Worst-case Response Time Research Articles

Analysis of cache-related preemption delay in fixed-priority preemptive scheduling

We propose a technique for analyzing cache-related preemption delays of tasks that cause unpredictable variation in task execution time in the context of fixed-priority preemptive scheduling. The proposed technique consists of two steps. The first step performs a per-task analysis to estimate cache-related preemption cost for each execution point in a given task. The second step computes the worst case response time of each task that includes the cache-related preemption delay using a response time equation and a linear programming technique. This step takes as its input the preemption cost information of tasks obtained in the first step. This paper also compares the proposed approach with previous approaches. The results show that the proposed approach gives a prediction of the worst case cache-related preemption delay that is up to 60 percent tighter than those obtained from the previous approaches.

Vertical framing of superimposed signature files using partial evaluation of queries

A new signature file method, Multi-Frame Signature File (MFSF), is introduced by extending the bit-sliced signature file method. In MFSF, a signature file is divided into variable sized vertical frames with different on-bit densities to optimize the response time using a partial query evaluation methodology. In query evaluation the on-bits of the lower on-bit density frames are used first. As the number of query terms increases, the number of query signature on-bits in the lower on-bit density frames increases and the query stopping condition is reached in fewer evaluation steps. Therefore, in MFSF, the query evaluation time decreases for increasing numbers of query terms. Under the sequentiality assumption of disk blocks, in a PC environment with 30 ms average disk seek time, MFSF provides a projected worst-case response time of 3.54 seconds for a database size of one million records in a uniform distribution multi-term query environment with 1–5 terms per query. Due to partial evaluation, this desired response time is guaranteed for queries with several terms. The comparison of MFSF with the inverted file approach shows that MFSF provides promising research opportunities.

Minimizing the effects of jitter in distributed hard real-time systems

In this paper we present a study of the effects caused on distributed real-time systems by the presence of jitter in the activation of tasks and messages. We show that although jitter has usually a small impact on the schedulability of single-processor systems, in distributed architectures the worst-case response times are significantly delayed. Reducing or eliminating jitter in these systems can increase the schedulability of the system up to 50% more than when jitter is permitted. The delay effects caused by jitter can be prevented by using a bandwidth-preserving scheduling algorithm such as the sporadic server. Since this kind of scheduling policy is not designed for communication networks, we describe in this paper how to adapt and implement the sporadic server algorithm on communication networks. Using the sporadic server both in the processors and networks, we can build distributed systems with up to 100% utilization of the CPUs and communication resources, while still guaranteeing that hard real-time requirements are met.

On-line Scheduling with Optimal Worst-Case Response Time

On-line Scheduling with Optimal Worst-Case Response Time

Calculating controller area network (can) message response times

Controller Area Network (CAN) is a well-designed communications bus for sending and receiving short real-time control messages at speeds of up to 1Mbit/sec. One of the perceived drawbacks to CAN has been the inability to bound accurately the worst-case response time of a given message (i.e., the longest time between queueing the message and the message arriving at the destination processors). This paper presents an analysis to bound such latencies. A benchmark is used to illustrate the application of this analysis.

Effective analysis for engineering real-time fixed priority schedulers

There has been considerable activity in recent years in developing analytical techniques for hard real-time systems. Inevitably these techniques make simplifying assumptions so as to reduce the complexity of the problem to be solved. Unfortunately this leads to a gap between theory and engineering practice. The paper presents new analysis that enables the costs of the scheduler (clock overheads, queue manipulations and release delays) to be factored into the standard equations for calculating worst-case response times. As well as predicting the true behavior of realistic systems, the analysis also allows free parameters, such as clock interrupt rate, to be determined.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Calculating controller area network (CAN) message response times

Controller Area Network (CAN) is a well designed communications bus for sending and receiving short real-time control messages at speeds of up to 1Mbit/sec. One of the perceived drawbacks to CAN has been the inability to bound accurately the worst-case response time of a given message (i.e. the longest time between queueing the message and the message arriving at the destination processors). This paper presents analysis to bound such response times, including the costs of error handling and re-transmission.

Fixed Priority Scheduling of Hard Real-time Multi-media Disk Traffic

In this paper we show how existing real-time scheduling theory, developed to analyse the behaviour of tasks executing on processing resources, can be applied to the problem of guaranteeing the performance of multi-media information streams read from a disk system. Analysis is derived that takes into account disk layout and predicts the worst-case response times for disk requests. It is shown how buffer size, priority of request and size of non-pre-emptable operations all crucially affect behaviour. The object of the paper is to define an effective run-time test that can be used to determine if new streams can be accommodated

Formal timing analysis for distributed real-time programs

A static analysis method for verifying timing properties of real-time distributed programs is presented. The goal is to calculate the worst-case response time of concurrent tasks which run mainly independently but share, and may have to wait for, logical or physical devices. For such tasks, the determination of the worst-case waiting time is a crucial problem because of the unpredictable order of synchronization events. We investigate the class of distributed Client-Server programs in which independent, time-critical tasks (clients) are synchronized only through additional server tasks, playing the role of monitors or resource managers. This model follows well-known real-time design guidelines for distributed ADA programs proposed to enhance schedulability and synchronization analysis. Our formal analysis approach is flow graph oriented. It leads to generating reduced program paths each of which represents a sequence of ordered local and global operations, thus transforming and reducing the original problem of computing the worst-case waiting time of a concurrent task into a graph-theoretic problem of calculating the maximal blocking time for one of its corresponding program paths. While local operations are completely independent global operations require mutually exclusive access to shared resources. We prove that computing the worst-case blocking time for a program path is NP-complete. Even for a reduced problem solution—which would yield a good upper bound for the worst-case blocking time—there was a conjecture maintained over many years that this problem was NP-complete. A major result of this paper is to show that this is wrong. Instead, we construct a polynomial solution algorithm, and we prove its correctness. The effectiveness and complexity of our method are discussed, with particular emphasis on distributed real-time debugging.

Sequential consistency versus linearizability

The power of two well-known consistency conditions for shared-memory multiprocessors,sequential consistencyandlinearizability, is compared. The cost measure studied is the worst-case response time in distributed implementations of virtual shared memory supporting one of the two conditions. Three types of shared-memory objects are considered: read/write objects, FIFO queues, and stacks. If clocks are only approximately synchronized (or do not exist), then for all three object types it is shown that linearizability is more expensive than sequential consistency. We show that, for all three data types, the worst-case response time is very sensitive to the assumptions that are made about the timing information available to the system. Under the strong assumption that processes have perfectly synchronized clocks, it is shown that sequential consistency and linearizability are equally costly. We present upper bounds for linearizability and matching lower bounds for sequential consistency. The upper bounds are shown by presenting algorithms that use atomic broadcast in a modular fashion. The lower-bound proofs for the approximate case use the technique of “shifting,” first introduced for studying the clock synchronization problem.

Logically instantaneous message passing in asynchronous distributed systems

Asynchrony (due to unknown message transmission delay) complicates the design of protocols for distributed systems. To simplify the protocol design task therefore, the authors propose an interprocess (point-to-point) communication mechanism that has the characteristic of instantaneous message passing. They first establish a hierarchy among synchronization properties, which shows that to ensure the logically instantaneous message passing property it is not always necessary to use a rendezvous mechanism. Next, they propose a solution to the logically instantaneous message passing problem that is more efficient than R. Bagrodia's (1989) rendezvous and K.J. Goldman's (1991) logically synchronous multicast in the point-to-point (single-cast) setting. This algorithm has the following properties: it is applicable without deadlock to the partner model in which each process acts as both client and server; it requires three control messages to send an application message, which is shown to be quasioptimum message complexity; and its worst-case response time from a send request to the occurrence of the corresponding send event is 2k/spl Delta/ (sec.), where k is the maximum number of interfering send requests and /spl Delta/ (sec.) is an assumed upper bound on interprocess communication delay. Furthermore, two modified algorithms are proposed: one for reducing the number of control messages required for an application message, and the other for attaining a shorter average response time by using a randomization technique.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Time Bounds for Real-Time Process Control in the Presence of Timing Uncertainty

A timing-based variant of the mutual exclusion problem is considered. In this variant, only an upper bound, m, on the time it takes to release the resource is known, and no explicit signal is sent when the resource is released; furthermore, the only mechanism to measure real time is an inaccurate clock, whose tick intervals take time between two constants, c1 ≤ c2. When control is centralized it is proved that n[c2(⌊(m+l)/c1⌋+1)]+l is an exact bound on the worst case response time for any such algorithm, where n is the number of contenders for the resource and l is an upper bound on process step time. On the other hand, when control is distributed among processes connected via communication lines with an upper bound, d, for message delivery time, it is proved that n[c2(⌊(m+l)/c1⌋+1)+d+c2+2l] is an upper bound. A new technique involving shifting and shrinking executions is combined with a careful analysis of the best allocation policy to prove a corresponding lower bound of n·c2(m/c1)+(n−1)d. These combinatorial results shed some light on modeling and verification issues related to real-time systems.

Holistic schedulability analysis for distributed hard real-time systems

This paper extends the current analysis associated with static priority pre-emptive based scheduling to address the wider problem of analysing schedulability of a distributed hard real-time system; in particular it derives analysis for a distributed system where tasks with arbitrary deadlines communicate by message passing and shared data areas. A simple TDMA protocol is assumed, and analysis developed to bound not only the communications delays, but also the delays and overheads incurred when messages are processed by the protocol stack at the destination processor. The paper illustrates how a window-based analysis technique can be used to find the worst-case response times of a distributed task set. An extended example illustrating the application of the analysis is presented.

An extendible approach for analyzing fixed priority hard real-time tasks

As the real-time computing industry moves away from static cyclic executive-based scheduling towards more flexible process-based scheduling, so it is important for current scheduling analysis techniques to advance and to address more realistic application areas. This paper extends the current analysis associated with static priority pre-emptive based scheduling; in particular it derives analysis for tasks with arbitrary deadlines that may suffer release jitter due to being dispatched by a tick driven scheduler. We also consider bursty sporadic activities, where tasks arrive sporadically but then execute periodically for some bounded time. The paper illustrates how a window-based analysis technique can be used to find the worst-case response time of a task set, and shows that the technique can be easily extended to cope with realistic and complex task characteristics.

File allocation involving worst case response times and link capacities: Model and solution procedure

A major design issue facing the designer of a distributed computing system involves the determination of the number of file copies and their locations in the distributed environment. This problem is commonly referred to as the file allocation problem (FAP). In this paper, a FAP model is formulated that seeks to obtain the lowest cost file allocation strategy, that ensures the attainment of acceptable levels of response times during peak demand periods, for all on-line queries. Unlike previous FAP research, the proposed model treats response time on a query-by-query basis, and not as a single, system wide average delay constraint. A Laggrangian relaxation based solution procedure is proposed for the resulting 0/1 integer programming problem. Results of computational experiments with the proposed solution procedure are reported.

THE RELATION BETWEEN ORDINAL PROBLEM SPACE SIZES AND THE MAXIMUM NUMBER OF ORDINAL CLASSIFICATION RULES

A method is presented of establishing bounds on the number of classification rules in such applications as credit worthiness assessment, investment decisions, premium determination, consumer choices, employee selection, and editorial preferences, to name just a few. A function that relates the maximum number of classification rules to the problem space size of such application domains is established. It is shown that in this important class of ordinal classification problems, the maximum possible number of rules is significantly lower than the relative problem space sizes. The approach grants the ability to a priori estimate worst case response time and memory requirements, and to better predict the effectiveness of knowledge acquisition efforts.

Formal Timing Analysis of Distributed Real-Time Programs

For verifying timing properties of real-time distributed programs we investigate the worst-case response time of concurrent tasks which run independently but share logical or physical devices. For such tasks, a crucial factor for predicting the worst-case response time is to estimate the time spent waiting for synchronization events. We study the class of Client-Server distributed programs in which independent, time-critical tasks (Clients) are synchronized only through additional Server tasks, as recently suggested in real-time design guidelines proposed to enhance schedulability and synchronization analysis. Focussing on the timing analysis we reduce the general analysis problem to studying reduced program paths in terms of flow graphs in which the arcs are labelled with minimum and maximum execution time estimates. The first formal result shows that the problem of evaluating the worst-case waiting (blocking) time is NP-compIete. For a reduced problem version in which only operations involving communication are considered a conjecture was held that even for only 2 tasks the evaluation of the worst-case blocking time was NP-complete. We disprove this by constructing, and proving correct, a polynomial algorithm for its closed form solution which works even for an arbitrary number of tasks. The effectiveness and complexity of this algorithm are discussed, also regarding the quality of of the solutions as upper bounds for the original timing analysis problem.

Two theses of knowledge representation: Language restrictions, taxonomic classification, and the utility of representation services

Levesque and Brachman argue that in order to provide timely and correct responses in the most critical applications, general-purpose knowledge representation systems should restrict their languages by omitting constructs which require nonpolynomial worst-case response times for sound and complete classification. They also separate terminological and assertional knowledge, and restrict classification to purely terminological information. We demonstrate that restricting the terminological language and classifier in these ways limits these “general-purpose” facilities so severely that they are no longer generally applicable. We argue that logical soundness, completeness, and worst-case complexity are inadequate measures for evaluating the utility of representation services, and that this evaluation should employ the broader notions of utility and rationality found in decision theory. We suggest that general-purpose representation services should provide fully expressive languages, classification over relevant contingent information, “approximate” forms of classification involving defaults, and rational management of inference tools.

Finding Response Times in a Real-Time System

There are two major performance issues in a real-time system where a processor has a set of devices connected to it at different priority levels. The first is to prove whether, for a given assignment of devices to priority levels, the system can handle its peak processing load without losing any inputs from the devices. The second is to determine the response time for each device. There may be several ways of assigning the devices to priority levels so that the peak processing load is met, but only some (or perhaps none) of these ways will also meet the response-time requirements for the devices. In this paper, we define a condition that must be met to handle the peak processing load and describe how exact worst-case response times can then be found. When the condition cannot be met, we show how the addition of buffers for inputs can be useful. Finally, we discuss the use of multiple processors in systems for real-time applications.