Workstations and personal computers are increasingly being used for applications with real-time characteristics such as speech understanding and synthesis, media computations and I/O, and animation, often concurrently executed with traditional non-real-time workloads. This paper presents a system that can schedule multiple independent activities so that: . activities can obtain minimum guaranteed execution rates with application-specified reservation granularities via CPU Reservations, . CPU Reservations, which are of the form "reserve X units of time out of every Y units", provide not just an average case execution rate of X/Y over long periods of time, but the stronger guarantee that from any instant of time, by Y time units later, the activity will have executed for at least X time units, . applications can use Time Constraints to schedule tasks by deadlines, with on-time completion guaranteed for tasks with accepted constraints, and . both CPU Reservations and Time Constraints...

This thesis presents flexible abstractions for specifying resource management policies, together with efficient mechanisms for implementing those abstractions. Several novel scheduling techniques are introduced, including both randomized and deterministic algorithms that provide proportional-share control over resource consumption rates. Such control is beyond the capabilities of conventional schedulers, and is desirable across a broad spectrum of systems that service clients of varying importance. Proportional-share scheduling is examined for several diverse resources, including processor time, memory, access to locks, and disk bandwidth. Resource rights are encapsulated by abstract, first-class objects called tickets. An active client consumes resources at a rate proportional to the number of tickets that it holds. Tickets can be issued in different amounts and may be transferred between clients. A modular currency abstraction is also introduced to flexibly name, share, and protect ...

We present the design, implementation, and experimental results of our soft real time (SRT) system for multimedia applications in a general purpose UNIX environment. The SRT system supports several service classes for the real time processes based on their processor usage time pattern: periodic constant processing time(PCPT) class, aperiodic constant processing time(ACPT) class, variable processing time (VPT) class, and one-time constant processing time(OCPT) class. It also provides the following features: (1) reservation and timing guarantees for the service classes, (2) overrun protection among real time processes, (3) dynamic earliest deadline rst (EDF) algorithm for scheduling of multiple real time (RT) processes,(4) overrun scheduling algorithm, (5) system-initiated adaptation strategies, (6) probing service to estimate the amount of processing time needed prior to a reservation, (7) pro ling service to record and retrieve the processing time needed for a reservation, (8) synchronization support among concurrent and cooperating real time processes, and (9) guaranteed allocation for traditional time sharing (TS) processes. Another unique feature of the SRT system is its easy portability to any operating systems with real time extensions because it is implemented purely in the user space without any modi cations to the kernel. We have implemented the SRT system on top of the Solaris 2.6 operating system with scheduling overhead under 400us and with good performance guarantees. 1

In contemporary operating systems, continuous media (CM) applications are sensitive to the behaviour of other tasks in the system. This is due to contention in the kernel (or in servers) between these applications. To properly support CM tasks, we require “Quality of Service Firewalling” between different applications. This paper presents a memory management system supporting Quality of Service (QoS) within the Nemesis operating system. It combines application-level paging techniques with isolation, exposure and responsibility in a manner we call self-paging. This enables rich virtual memory usage alongside (or even within) continuous media applications. 1

Data Type. A collection of operations, each with a name and a signature defining the number and types of its arguments. application domain A domain whose purpose is to execute an application program. binding An association of a name with some value; in IDC, the local data structures for invoking an operation on an interface. class A set of objects sharing the same implementation. An object is an instance of exactly one class. closure The concrete realisation of an interface. A record containing two pointers, one to an operation table and the other to a state record. concrete type A data type whose structure is explicit. constructor An operation on an interface which causes the creation of an object, and returns the interfaces exported by the object. context A collection of bindings of names to values. context slot A data structure used to hold processor execution state within a domain. ix domain The entity which is activated by the kernel scheduler. Domains can be thought of a...

The goal of the Rialto project at Microsoft Research is to build a system architecture supporting coexisting independent real-time (and non-real-time) programs. Unlike traditional embedded-systems real-time environments, where timing and resource analysis among competing tasks can be done off-line, it is our goal to allow multiple independently authored real-time applications with varying timing and resource requirements to dynamically coexist and cooperate to share the limited physical resources available to them, as well as also coexisting with nonreal -time applications. This paper gives an overview of the Rialto real-time architecture as it is implemented today and reports on some of the early results obtained. In particular, it describes the use of time constraints, activities, CPU and other resource reservation, and the system resource planner, and how they work together to achieve our goal of providing a flexible, dynamic real-time computing environment. 1. Introduction The Ri...

Abstract not found

This paper is intended to catalyze discussions on two intertwined systems topics. First, it presents early results from a latency study of Windows NT that identifies some apecific causes of long thread scheduling latencies, many of which delay the diapatching of runnable threads' for tens of milliseconds'. Reasons for these delays', including technical, methodological, and economic are presented and possible solutions are discussed.

We present the design and implementation of a soft real time CPU server for the time-sensitive multimedia applications in the Windows NT environment. The server is a user-level daemon process from which multimedia applications can request and acquire periodic processing time in the well-known form of (processing time per period). Our server is based on a careful manipulation of the real time(RT) priority class, and it does not require any modifications to the kernel. It provides (1) the rate monotonic scheduling algorithm, (2) support for multiple processors (SMP model), (3) limited overrun protection among realtime(RT) processes, (4) fair allocation between the RT and time sharing (TS) processes so that TS processes are not starved for processing time, (5) accessibility by a normal user privilege, and (6) an efficient implementation. We have implemented the CPU scheduling server on top of the Windows NT 4.0 operating system with dual Pentium processors, and we have shown through experiments that our CPU scheduling server provides good soft real time support for the multimedia applications. 1.

. This paper describes ongoing investigations into algorithms for user-centric modular distributed real-time resource management. These investigations are being conducted in the context of the Rialto operating system -- an object-based real-time kernel and programming environment currently being developed within Microsoft Research. A primary goal of this research is to develop appropriate real-time programming abstractions to allow multiple independent real-time programs to dynamically coexist and share resources on the same hardware platforms. Use of these abstractions is intended both to allow individual applications to reason about their own resource requirements and for per-machine system resource planner applications to reason about and control resource allocations between potentially competing applications. The set of resources being managed is dynamically extensible, and may include remote resources in distributed environments. The local planner conducts resource negotiations wi...