This paper presents a uni-processor real-time scheduling algorithm called the generic utility scheduling algorithm (which we refer to simply as GUS). GUS solves a previously open real-time scheduling problem-scheduling application activities that have time constraints specified using arbitrarily shaped time/utility functions and have mutual exclusion resource constraints. A time/ utility function are a time constraint specification that describes an activity's utility to the system as a function of that activity's completion time. Given such time and resource constraints, we consider the scheduling objective of maximizing the total utility that is accrued by the completion of all activities. Since this problem is NP-hard, GUS heuristically computes schedules with a polynomial-time cost of O(n/sup 3/) at each scheduling event, where n is the number of activities in the ready queue. We evaluate the performance of GUS through simulation and by an actual implementation on a real-time POSIX operating system. Our simulation studies and implementation measurements reveal that GUS performs close to, if not better than, the existing algorithms for the cases that they apply. Furthermore, we analytically establish several properties of GUS.

We present an energy-efficient, utility accrual, real-time scheduling algorithm called ReUA. ReUA considers an application model where activities are subject to time/utility function time constraints, mutual exclusion constraints on shared non-CPU resources, and statistical performance requirements on individual activity timeliness behavior. The algorithm targets mobile embedded systems where system-level energy consumption is also a major concern. For such a model, we consider the scheduling objectives of (1) satisfying the statistical performance requirements and (2) maximizing the system-level energy efficiency, while respecting resource constraints. Since the problem is NP-hard, ReUA allocates CPU cycles using statistical properties of application cycle demands, and heuristically computes schedules with a polynomial time cost. We analytically establish several timeliness and nontimeliness properties of the algorithm. Further, our simulation experiments illustrate ReUA's effectiveness and superiority.

Heuristic algorithms have enjoyed increasing interests and success in the context of utility accrual (UA) scheduling. However, few analytical results, such as bounds on task-level and system-level accrued utilities are known. In this paper, we propose the S-UA algorithm that can provide probabilistic bounds on task-level accrued utilities. Lower bound on system-level accrued utility ratio (AUR) is also derived and maximized by S-UA.

We argue that the key underpinning of the current state-of-the real-time practice - the priority artifact - and that of the current state-of-the real-time art - deadline-based timeliness optimality - are entirely inadequate for specifying timeliness objectives, for reasoning about timeliness behavior, and for performing resource management that can dependably satisfy timeliness objectives in many dynamic real-time systems. We argue that time/utility functions and the utility accrual scheduling paradigm provide a more generalized, adaptive, and flexible approach. Recent research in the utility accrual paradigm has significantly advanced the state-of-the-art of that paradigm. We survey these advances.

We consider Real-Time CORBA 1.2's distributable threads (DTs), whose time constraints are specified using time/utility functions (TUFs), operating in legacy environments. In legacy environments, system node resources - both physical and logical - are shared among time-critical DTs and local applications that may also be time-critical. Hence, DTs that are scheduled using their propagated TUFs, as mandated by Real-Time CORBA 1.2's Case 2 approach, may suffer performance degradation, if a node utility accrual (UA) scheduler achieves higher locally accrued utility by giving higher eligibility to local threads than to DTs. To alleviate this, we consider decomposing TUFs of DTs into "sub-TUFs" for scheduling segments of DTs. We present five decomposition techniques, called UT, SCEQF, SCALL, OPTCON, and TUFS, which are specific to different classes of UA scheduling algorithms, such as those that use utility density and those that use deadline as their key decision metric. Our experimental studies identify the decomposition technique that performs best for each class of UA scheduling algorithms. In particular, our studies show that OPTCON and TUFS perform best for utility density-based UA algorithms, while SCEQF and SCALL perform best for deadline-based UA algorithms.

We present an energy-efficient real-time scheduling algorithm called the Resource-constrained Energy-Efficient Utility Accrual Algorithm (or ReUA). ReUA considers an application model where activities are subject to time/utility function-time constraints, resource dependencies including mutual exclusion constraints, and statistical performance requirements including probabilistically satisfied, activity (timeliness) utility bounds. Further, ReUA targets mobile embedded systems where system-level energy consumption is a major concern. For such a model, we consider the scheduling objectives of (1) satisfying statistical performance requirements, and (2) maximizing system-level energy efficiency, while respecting resource dependencies. Since the problem is NP-hard, ReUA allocates resources using statistical properties of application cycle demands and heuristically computes schedules with a polynomial-time cost. We analytically establish several timeliness and non-timeliness properties of the algorithm. Further, our simulation experiments illustrate ReUA's effectiveness.

This paper presents two fast, best-effort real-time scheduling algorithms called MDASA and MLBESA. MDASA and MLBESA are novel in the way that they heuristically, yet accurately, mimic the behavior of the DASA and LBESA scheduling algorithms, but are faster with O(n) and O(n lg(n)) worst-case complexities, respectively. Experimental results show that the performance of MDASA and MLBESA, in general, is close to that of DASA and LBESA, respectively, for a broad range of realistic workloads. However, for a highly bursty workload, MLBESA is found to perform worse than LBESA. Furthermore, the task response times under MDASA and MLBESA are very close to the values under their counterpart scheduling algorithms. Thus, MDASA and MLBESA can substitute for DASA and LBESA algorithms, respectively, in adaptive resource allocation techniques for asynchronous real-time distributed systems where DASA and LBESA have previously been serious bottlenecks on computational costs.

We present two proactive resource allocation algorithms, called DPR and LPR, for satisfying the timeliness requirements of real-time tasks in asynchronous real-time distributed systems. The algorithms are proactive in the sense that they allow application-specified and user-triggered resource allocation by allowing anticipated task workloads to be specified for future time intervals. When proactively triggered, the algorithms allocate resources to maximize the aggregate deadline-satisfied ratio for the future time interval under the anticipated workload. While DPR uses the earliest deadline first scheduling algorithm as the underlying algorithm for process scheduling and packet scheduling, LPR uses a modified least laxity first scheduling algorithm. We show that LPR is computationally more expensive than DPR. Further, our experimental studies reveal that LPR yields a higher deadline-satisfied ratio than DPR.

We present a framework, called meta scheduler, for implementing real-time scheduling algorithms. The meta scheduler is a portable middleware layer component designed for implementations over POSIX-compliant operating systems. It accommodates pluggable real-time scheduling algorithms while offering the flexibility of platform independence - the singular underlying OS requirement is the now nearly ubiquitous POSIX compliance. The versatility of pluggable schedulers positions the meta scheduler for deployment in an interoperable heterogeneous real-time environment. We present the design of the meta scheduler and outline its implementation. Furthermore, we present a mechanized correctness verification using the UPPAAL model checker. Prototype implementation of the meta scheduler over QNX Neutrino real-time operating system demonstrates high performance and a small footprint.

Asynchronous real-time distributed systems are inherently non-deterministic. To deal with such non-determinism's, we have developed a family of proactive resource management algorithms that support benefit-function based, end-to-end QoS management. This paper describes a middleware implementation of these algorithms, called Choir. The Choir middleware allows the user express the task end-to-end timeliness requirements using Jensen's benefit functions. Furthermore, the middleware system can transparently replicate, and possibly migrate the computational subtasks to conquer uncertainties such as workload fluctuations, changes of system resources, so that the system aggregate benefit is maximized. Initial experimental results suggest the effectiveness the Choir middleware.

In this paper, we present a systems engineering methodology for constructing certifiable realtime distributed systems. In the proposed approach, an architectural and algorithmic solution to an application problem is designed by considering the "weakest" models including the weakest asynchronous computational model and multimodal arrival model. Furthermore, timeliness properties are described using Jensen's benefit accrual predicates. Once a system solution is designed, timeliness properties are established by constructing necessary feasibility conditions that are expressed as non-valued predicates. The predicates are quantified and verified to produce the specification of a certified solution. We illustrate the approach by considering a packet transmission problem that desire soft timeliness. We present a certifiable solution to this problem that consists of switched Ethernet, a soft real-time packet scheduling algorithm (that was previously developed), and feasibility conditions.

This paper describes an implementation and the performance evaluation of the DASAATD best-effort scheduling algorithm [4] in the pC1id/pCsinunm micro-controller system Experimental results under synthetic wrkload show that in some cases, the DASALND scheduler outperfom both the EDF (Earliest Deadline First) and the RMS (Rate Monotonic Scheduling) schedulers [7]. Meanwhile, the system performance gracefully degrades as the aggregate CPU Load increases. However, the scheduling overhead in general, is not negligible, which may lead to poorer performance than non best-effort scheduling algorithms. It is found that the schealuling overhead strongly depends on the task set properties. Using the Regression Analysis technique, we developed a statistical model accounting for the scheduling overhead We show that this model, combined with a simulation tool can well predict the system performance.