Results 1 
5 of
5
Load Balancing, Selection and Sorting on the Hypercube
 In Proceedings of the 1989 ACM Symposium on Parallel Algorithms and Architectures
, 1989
"... This paper presents novel load balancing, selection and sorting algorithms for the hypercube with 1port communication. The main result is an algorithm for sorting n values on p processors, SmoothSort, that runs asymptotically faster (in the worst case) than any previously known algorithm over a ..."
Abstract

Cited by 26 (4 self)
 Add to MetaCart
This paper presents novel load balancing, selection and sorting algorithms for the hypercube with 1port communication. The main result is an algorithm for sorting n values on p processors, SmoothSort, that runs asymptotically faster (in the worst case) than any previously known algorithm over a wide range of the ratio n=p. The load balancing and selection algorithms upon which SmoothSort is based are expected to be of independent interest. Although the analysis of our algorithms is limited to obtaining asymptotic bounds, the constant factors being ignored are quite small. 1 Introduction This paper presents novel load balancing, selection and sorting algorithms for the hypercube. The following model of computation is assumed. Each processor has an infinite local memory configured in O(log p) bit words and can perform the usual set of ALU operations in constant time on wordsized operands. Processors communicate with one another by sending packets over the bidirectional channel...
SelfCustomized BSP Trees for Collision Detection
, 2000
"... The ability to perform efficient collision detection is essential in virtual reality environments and their applications, such as walkthroughs. In this paper we reexplore a classical structure used for collision detection  the binary space partitioning tree. Unlike the common approach, which a ..."
Abstract

Cited by 14 (1 self)
 Add to MetaCart
The ability to perform efficient collision detection is essential in virtual reality environments and their applications, such as walkthroughs. In this paper we reexplore a classical structure used for collision detection  the binary space partitioning tree. Unlike the common approach, which attributes equal likelihood to each possible query, we assume events that happened in the past are more likely to happen again in the future. This leads us to the definition of selfcustomized data structures. We report encouraging results obtained while experimenting with this concept in the context of selfcustomized bsp trees. Keywords: Collision detection, binary space partitioning, selfcustomization. 1 Introduction Virtual reality refers to the use of computer graphics to simulate physical worlds or to generate synthetic ones, where a user is to feel immersed in the environment to the extent that the user feels as if "objects" seen are really there. For example, "objects" should m...
Towards Optimal Range Medians ⋆
"... Abstract. We consider the following problem: Given an unsorted array of n elements, and a sequence of intervals in the array, compute the median in each of the subarrays defined by the intervals. We describe a simple algorithm which needs O(n log k + k log n) time to answer k such median queries. Th ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
Abstract. We consider the following problem: Given an unsorted array of n elements, and a sequence of intervals in the array, compute the median in each of the subarrays defined by the intervals. We describe a simple algorithm which needs O(n log k + k log n) time to answer k such median queries. This improves previous algorithms by a logarithmic factor and matches a comparison lower bound for k = O(n). The space complexity of our simple algorithm is O(n log n) in the pointermachine model, and O(n) in the RAM model. In the latter model, a more involved O(n) space data structure can be constructed in O(n log n) time where the time per query is reduced to O(log n / log log n). We also give efficient dynamic variants of both data structures, achieving O(log 2 n) query time using O(n log n) space in the comparison model and O((log n / log log n) 2) query time using O(n log n / log log n) space in the RAM model, and show that in the cellprobe model, any data structure which supports updates in O(log O(1) n) time must have Ω(log n / log log n) query time.
On the Network Complexity of Selection
 In Proceedings of the 30th Annual Symposium on Foundations of Computer Science
, 1989
"... The selection problem is to determine the kth largest out of a given set of n keys, and its sequential complexity is well known to be linear. Thus, given a p processor parallel machine, it is natural to ask whether or not an O(n=p) selection algorithm can be devised for that machine. The main resu ..."
Abstract
 Add to MetaCart
The selection problem is to determine the kth largest out of a given set of n keys, and its sequential complexity is well known to be linear. Thus, given a p processor parallel machine, it is natural to ask whether or not an O(n=p) selection algorithm can be devised for that machine. The main result of this paper is an \Omega\Gamma/ n=p) log log p + log p) lower bound for selection on any network that satisfies a particular low expansion property. The class of networks satisfying this property includes all of the common network families such as the tree, multidimensional mesh, hypercube, butterfly and shuffle exchange. When n=p is sufficiently large (for example, greater than log 2 p on the butterfly, hypercube and shuffle exchange), this result is matched by the upper bound presented in [4]. 1 Introduction This paper is concerned with deriving a lower bound on the complexity of the selection problem for a certain large class of networks. Given a set S of n keys and an inte...
Algorithms and Arrays for Computing on Massive Data Sets
, 2001
"... In this work we investigate three approaches to computing on massive data sets. In the first approach, we give a sampling algorithm to estimate the maximum of a large data set. It gives estimates strictly better than the largest sample for an infinite family of data sets. In addition, the algorithm ..."
Abstract
 Add to MetaCart
In this work we investigate three approaches to computing on massive data sets. In the first approach, we give a sampling algorithm to estimate the maximum of a large data set. It gives estimates strictly better than the largest sample for an infinite family of data sets. In addition, the algorithm overshoots the true maximum of the worst case data set with probability at most 1/e + O(1/k), where the sample is of size k, which is much smaller than the size of the data set. Our proof is the result of a new extremal graph coloring theorem. In the second approach, we consider algorithms which process queries in batches for greater efficiency. We give a batched algorithm for high dimensional hamming nearest neighbors using fast matrix multiplication. In addition, using two techniques, query data structures and presampling, we create batched algorithms for string matching, 1D nearest neighbor, 2D 2approximate nearest neighbor, 2D point location, selection, inhull and halfplane intersection. These algorithms answer b queries to an unsorted data set of size n in O(nlogb) time using O(b 2 ) space and O(n/B) I/O's to the data set, where B is the block size. In the third approach, we consider the problem of designing disk arrays that reduce both read and write latency. We explore the disk array techniques of striping, mirroring, rotational replication, and eager writing. We give analytical models for three disk array combinations that reduce the seek and rotational delays of reads in a balanced fashion. Then we model the dramatic reduction in write latency of eager writing. Finally, we combine the ideas of mirroring, striping and eager writing. We discuss how to analytically model the latency of reads and writes, and how to maintain persistence. Finally we combine algorithms a...