Results 1  10
of
23
On parallel search
 in Proc. ACM Symp. Distributed Algorithms
, 1982
"... Abstract. We investigate the complexity of searching a sorted table of n elements on a synchronous, shared memory parallel computer with p processors. We show that f(lg nlgp) steps are required if concurrent accesses to the same memory cell are not allowed, whereas O(lg n/lg p) steps are sufficient ..."
Abstract

Cited by 46 (1 self)
 Add to MetaCart
(Show Context)
Abstract. We investigate the complexity of searching a sorted table of n elements on a synchronous, shared memory parallel computer with p processors. We show that f(lg nlgp) steps are required if concurrent accesses to the same memory cell are not allowed, whereas O(lg n/lg p) steps are sufficient if simultaneous reads are allowed. The lower bound is valid even if only communication steps are counted, and the computational power of each processor is not restricted. In this model, (R)(x/g n) steps are required for searching when the number of processors is unbounded. If the amount of information that a memory cell may store is restricted, then the time complexity for searching with an unbounded number of processors is O(lg n/lg lg n). If the amount of information a processor may hold is also restricted, then an fl(lg n) lower bound holds. These lower bounds are first proven for comparisonbased algorithms; it is next shown that comparisonbased algorithms are as powerful as more general ones in solving problems defined in terms of the relative order of the inputs. Key words, parallel algorithms, parallel computations 1. Introduction. With
Sorting and selecting in rounds
 SIAM Journal on Computing
, 1987
"... Abstract. We present upper bounds for sorting and selecting the median in a fixed number of rounds. These bounds match the known lower bounds to within logarithmic factors. They also have the merit of being "explicit modulo expansion"; that is, probabilistic arguments are used only to obta ..."
Abstract

Cited by 36 (0 self)
 Add to MetaCart
Abstract. We present upper bounds for sorting and selecting the median in a fixed number of rounds. These bounds match the known lower bounds to within logarithmic factors. They also have the merit of being "explicit modulo expansion"; that is, probabilistic arguments are used only to obtain expanding graphs, and when explicit constructions for such graphs are found, explicit algorithms for sorting and selecting will follow. Using the best currently available explicit constructions for expanding graphs, we present the best currently known explicit algorithms for sorting and selecting in rounds.
Fast Generation of Random Permutations Via Networks Simulation
 ALGORITHMICA
, 1998
"... We consider the problem of generating random permutations with uniform distribution. That is, we require that for an arbitrary permutation π of n elements, with probability 1/n! the machine halts with the ith output cell containing π(i), for 1 ≤ i ≤ n. We study this problem on two models of parall ..."
Abstract

Cited by 10 (4 self)
 Add to MetaCart
We consider the problem of generating random permutations with uniform distribution. That is, we require that for an arbitrary permutation π of n elements, with probability 1/n! the machine halts with the ith output cell containing π(i), for 1 ≤ i ≤ n. We study this problem on two models of parallel computations: the CREW PRAM and the EREW PRAM. The main result of the paper is an algorithm for generating random permutations that runs in O(log log n) time and uses O(n1+o(1) ) processors on the CREW PRAM. This is the first o(log n)time CREW PRAM algorithm for this problem. On the EREW PRAM we present a simple algorithm that generates a random permutation in time O(log n) using n processors and O(n) space. This algorithm outperforms each of the previously known algorithms for the exclusive write PRAMs. The common and novel feature of both our algorithms is first to design a suitable random switching network generating a permutation and then to simulate this network on the PRAM model in a fast way.
Very Fast Optimal Parallel Algorithms for Heap Construction
, 1994
"... We give two algorithms for permuting n items in an array into heap order on a CRCW PRAM. The first is deterministic and runs in O(log log n) time and performs O(n) operations. This runtime is the best possible for any comparisonbased algorithm using n processors. The second is randomized and runs ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
We give two algorithms for permuting n items in an array into heap order on a CRCW PRAM. The first is deterministic and runs in O(log log n) time and performs O(n) operations. This runtime is the best possible for any comparisonbased algorithm using n processors. The second is randomized and runs in O(log log log n) time with high probability, performing O(n) operations. No PRAM algorithm with o(log n) runtime was previously known for this problem. In order to obtain the deterministic result we study the parallel complexity of selecting the kth smallest of n elements on the CRCW PRAM, a problem that is of independent interest. We give an algorithm that is superior to existing ones when k is small compared to n. Consequently, we show that this problem can be solved in O(log log n + log k= log log n) time and O(n) operations for all 1 k n=2. A matching time lower bound is shown for all algorithms that use n or fewer processors to solve this problem. 1 Introduction A heap is a co...
Randomized RangeMaxima In NearlyConstant Parallel Time
, 1992
"... . Given an array of n input numbers, the rangemaxima problem is that of preprocessing the data so that queries of the type "what is the maximum value in subarray [i::j]" can be answered quickly using one processor. We present a randomized preprocessing algorithm that runs in O(log n) t ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
. Given an array of n input numbers, the rangemaxima problem is that of preprocessing the data so that queries of the type "what is the maximum value in subarray [i::j]" can be answered quickly using one processor. We present a randomized preprocessing algorithm that runs in O(log n) time with high probability, using an optimal number of processors on a CRCW PRAM; each query can be processed in constant time by one processor. We also present a randomized algorithm for a parallel comparison model. Using an optimal number of processors, the preprocessing algorithm runs in O(ff(n)) time with high probability; each query can be processed in O(ff(n)) time by one processor. (As is standard, ff(n) is the inverse of Ackermann function.) A constant time query can be achieved by some slowdown in the performance of the preprocessing stage. Key words. parallel algorithms; randomized algorithms; PRAM; comparison model; range maximum; prefix maximum. Subject classifications. 68Q20. 1 APPEARED...
Randomized Parallel Computation
 CONCURRENT COMPUTATIONS  ALGORITHMS, ARCHITECTURE, AND TECHNOLOGY. PROC. 1987 PRINCETON WORKSHOP ON ALGORITHMS, ARCHITECTURE AND TECHNOLOGY ISSUES FOR MODELS OF CONCURRENT COMPUTATION
"... The scope of this paper is to survey randomized parallel algorithms available for various computational problems. We do not claim to give a comprehensive list of all the randomized parallel algorithms that have been discovered so far. We only discuss representative examples which demonstrate the ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
The scope of this paper is to survey randomized parallel algorithms available for various computational problems. We do not claim to give a comprehensive list of all the randomized parallel algorithms that have been discovered so far. We only discuss representative examples which demonstrate the special features of both randomization and parallelization. The areas of CS we consider are: 1) routing and sorting, 2) processor load balancing, 3) algebra, and 4) graph theory. We also discuss in this paper various ways of derandomizing randomized parallel algorithms.
Fast integer merging on the EREW PRAM
 In Proc. 19th Intl. Coll. on Automata, Languages, and Programming
, 1992
"... Abstract. We investigate the complexity of merging sequences of small integers on the EREW PRAM. Our most surprising result is that two sorted sequences of n bits each can be merged in O(log log n) time. More generally, we describe an algorithm to merge two sorted sequences of n integers drawn from ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
Abstract. We investigate the complexity of merging sequences of small integers on the EREW PRAM. Our most surprising result is that two sorted sequences of n bits each can be merged in O(log log n) time. More generally, we describe an algorithm to merge two sorted sequences of n integers drawn from the set {0,..., m − 1} in O(log log n + log m) time using an optimal number of processors. No sublogarithmic merging algorithm for this model of computation was previously known. The algorithm not only produces the merged sequence, but also computes the rank of each input element in the merged sequence. On the other hand, we show a lower bound of Ω(log min{n, m}) on the time needed to merge two sorted sequences of length n each with elements in the set {0,..., m − 1}, implying that our merging algorithm is as fast as possible for m = (log n) Ω(1). If we impose an additional stability condition requiring the ranks of each input sequence to form an increasing sequence, then the time complexity of the problem becomes Θ(log n), even for m = 2. Stable merging is thus harder than nonstable merging. 1
New Bounds for Oblivious Mesh Routing
 Journal of Graph Algorithms and Applications
, 2001
"... We give two, new upper bounds for oblivious permutation routing on the mesh networks: Let N be the total number of processors in each mesh. One is an O(N^0.75) algorithm on the twodimensional, N^0.5 by N^0.5 mesh with constant queuesize. This is the first algorithm which improves substantially the ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
We give two, new upper bounds for oblivious permutation routing on the mesh networks: Let N be the total number of processors in each mesh. One is an O(N^0.75) algorithm on the twodimensional, N^0.5 by N^0.5 mesh with constant queuesize. This is the first algorithm which improves substantially the trivial O(N) bound for oblivious routing in the mesh networks with constant queuesize. The other is a 1.16 N^0.5 +o(N^0.5) algorithm on the threedimensional, N^1/3 by N^1/3 by N^1/3 mesh with unlimited queuesize. This algorithm allows at most three bends in the path of each packet. If the number of bends is restricted to minimal, i.e., at most two, then the bound jumps to Omega(N^2/3) as was shown in ESA'97. Communicated by T. Nishizeki, R. Tamassia and D. Wagner: submitted January 1999; revised April 2000 and October 2000. # A preliminary version of this paper was presented at the 6th European Symposium on Algorithms (ESA'98). + Supported in part by Scientific Research Grant, Ministry of Japan, 09480055 and 08244105, and Kayamori Foundation of Information Science Advancement, Japan # Supported in part by Scientific Research Grant, Ministry of Japan, 08244102 Supported in part by Scientific Research Grant, Ministry of Japan, 10780198 and 12780234, and The Telecommunications Advancement Foundation, Japan. K. Iwama et al., Oblivious Mesh Routing , JGAA, 5(5) 1738 (2001) 18 1