Abha Moitra

Derivation of a parallel algorithm for balancing binary trees

A recent trend in program methodologies is to derive efficient parallel programs from sequential programs. This study explores the question of transforming a sequential algorithm into an efficient parallel algorithm by considering the problem of balancing binary search trees. The derivation of the parallel algorithm makes use of stepwise refinement. The authors first derive a new iterative balancing algorithm that exploits the similarity of point restructuring required at all the nodes at the same level. From this they derive a parallel algorithm that has time complexity O(1) on an N-processor configuration. This achieves the theoretical limit of speedup possible in a multiprocessor configuration.

Proof rules for fault tolerant distributed programs

Abstract Proving the properties of a program which must execute on a distributed system whose nodes may fail is a complex task. Such proofs must take into account the effects of hardware failures at all possible points in the execution of individual processes. The difficulty in accomplishing this is compounded by the need to cater also for the simultaneous failure of two or more processing nodes. In this paper, we consider programs written in a version of Hoares CSP and define a set of axioms and inference rules by which proofs can be constructed in three steps: proving the properties of each process when its communicants are prone to failure, establishing the effects of failure of each process, and combining these two steps to determing the fault tolerant properties of the whole program. The proof system is thus compositional, in the sense that proofs can be constructed in a modular way.

A Maximally Parallel Balancing Algorithm for Obtaining Complete Balanced Binary Trees

We present a new iterative balancing algorithm for binary trees of size N = 2n -1 by exploiting the similarity of pointer restructuring at each level. We also extract parallelism from this algorithm to yield a constant time complexity balancing algorithm for an N-processor configuration. This achieves the theoretical limit of speedup possible.

Parallel algorithms for some computational problems

Publisher Summary The chapter presents a survey of parallel algorithms for finding the connected and biconnected components of a graph. The chapter classifies the various parallel algorithms for finding the connected components of undirected graphs according to two major criteria: the basic technique employed and the format of the input. The basic techniques used in these algorithms are breadth-first search, transitive closure, and vertex collapse. The most common form of input is adjacency matrix. The chapter presents several parallel minimum spanning tree algorithms for different types of parallel computational models. A minimum spanning tree of a weighted, connected, and undirected graph is defined as a set of edges of the graph that connects all vertices and whose total edge weight is minimum. The chapter discusses various other parallel graph algorithms for shortest path, maximum matching, planarity testing, and maximal independent set. It describes parallel algorithms for various nongraph-theoretic problems like arithmetic expression and polynomial evaluation, string matching, tree balancing, and alpha-beta search.

Multilevel data structures: models and performance

A stepwise method of deriving the high-performance implementation of a set of operations is proposed. This method is based on the ability to organize the data into a multilevel data structure to provide an efficient implementation of all the operations. Typically, for such data organization the performance may deteriorate over a period of time and that can be corrected by reorganizing the data. This data reorganization is done by the introduction of maintenance processes. For a particular example, the multilevel data organization and the different models of maintenance processes possible are considered. The various models of maintenance process provide varying amounts of concurrency by varying the degree of atomicity in different operations. Performance behavior for the different models is derived and a correctness proof for the developed implementation is outlined. >

Scheduling of Hard Real-Time Systems

In this paper we study hard real-time systems: systems where strict time deadlines have to be met. We analyze a special case as well as a general model for hard real-time systems and study pre-emptive, static, scheduling policies for a single processor. The analysis is exact and can handle any arbitrary choice of strict deadlines thereby allowing us to prove the correctness of critical systems. For both the special and general model we present a feasible scheduling algorithm; that is a scheduling algorithm that always produces a priority assignment where all deadlines are met if such a priority assignment exists.

Automatic construction of CSP programs from sequential non-deterministic programs

Abstract In this paper we describe a systematic method for transforming a sequential program, written in a guarded command language, into a distributed program, written in CSP. The variables of the sequential program are first partitioned into n disjoint sets, and then the program is transformed into CSP program of n communicating processes. The two versions of the program are shown to be strongly equivalent , in the sense that they exhibit the properties of reaching the same final states and of either aborting, terminating, or running forever. We also discuss the conditions under which, when compared to the executiion of the original sequential program, a speed-up in the execution of the resulting distributed program can be achieved.

Algebraic specification of a communcation scheduler

A distributed programming language normally incorporates one mechanism by which processes communicate with each other. This mechanism can be used to transfer information or to synchronize the flow of control in the program. Different communication mechanisms have been proposed for different languages. In this paper, we provide a common framework in which these mechanisms can be examined independently of the languages in which they may be embedded. Operationally, this framework is a communication scheduler: formally, it is specified algebraically as a data type. A number of different communication mechanisms, such as synchronous and asynchronous message passing, broadcasts and remote procedure calls, are modelled and, as an illustration of how global properties can be analysed, we consider the problem of deadlock detection.