List Ranking Research Articles

A Model for Asynchronous Shared Memory Parallel Computation

Traditional theoretical shared memory parallel models have been based on a number of assumptions which simultaneously simplify solutions to problems and distance the models from actual parallel machines. One such assumption is that processors work together in a synchronous fashion. Recent work has focused on finding a model that captures the essence of computation by processors communicating asynchronously through shared memory. In this paper, a general framework and set of criteria used to analyze these models, including the complexity analysis of several fundamental algorithmic paradigms, are considered. A general asynchronous model is introduced and how it satisfies these criteria is demonstrated. In this model, $O(\log p)$ algorithms are demonstrated for solving p-input versions of the problems of AND, OR, parity, maximum, minimum, and list ranking. To handle list ranking, a technique of analyzing algorithms is developed in which the set of tasks that are to be executed depends on the processor schedules.

Virtual Shared Memory: Algorithms and Complexity

We consider the Block PRAM model of Aggarwal et al. ( in "Proceedings, First Annual ACM Symposium on Parallel Algorithms and Architectures, 1989," pp. 11-21). For a Block PRAM model with n /log n processors and communication latency l = O (log n ), we show that prefix sums can be performed in time O ( l log n /log l ), but list ranking requires time Ω( l log n ); these bounds are tight. These results justify an intuitive observation of Gazit et al. ( in "Proceedings, 1987 Princeton Workshop on Algorithm, Architecture and Technology Issues for Models of Concurrent Computation," pp. 139-156) that algorithm designers should, when possible, replace the list ranking procedure with the prefix sums procedure. We demonstrate the value of this technique in choosing between two optimal PRAM algorithms for finding the connected components of dense graphs. We also give theoretical improvements for integer sorting and many other algorithms based on prefix sums, and suggest a relationship between the issue of graph density for the connected components problem and alternative approaches to integer sorting.

SIMPLE DETERMINISTIC AND RANDOMIZED ALGORITHMS FOR LINKED LIST RANKING ON THE EREW PRAM MODEL

An asynchronous, CRCW PRAM (or APRAM) algorithm for linked list ranking, proposed by Martel and Subramonian, performs EO (n log log n) expected work employing [Formula: see text] processors. Motivated by their unique approach, this paper proposes two EREW list ranking algorithms – one deterministic and the other randomized. The deterministic algorithm performs in [Formula: see text] time using p processors, where n≥p log p. Thus, for p= O (n/ log n), it requires O ( log n log log n) time and O (n log log n) work. Although not work-optimal, this algorithm is very simple compared to the known work-optimal (deterministic) EREW algorithms for list ranking and has the added advantage of small constant factors in the time and space requirements. The randomized algorithm follows the same line of approach, but uses randomization in one step to decrease the time complexity, thus improving on the time complexity of the original algorithm. It requires [Formula: see text] expected time, and hence it is an EO ( log n) expected time, work-optimal algorithm employing p= O (n/ log n) processors. Furthermore, the randomized algorithm uses less space than the deterministic algorithm.

Efficient Parallel Computations on the Reduced Mesh of Trees Organization

Optimal and near optimal parallel algorithms for several fundamental problems are proposed for a parallel organization consistmg of n processors, each having access to a row and a column of an n × n array of memory modules. Parallel computations are implemented on such an organization by decomposing them into alternating orthogonal processing phases. A number of efficient data movement techniques are developed for the proposed organization which lead to optimal or near optimal solutions to several communication-intensive problems such as sorting, performing permutations, list ranking (data dependent parallel prefix), and problems on graphs represented by an unsorted list of n2 edges. It is also shown that the proposed organization is capable of simulating any fixed-degree network on n2 processors with O(n) loss in time, which is optimal. Finally, an enhanced organization having p processors, 1 ≤ p ≤ n2, and O(n2) memory locations is presented, and is shown to provide optimal speedups for adjacency-matrix based graph problems for any number of processors in the range [1, n3/2].

Efficient EREW PRAM algorithms for parentheses-matching

We present four polylog-time parallel algorithms for matching parentheses on an exclusive-read and exclusive-write (EREW) parallel random-access machine (PRAM) model. These algorithms provide new insights into the parentheses-matching problem. The first algorithm has a time complexity of O(log/sup 2/ n) employing O(n/(log n)) processors for an input string containing n parentheses. Although this algorithm is not cost-optimal, it is extremely simple to implement. The remaining three algorithms, which are based on a different approach, achieve O(log n) time complexity in each case, and represent successive improvements. The second algorithm requires O(n) processors and working space, and it is comparable to the first algorithm in its ease of implementation. The third algorithm uses O(n/(log n)) processors and O(n log n) space. Thus, it is cost-optimal, but uses extra space compared to the standard stack-based sequential algorithm. The last algorithm reduces the space complexity to O(n) while maintaining the same processor and time complexities. Compared to other existing time-optimal algorithms for the parentheses-matching problem that either employ extensive pipelining or use linked lists and comparable data structures, and employ sorting or a linked list ranking algorithm as subroutines, the last two algorithms have two distinct advantages. First, these algorithms employ arrays as their basic data structures, and second, they do not use any pipelining, sorting, or linked list ranking algorithms. >

COMPUTATION LIST EVALUATION AND ITS APPLICATIONS

In this paper, we present an algorithm for a generalization of list ranking called computation list evaluation. As a consequence of the generalization and the existence of this algorithm for computation list evaluation, we obtain a generalization of Euler Tour technique. Finally, we present several applications of the generalized Euler Tour technique. Of interest in the applications is the identification of a set of problem instances that are solvable using tree contraction and which can alternatively be solved using a simple algorithm based on the generalized Euler Tour technique.

Towards a single model of efficient computation in real parallel machines

We propose a model of parallel computation, the YPRAM, that allows general parallel algorithms to be designed for a wide class of parallel models. The basic model captures locality among processors, which is measured as a function of two parameters; latency and bandwidth. We design YPRAM algorithms for solving several fundamental problems: parallel prefix, sorting, sorting numbers from a bounded range, and list ranking. We show that our model predicts, reasonably accurately, the actual known performances of several basic parallel models — PRAM, hypercube, mesh and tree — when solving these problems.

Efficient parallel algorithms can be made robust

The efficient parallel algorithms proposed for many fundamental problems, such as list ranking, integer sorting and computing preorder numberings on trees, are very sensitive to processor failures. The requirement of efficiency (commonly formalized using Parallel-time × Processors as a cost measure) has led to the design of highly tuned PRAM algorithms which, given the additional constraint of simple processor failures, unfortunately become inefficient or even incorrect. We propose a new notion of robustness, that combines efficiency with fault tolerance. For the common case of fail-stop errors, we develop a general and easy to implement technique to make robust many efficient parallel algorithms, e.g., algorithms for all the problems listed above. More specifically, for any dynamic pattern of fail-stop errors on a CRCW PRAM with at least one surviving, processor, our method increases the original algorithm cost by at most a log2 multiplicative factor. Our technique is based on a robust solution of the problem of Write-All, i.e., using P processors, write 1's in all locations of an N-sized array. In addition we show that at least a log/log log multiplicative overhead will be incurred for certain patterns of failures by any algorithm that implements robust solutions to Write-All with P = N. However, by exploiting parallel slackness, we obtain an optimal cost algorithm when P ≤ N/log2N-logNloglogN.

Improved deterministic parallel integer sorting

We consider the problem of deterministic sorting of integers on a parallel RAM (PRAM). The best previous result ( T. Hagerup, 1987 , Inform. and Comput. 75 , 39–51) states that n integers of size polynomial in n can be sorted in time O (log n ) on a Priority CRCW PRAM with O( n log log n log n ) processors. We prove that n integers drawn from a set {0, …, m −1} can be sorted on an Arbitrary CRCW PRAM in time O( log n log log n + log log m) with a time-processor product of O ( n log log m ). In particular, if m = n (log n ) O (1) , the time and number of processors used are O( log n log log n ) and O( n( log log n) 2 log n ) , respectively. This improves the previous result in several respects: The new algorithm is faster, it works on a weaker PRAM model, and it is closer to optimality for input numbers of superpolynomial size. If log log m = O( log n log log n ) , the new algorithm is optimally fast, for any polynomial number of processors, and if log log m = (1 + Ω(1)) log log n and log log m = 0 ( log n ), it has optimal speedup relative to the fastest known sequential algorithm. The space needed is O ( nm ε ), for arbitrary but fixed ε > 0. The sorting algorithm derives its speed from a fast solution to a special list ranking problem of possible independent interest, the monotonic list ranking problem . In monotonic list ranking, each list element has an associated key, and the keys are known to increase monotonically along the list. We show that monotonic list ranking problems of size n can be solved optimally in time O( log n log log n ) . We also discuss and attempt to solve some of the problems arising in the precise description and implementation of parallel recursive algorithms. As part of this effort, we introduce a new PRAM variant, the allocated PRAM .

Deterministic parallel list ranking

In this paper we describe a simple parallel algorithm for list ranking. The algorithm is deterministic and runs inO(logn) time on an EREW PRAM withn/logn processors. The algorithm matches the performance of the Cole-Vishkin [CV3] algorithm but is simple and has reasonable constant factors.

Approximate parallel scheduling. II. Applications to logarithmic-time optimal parallel graph algorithms

Part I of this paper presented a novel technique for approximate parallel scheduling and a new logarithmic time optimal parallel algorithm for the list ranking problem. In this part, we give a new logarithmic time parallel (PRAM) algorithm for computing the connected components of undirected graphs which uses this scheduling technique. The connectivity algorithm is optimal unless m = o(n log ∗ n) in graphs of n vertices and m edges. (log ( k ) denotes the k th iterate of the log function and log ∗ n denotes the least i such that log ( i ) n ≤ 2). Using known results, this new algorithm implies logarithmic time optimal parallel algorithms for a number of other graph problems, including biconnectivity, Euler tours, strong orientation and st -numbering. Another contribution of the present paper is a parallel union/find algorithm.

A unified approach to parallel depth-first traversals of general trees

This paper unifies various parallel algorithms for traversing trees into a more generalized approach for traversing general trees in pre-order, in-order, and post-order fashion. Existing algorithms are usually based on different characterizations for different traversal problems and do not address the in-order traversal of general trees. But our generalized algorithm is applicable to all three commonly-used tree traversals using only a single characterization. For a general tree with n nodes, it achieves O( n p + log n ) time complexity employing p processors on an exclusive-read and exclusive-write (EREW). parallel random access machine (PRAM) model. Hence our algorithm is cost-optimal for p = O( n log n ) . As usual, our approach attempts to reduce the tree-traversal problem into a linked list ranking problem.

Efficient algorithms for list ranking and for solving graph problems on the hypercube

A hypercube algorithm to solve the list ranking problem is presented. Let n be the length of the list, and let p be the number of processors of the hypercube. The algorithm described runs in time O(n/p) when n= Omega (p/sup 1+ epsilon /) for any constant epsilon >0, and in time O(n log n/p+log/sup 3/ p) otherwise. This clearly attains a linear speedup when n= Omega (p/sup 1+ epsilon /). Efficient balancing and routing schemes had to be used to achieve the linear speedup. The authors use these techniques to obtain efficient hypercube algorithms for many basic graph problems such as tree expression evaluation, connected and biconnected components, ear decomposition, and st-numbering. These problems are also addressed in the restricted model of one-port communication. >

A simple parallel tree contraction algorithm

A simple reduction from the tree contraction problem to the list ranking problem is presented. The reduction takes O(log n) time for a tree with n nodes, using O( n log n ) EREW processors. Thus tree contraction can be done as efficiently as list ranking. A broad class of parallel tree computations to which the tree contraction techniques apply is described. This subsumes earlier characterizations. Applications to the computation of certain properties of cographs are presented in some detail.

Faster optimal parallel prefix sums and list ranking

We present a parallel algorithm for the prefix sums problem which runs in time O ( log n /log log n ) using n log logn/log n processors (optimal speedup). This algorithm leads to a parallel list ranking algorithm which runs in O (log n ) time using n /log n processors (optimal speedup).

Optimal parallel algorithms for dynamic expression evaluation and context-free recognition

We describe a deterministic parallel algorithm to evaluate algebraic expressions in O (log n ) time using n log (n) processors on a parallel random access machine without write conflicts (P-RAM) and with no free preprocessing. The input to the algorithm is a string (of the symbols making up the expression) store in an array. Such a form for the input enables a consecutive numbering of the operands in the expression in O (log( n )) time with n log (n) processors. This corresponds to a consecutive numbering of the leaves of the expression tree. This then further permits us to partition the leaves into small segments. We improve the result of Miller and Reif (1985, in “26th IEEE Sympos. on Found. of Comput. Sci.,” pp. 478–489), who described an optimal parallel randomized algorithm. (Strictly speaking, the input to their algorithm is different being the parse tree of the expression. The input to the innovative part of our algorithm (step 2) is this parse tree which, in addition, has its leaves numbered consecutively from left to right. These two orms are equivalent if we note that such a numbering can be obtained by an optimal parallel algorithm which employs the Euler tour technique and optimal list ranking). Our algorithm can be used to construct optimal parallel algorithms for the recognition of two nontrival subclasses of context-free languages: bracket and input-driven languages. These languages are the most complicated context-free languages known to be recognizable in deterministic logarithmic space. This strengthens the result of Matheyses and Fiduccia (1982 in “20th Allerton Conf. on Commun. Control and Comput.”) who constructed an almost optimal parallel algorithm for Dyck languages, since Dyck languages are a proper subclass of input-driven languages. Our algorithm includes a new simple method for tree contraction which we call the leaves-cutting method. Its correctness is trival (compared with the method of Miller and Reif) and it can be implemented on a P-RAM without write and without read conflicts.

Approximate Parallel Scheduling. Part I: The Basic Technique with Applications to Optimal Parallel List Ranking in Logarithmic Time

We define a novel scheduling problem; it is solved in parallel by repeated, rapid, approximate reschedulings. This leads to the first optimal logarithmic time PRAM algorithm for list ranking. Companion papers show how to apply these results to obtain improved PRAM upper bounds for a variety of problems on graphs, including the following: connectivity, biconnectivity, Euler tour and $st$-numbering, and a number of problems on trees.

Selection of Kidney Recipients

To the Editor.— We have read with interest the article by Starzl et al 1 about a multifactorial system for the selection of recipients of cadaver donor kidneys. The article is the first to describe a widely applicable system for organ distribution. The described system gives points for time on the waiting list (rank order, ten points for the patient longest on the list), HLA antigen match (two points for each matched antigen), panel reactive antibody (PRA) number (one point for each 10%), medical emergency (zero to ten points), and logistical factors (zero to six points). The authors argue against a system that uses antigen match as the sole or major criterion of recipient selection. We believe that even their system gives too much weight to antigen matching. With the exception of a six-antigen match, the value of HLA matching is controversial. Recently, Niblack et al, at the 1987 meeting

Randomized parallel speedups for list ranking

The following problem is considered: given a linked list of length n, compute the distance of each element of the linked list from the end of the list. The problem has two standard deterministic algorithms: a linear time serial algorithm, and an O(( n log n)/ p + log n) time parallel algorithm using p processors. We present a randomized parallel algorithm for the problem. The algorithm is designed for an exclusive-read exclusive-write parallel random access machine (EREW PRAM). It runs almost surely in time O(n/p + log n log ∗ n) using p processors. Using a recently published parallel prefix sums algorithm the list-ranking algorithm can be adapted to run on a concurrent-read concurrent-write parallel random access machine (CRCW PRAM) almost surely in time O( n/ p + log n) using p processors.

Deterministic coin tossing with applications to optimal parallel list ranking

The following problem is considered: given a linked list of length n , compute the distance from each element of the linked list to the end of the list. The problem has two standard deterministic algorithms: a linear time serial algorithm, and an O (log n ) time parallel algorithm using n processors. We present new deterministic parallel algorithms for the problem. Our strongest results are (1) O (log n log* n ) time using n /(log n log* n ) processors (this algorithm achieves optimal speed-up); (2) O (log n ) time using n log ( k ) n /log n processors, for any fixed positive integer k . The algorithms apply a novel “random-like” deterministic technique. This technique provides for a fast and efficient breaking of an apparently symmetric situation in parallel and distributed computation.