Johann Blieberger

Discrete loops and worst case performance

Abstract In this paper so-called discrete loops are introduced which narrow the gap between general loops (e.g. while- or repeat-loops) and for-loops. Although discrete loops can be used for applications that would otherwise require general loops, discrete loops are known to complete in any case. Furthermore it is possible to determine the number of iterations of a discrete loop, while this is trivial to do for for-loops and extremely difficult for general loops. Thus discrete loops form an ideal frame-work for determining the worst case timing behavior of a program and they are especially useful in implementing real-time systems and proving such systems correct.

Data-Flow Frameworks for Worst-Case Execution Time Analysis

The purpose of this paper is to introduce frameworks based on data-flow equations which estimate the worst-case execution time (WCET) of real-time programs. These frameworks allow several different WCET analysis techniques with various precisions, which range from naïve approaches to exact analysis, provided exact knowledge on the program behavior is available. In addition, data-flow frameworks can also be used for symbolic analysis based on information derived automatically from the source code of the program.

Symbolic Data Flow Analysis for Detecting Deadlocks in Ada Tasking Programs

It is well accepted that designing and analyzing concurrent software-components are tedious tasks. Assuring the quality of such software requires formal methods, which can statically detect deadlocks. This paper presents a symbolic data flow analysis framework for detecting deadlocks in Ada programs with tasks. The symbolic data flow framework is based on symbolic evaluation – an advanced technique to statically determine properties of programs.

Symbolic pointer analysis for detecting memory leaks

It is well accepted that pointers are a common source of memory anomalies such as loosing references to dynamic records without deallocating them (also known as memory leaks). This paper presents a novel pointer analysis framework that detects memory leaks by statically analyzing the behavior of programs. Our approach is based on symbolic evaluation of programs. Symbolic evaluation is an advanced static symbolic analysis that is centered around symbolic variable values, assumptions about and constraints between variable values, and control flow information (path conditions). As part of symbolic evaluation we introduce a new symbolic heap algebra for modeling heap operations. Predicates — defined over the programs input — are derived which allow to detect memory leaks. Our approach goes beyond previous work in the field of statically detecting memory leaks by considering also path conditions which increases the accuracy of our results, symbolically modeling heap data structures and heap operations. Examples are used to illustrate the effectiveness of our approach.

Symbolic Cache Analysis for Real-Time Systems

Caches impose a major problem for predicting execution times of real-time systems since the cache behavior depends on the history of previous memory references. Too pessimistic assumptions on cache hits can obtain worst-case execution time estimates that are prohibitive for real-time systems. This paper presents a novel approach for deriving a highly accurate analytical cache hit function for C-programs at compile-time based on the assumption that no external cache interference (e.g. process dispatching or DMA activity) occurs. First, a symbolic tracefile of an instrumented C-program is generated based on symbolic evaluation, which is a static technique to determine the dynamic behavior of programs. All memory references of a program are described by symbolic expressions and recurrences and stored in chronological order in the symbolic tracefile. Second, a cache hit function for several cache architectures is computed based on a cache evaluation technique. Our approach goes beyond previous work by precisely modelling program control flow and program unknowns, modelling large classes of cache architectures, and providing very accurate cache hit predictions. Examples for the SPARC architecture are used to illustrate the accuracy and effectiveness of our symbolic cache prediction.

Worst-case space and time complexity of recursive procedures

The purpose of this paper is to show that recursive procedures can be used for implementing real-time applications without harm, if a few conditions are met. These conditions ensure that upper bounds for space and time requirements can be derived at compile time. Moreover they are simple enough such that many important recursive algorithms can be implemented, for example Mergesort or recursive tree-traversal algorithms.In addition, our approach allows for concentrating on essential properties of the parameter space during space and time analysis. This is done by morphisms that transfer important properties from the original parameter space to simpler ones, which results in simpler formulas of space and time estimates.

Reliable Software Technologies — Ada-Europe 2002

Separating different aspects of a program, and encapsulating them inside well defined modules, is considered a good engineering discipline. This discipline is particularly desirable in the development of distributed agreement algorithms which are known to be difficult and error prone. For such algorithms, one aspect that is important to encapsulate is failure detection. In fact, a complete encapsulation was proven to be feasible in the context of distributed systems with process crash failures, by using black-box failure detectors. This paper discusses the feasibility of a similar encapsulation in the context of Byzantine (also called arbitrary or malicious) failures. We argue that, in the Byzantine context, it is just impossible to achieve the level of encapsulation of the original crash failure detector model. However, we also argue that there is some room for an intermediate approach where algorithms that solve agreement problems, such as consensus and atomic broadcast, can still benefit from grey-box failure detectors that partially encapsulate Byzantine failure detection.

Real-time properties of indirect recursive procedures

The purpose of this paper is to show that indirect recursive procedures can be used for implementing real-time applications without harm, if a few conditions are met. These conditions ensure that upper bounds for space and time requirements can be derived at compile time. Moreover they are simple enough such that many important recursive algorithms can be implemented. In addition, our approach allows for concentrating on essential properties of the parameter space during space and time analysis. This is done by morphisms that transfer important properties from the original parameter space to simpler ones, which results in simpler formulas of space and time estimates. 2001 Elsevier Science

Timing Analysis of Concurrent Programs

Worst-case execution time analysis of multi-threaded software is still a challenge. This comes mainly from the fact that the number of thread interleavings grows exponentially in the number of threads and that synchronization has to be taken into account. In particular, a suitable graph based model has been missing. The idea that thread interleavings can be studied with a matrix calculus is a novel approach in this research area. Our sparse matrix representations of the program are manipulated using Kronecker algebra. The resulting graph represents the multi-threaded program and plays a similar role for concurrent systems as control flow graphs do for sequential programs. Thus a suitable graph model for timing analysis of multi-threaded software has been set up. Due to synchronization it turns out that often only very small parts of the resulting graph are actually needed, whereas the rest is unreachable. A lazy implementation of the matrix operations ensures that the unreachable parts are never calculated. This speeds up processing significantly and shows that our approach is very promising.

Some investigations on FCFS scheduling in hard real time applications

We investigate some real time behaviour of a (discrete time) single server system with FCFS task scheduling. The main results deal with the probability distribution of a random variable SRD(T), which describes the time the system operates without violating a fixed task service time deadline T. The tree approach used for the derivation of our results is suitable for revisiting problems already solved by queueing theory, too. Relying on a simple general probability model, asymptotic formulas concerning all moments of SRD(T) are determined; for example, the expectation of SRD(T) is proved to grow exponentially in T, i.e., E[SRD(T)] ∼ C · κT for some κ > 1.