Krithivasan Ramamritham

Scheduling Tasks with Resource Requirements in Hard Real-Time Systems

This paper describes a heuristic approach for solving the problem of dynamically scheduling tasks in a real-time system where tasks have deadlines and general resource requirements. The crux of our approach lies in the heuristic function used to select the task to be scheduled next. The heuristic function is composed of three weighted factors. These factors explicitly consider information about real-time constraints of tasks and their utilization of resources. Simulation studies show that the weights for the various factors in the heuristic function have to be fine-tuned in order to obtain a degree of success in the range of 75-88 percent of that obtained via exhaustive search. However, modifying the approach to use limited backtracking improves the degree of success substantially to as high as 99.5 percent. This improvement is observed even when the initial set of weights are not tailored for a particular set of tasks. Simulation studies also show that in most cases the schedule determined by the heuristic algorithm is optimal or close to optimal.

Evaluation of a flexible task scheduling algorithm for distributed hard real-time systems

Most systems which are required to operate under severe real-time constraints assume that all tasks and their characteristics are known a priori. Scheduling of such tasks can be done statistically. Further, scheduling algorithms operating under such conditions are usually limited to multiprocessor configurations. The authors present a scheduling algorithm which works dynamically and on loosely coupled distributed systems for tasks with hard real-time constraints; i.e., the tasks must meet their deadlines. It uses a scheduling component local to every node and a distributed scheduling scheme which is specifically suited to hard real-time constraints and other timing considerations. Periodic tasks, nonperiodic tasks, scheduling overheads, communication overheads due to scheduling and preemption are all accounted for in the algorithm. Simulation studies are used to evaluate the performance of the algorithm.

Specification of Synchronizing Processes

The formalism of temporal logic has been suggested to be an appropriate tool for expressing the semantics of concurrent programs. This paper is concerned with the application of temporal logic to the specification of factors affecting the synchronization of concurrent processes. Towards this end, we first introduce a model for synchronization and axiomatize its behavior. SYSL, a very high-level language for specifying synchronization properties, is then described. It is designed using the primitives of temporal logic and features constructs to express properties that affect synchronization in a fairly natural and modular fashion. Since the statements in the language have intuitive interpretations, specifications are humanly readable. In addition, since they possess appropriate formal semantics, unambiguous specifications result.

A Completely Integrated Approach to Developing, Implementing, Evaluating Distributed Active Database Management and its OS Support

Abstract This paper constitutes a work-in-progress report on the first, mostly conceptual phase of a major international effort in building and evaluating a distributed testbed for database application systems in safetycritical real-time environments. Given that safety/ reliability requirements and real-time constraints are in conflict there cannot be a closed form solution or design, and all system functions have to dynamically adapt to the unpredictable environmental situation in safety-critical real-time systems. Over the past years groups headed by the authors had pursued novel concepts and approaches on a novel tailored LINUX kernel, safety-critical application operating system support (MELODY project) and Active Database levels (concurrency control under data replication). In the research project a complete integration of these achievements from the basic OS kernel through the application levels is the major theme. While quite a number of research and design problems stemming from the partial insights or incomplete functionality on the various levels posed serious challenges the integration itself requires. and gives rise to, extensions, modifications, or refinements of the functions involved for ensuring system survivability. The paper will describe the technical details of these implications from the integration for the whole project as well as the stepwise design and evaluation of the different functions and models.- To our knowledge this is the first fully integrative attempts in the area of distributed safety-critical real-time systems.

Privilege transfer and revocation in a port-based system

Gutenberg is a port-based operating system being designed to study protection issues in distributed systems. All shared resources are viewed as protected objects and hence can be assessed only via specific operations defined on them. Processes communicate and access objects through the use of ports. Each port is associated with an abstract data type operation and can be created by a process only if the process has the capability to execute the operation on the type. Thus, a port represents the privilege of the ports client process to request a service. Capabilities to create ports for requesting operations are contained in a capability directory, which is navigated by processes to gain these capabilities. Privilege transfer is a means of providing servers access to the resources they need to perform their services. In Gutenberg, privilege transfer is accomplished by allowing access to subdirectories of the capability directory and by passing capabilities, including port access capabilities, to processes via ports. It should be possible to revoke transferred privileges when breaches of trust are detected or suspected, when a period of time has passed beyond which the distributor of a privilege does not want the privilege shared, or when an error has been detected.

Synthesizing Code for Resource Controllers

A distributed system is viewed as a set of objects and processes utilizing the objects. If a shared object, known as a resource, is accessed concurrently, some mechanism is necessary to control use of the resource in order to satisfy the consistency and fairness requirements associated with the resource. These mechanisms are termed resource controllers.

Functional addressing in Gutenberg: Interprocess communication without process identifiers

An interprocess communication facility provided by the kernel of the Gutenberg experimental operating system is presented. In Gutenberg all interprocess communication is via channels (ports) that are typed by the service which can be requested on them. Ports are created by reference to their service without using the identifier of the process providing the service, a technique the authors refer to as functional addressing. By using functional addressing, interprocess transfer of port use privileges and a new concept of cooperation class, arbitrary process interconnection topologies can be achieved without any explicit use of process identifiers by processes. Examples of object sharing with abstract data type managers and data-driven protocols of database query execution are presented to illustrate the methods of constructing systems of cooperation processes using the Gutenberg system.

On synchronization and its specification

We introduce a very high level language for specifying synchronization properties. It is designed using the primitives of temporal logic which facilitates the specification of both invariant and time-dependent properties. The paper begins with a discussion of properties that affect synchronization. The specification language then introduced features constructs to express each of these in a fairly natural and modular fashion. Since the statements in the language have intuitive interpretations, specifications are humanly readable. Also, since they possess appropriate formal semantics, unambiguous specifications result.

Verification of resource controller processes

Shared resources and the processes that control them play a critical role in the functioning of concurrent systems. A shared resource is viewed as an abstract data type consisting of the definition of the resource and the operations on it, with additional synchronization constraints. Here we present a technique for verifying resource controllers using the formalism of temporal logic. Properties of the operations on a given shared resource are first verified. This is followed by the verification of invariant and liveness properties of the controller. The technique is illustrated by its application to resource controller tasks in Ada. As a prerequisite for accomplishing this, we specify the semantics of Ada tasking primitives.

Enabling local actions by global consensus

Presented is an algorithm for determining whether total global consensus exists for a process to execute a local action that has interaction constraints. The algorithm assumes a virtual ring of processes each of which possesses a token. Multiple processes can simultaneously attempt and succeed in performing actions that do not constrain each other, thus exploiting the available parallelism. The algorithm can be tailored to handle any situation in which the action of one process is constrained by actions of other processes and where total global consensus is required. The use of execution time estimates and information concerning the attempts and activities of other processes reduces the number of failed attempts and hence unnecessary communication.