Eshrat Arjomandi

Efficiency of Synchronous Versus Asynchronous Distributed Systems

A system of parallel processes is said to be synchronous if all processes run using the same clock, and it is said to be asynchronous if each process has its own independent clock. For any s, n, a particular distributed problem is defined involving system behavior at n ports. This problem can be solved in time s by a synchronous system but requires time at least (s-1)(log/sub b/n) on any asynchronous system, where b is a constant reflecting the communication bound in the model. This appears to be the first example of a problem for which an asynchronous system is probably slower than a synchronous one, and it shows that a straightforward step-by-step and process-by-process simulation of an n-process synchronous system by an n-process asynchronous system necessarily loses a factor of log/sub b/n in speed. 1 ref.The problem of implementing mutual exclusion of N asynchronous parallel processes in a model where the primitive communication mechanism is a test-and-set operation on a shared variable, was the subject of extensive research. While a two-valued variable suffices to insure mutual exclusion, it is shown in [1] that N/2 values are necessary to avoid lockout of any process, and N + 1 values are required to insure bounded waiting time. We introduce the idea of employing randomization in the synchronization protocol and achieve a mutual exclusion, lockout-free, bounded-waiting solution using just 4(log2N+4)-valued shared variable. The protocol is extremely simple, easy to implement, and avoids certain undesirable features present in some of the other solutions.

ABC++: concurrency by inheritance in C++

Many attempts have been made to add concurrency to C++, often by extensive compiler extensions, but much of the work has not exploited the power of C++. This paper shows how the object-oriented facilities of C++ are powerful enough to encapsulate concurrency creation and control. We have developed a concurrent C++-based prototype system (ABC++) and describe how we can provide, with a standard compiler, almost all of the functionality offered by a new or extended language. Active objects, object distribution, selective method acceptance, and synchronous and asynchronous object interaction are supported. Concurrency control and synchronization are encapsulated at the active object level. The goal of ABC++ is to allow users to write concurrent programs without dealing with explicit synchronization and mutual exclusion constructs, with as few restrictions on the use of C++ as possible. ABC++ can be implemented on either a shared memory multiprocessor or a cluster of homogeneous workstations. It is presently implemented on a network of RISC System/6000® processors and on the IBM Scalable POWERparallel™ System 1 (SP1™).

Controlling garbage collection and heap growth to reduce the execution time of Java applications

In systems that support garbage collection, a tension exists between collecting garbage too frequently and not collecting garbage frequently enough. Garbage collection that occurs too frequently may introduce unnecessary overheads at the rist of not collecting much garbage during each cycle. On the other hand, collecting garbage too infrequently can result in applications that execute with a large amount of virtual memory (i.e., with a large footprint) and suffer from increased execution times die to paging. In this paper, we use a large colleciton of Java applications and the highly tuned and widely used Boehm-Demers-Weiser (BDW) conservative mark-and-sweep garbage collector to experimentally examine the extent to which the frequency of garbage collectio impacts an applications execution time, footprint, and pause times. We use these results to devise some guidelines for controlling garbage and heap growth in a conservative garbage collection in order to minimize application execution times. Then we describe new strategies for controlling in order to minimize application execution times.

Selection in X + Y and matrices with sorted rows and columns☆

Abstract Let A be an n×n matrix of reals with sorted rows and columns and k an integer, 1 ⩽ k ⩽ n 2 . We present an O(n) time algorithm for selecting the k th smallest element of A. If X and Y are sorted n-vectors of reals, then Cartesian sum X + Y is such a matrix as A. One application of selection in X + Y can be found in statistics. The algorithm presented here is based on a new divide-and-conquer technique, which can be applied to similar order related problems as well. Due to the fact that the algorithm has a relatively small constant time factor, this result is of practical as well as theoretical interest.

A difference in efficiency between synchronous and asynchronous systems

A system of parallel processes is said to be <underline>synchronous</underline> if all processes run using the same clock, and it is <underline>asynchronous</underline> if each process has its own independent clock. For any s, n, a particular distributed problem is defined involving system behavior at n “ports”. This problem can be solved in time s by a synchronous system but requires time at least (s-1) log n on any asynchronous system.

An Efficient Algorithm for Colouring the Edges of a Graph With Δ + 1 Colours

AbstractThe edge colouring problem has received considerable attention from mathematicians andcomputer scientists. The edges of a simple graph G can be coloured with Δ or Δ + 1 colours, where Δ is the maximum degree in G. Holyer has recently shown that A-edgecolourability is NP-complete. In this paper we present a edge colouring algorithm for general graphs which uses at most Δ + 1 colours.

Object-Oriented Distributed and Parallel I/O Streams

Writing programs for parallel and distributed computing environments can be significantly more complex than writing programs for their sequential counterparts. These complexities mainly arise from the additional synchronization and communication requirements imposed by such environments. These requirements also make debugging and maintaining such programs significantly more complicated. The problem of debugging and maintenance is further exacerbated by the lack of good debuggers and the lack of proper I/O support for such environments.