Robert A. Wagner

An efficient and fast parallel-connected component algorithm

A parallel algorithm for computing the connected components of undirected graphs is presented. Shared memory computation models are assumed. For a graph of <italic>e</italic> edges and <italic>n</italic> nodes, the time complexity of the algorithm is &Ogr;(<italic>e/p</italic> + (<italic>n</italic> log <italic>n</italic>)/<italic>p</italic> + log<supscrpt>2</supscrpt><italic>n</italic>) with <italic>p</italic> processors. The algorithm can be further refined to yield time complexity &Ogr;(<italic>H</italic>(<italic>e</italic>, <italic>n</italic>, <italic>p</italic>)/<italic>p</italic> + (<italic>n</italic> log <italic>n</italic>)/(<italic>p</italic> log(<italic>n</italic>/<italic>p</italic>)) + log<supscrpt>2</supscrpt><italic>n</italic>), where <italic>H</italic>(<italic>e, n, p</italic>) is very close to &Ogr;(<italic>e</italic>). These results show that linear speedup can be obtained for up to <italic>p</italic> ≤ <italic>e</italic>/log<supscrpt>2</supscrpt><italic>n</italic> processors when <italic>e</italic> ≥ <italic>n</italic> log <italic>n</italic>. Linear speedup can still be achieved with up to <italic>p</italic> ≤ <italic>n</italic>ε processors, 0 ≤ ε < 1, for graphs satisfying <italic>e</italic> ≥ <italic>n</italic> log<supscrpt>(*)</supscrpt><italic>n</italic>. Our results can be further improved if a more efficient integer sorting algorithm is available.

Optimal Selection of CPU Speed, Device Capacities, and File Assignments

This paper presents a computer system configuration design problem in which the objective is to select the CPU speed, the capacities of secondary storage devices, and the allocation of a set of files across the secondary storage devices so as to maximize the system throughput subject to a cost constraint. It is shown that any relative maximum of this complex nonlinear programming problem is also a global maximum. A technique to significantly reduce the dimensionality of the optimization problem is presented along.with an example to illustrate the models usefulness. The well-known file assignment problem is shown to be a subproblem of this model, and an example is given which demonstrates this fact. Finally, the errors introduced by the conversion of an essentially discrete problem into a continuous one are estimated and bounded.

The Boolean Vector Machine [BVM]

We describe the architecture of a class of machines intended to solve computationally intensive problems much faster than can todays machines, at no increase in cost. We have investigated the programming of the BVM for several interesting algorithms on a BVM of 2k bit positions per register. More theoretical study of implementations of such highly parallel algorithms is motivated.

Prototyping parallel and distributed programs in Proteus

This paper presents Proteus, an architecture-independent language suitable for prototyping parallel and distributed programs. Proteus is a high-level imperative notation based on sets and sequences with a single construct for the parallel composition of processes. Although a shared-memory model is the basis for communication between processes, this memory can be partitioned into shared and private variables. Parallel processes operate on individual copies of private variables, which are independently updated and may be merged into the shared state at specifiable barrier synchronization points. Several examples are given to illustrate how the various parallel programming models, such as synchronous data-parallelism and asynchronous control-parallelism, can be expressed in terms of this foundation. This common foundation allows prototypes to be tested, evolved and finally implemented through refinement techniques targeting specific architectures.<<ETX>>

A Decision Model for Closed Queuing Networks

This paper considers a computer configuration design problem. The computer system is modeled by a closed queuing network. The system throughput is the objective function to be maximized and the speed of the devices are the decision variables. A rich class of non-linear cost functions is considered.

Hardware configuration selection through discretizing a continuous variable solution

This paper extends a previous model for computer system configuration planning developed by the authors. The problem is to optimally select the CPU speed, the device capacities, and file assignments so as to maximize throughput subject to a fixed cost constraint. We advocate solving this essentially discrete problem in continuous variables followed by an appropriate discretization. The discretization error thus committed is analyzed in detail.

A Refinement Methodology for Developing Data-Parallel Applications

Data-parallelism is a relatively well-understood form of parallel computation, yet developing simple applications can involve substantial efforts to express the problem in low-level data-parallel notations. We describe a process of software development for data-parallel applications starting from high-level specifications, generating repeated refinements of designs to match different architectural models and performance constraints, supporting a development activity with cost-benefit analysis. Primary issues are algorithm choice, correctness and efficiency, followed by data decomposition, load balancing and message-passing coordination. Development of a data-parallel multitarget tracking application is used as a case study, showing the progression from high to low-level refinements. We conclude by describing tool support for the process.

The Crippled Queen Placement Problem

We describe the outcome of various combinations of choices made by individuals in the solution of a non-trivial combinatorial problem on a computer. The programs which result are analyzed with respect to execution speed, design time, and difficulty in debugging. The solutions obtained vary dramatically as a result of choices made in the overall design of the solution. Choices made at lower levels in the top-down tree of design choices seem to have less effect on the parameters analyzed. A tradeoff between mathematical effort in algorithm design, and program speed is evident, since some solutions required solution-time which grows exponentially with the case size, while another solution presented here gives a closed-form expression for the required answers for all large cases.

Solving the date crisis

have evolved over hundreds of years. But current data processing is rooted not only in punch-card records but in the few symbols inherited from the typewriter keyboard. Only two of the elementary algebraic functions exist, but no multiplication or division sign. Why? Because on type-written paper a lower-case “x” could be read as “multiply” and “/” as “divide.” As the typewriter went electric and became a terminal, two additions had to be made: “zero” and “one” could no longer be upper-case “O” and lower-case “l.” Otherwise, data processing is still operating in the pre-computer age defined by this old keyboard (and by “computer” I mean the modern, stored-program computer originally conceived by John von Neumann). Without intrinsic numeric and array processing as in APL and a few other languages, which require symbolism as their foundation, computer science can hardly be said to exist in the normal, operating world of business, government and everyday work. The consequent limited viewpoint engenders such gross errors and will cause others. And repairing this particular error at a cost of millions will do nothing to enhance current programs; on the contrary it is likely to make them slower and more cumbersome. I rephrase the questions posed to those responsible for this fiasco: What are you going to do to change from word to numeric processing, to use symbols instead of words and to make computing a science using numbers and mathematical logic?

Finding test-and-treatment procedures using parallel computation

A parallel algorithm for the NP-hard problem test-and-treatment is presented for a machine whose number of connections is 3p(2 squared), where p is the number of processing elements (PEs), and where the PEs are simple enough such that a machine with 2 to the 20th power PEs is currently implementable and to the 30th power PE machine is feasible. The speedup of O/sub p/ (log p) is realizable because we are able to transform the dynamic programming solution into the ASCEND/DESCEND scheme with considerable attention to the communication problem. This algorithm is realized on the Boolean Vector Machine, a fully designed cube-connected-cycle system where processor allocation and other control issues have been faced. The particular NP-hard problem is of independent interest; it generalizes the binary testing problem by introducing treatments on an equal basis with tests. Applications of this test-and-treatment problem are found in medical diagnosis, systematic biology, machine fault location, laboratory analysis and many other fields.