Results 21  30
of
55
A framework for speeding up priorityqueue operations
, 2004
"... Abstract. We introduce a framework for reducing the number of element comparisons performed in priorityqueue operations. In particular, we give a priority queue which guarantees the worstcase cost of O(1) per minimum finding and insertion, and the worstcase cost of O(log n) with at most log n + O ..."
Abstract

Cited by 8 (8 self)
 Add to MetaCart
Abstract. We introduce a framework for reducing the number of element comparisons performed in priorityqueue operations. In particular, we give a priority queue which guarantees the worstcase cost of O(1) per minimum finding and insertion, and the worstcase cost of O(log n) with at most log n + O(1) element comparisons per minimum deletion and deletion, improving the bound of 2log n + O(1) on the number of element comparisons known for binomial queues. Here, n denotes the number of elements stored in the data structure prior to the operation in question, and log n equals max {1,log 2 n}. We also give a priority queue that provides, in addition to the abovementioned methods, the prioritydecrease (or decreasekey) method. This priority queue achieves the worstcase cost of O(1) per minimum finding, insertion, and priority decrease; and the worstcase cost of O(log n) with at most log n + O(log log n) element comparisons per minimum deletion and deletion. CR Classification. E.1 [Data Structures]: Lists, stacks, and queues; E.2 [Data
LocalityInformationBased Scheduling in SharedMemory Multiprocessors’’, Job Scheduling Strategies for Parallel Processing
 SpringerVerlag, Lecture Notes in Computer Science
, 1996
"... Lightweight threads have become a common abstraction in the field of programming languages and operating systems. This paper examines the performance implications of locality information usage in thread scheduling algorithms for scalable sharedmemory multiprocessors. The elements of a distributed s ..."
Abstract

Cited by 8 (3 self)
 Add to MetaCart
Lightweight threads have become a common abstraction in the field of programming languages and operating systems. This paper examines the performance implications of locality information usage in thread scheduling algorithms for scalable sharedmemory multiprocessors. The elements of a distributed scheduler using all available locality information as well as experimental measurements are presented. Most sharedmemory multiprocessors use multiple stages of caches to hide latency. Data structures and policies of a scheduling architecture have to reflect the various levels of the memory hierarchy in order to achieve high data locality. Perprocessor data structures avoid lock contention and help to reduce memory traffic. While CPU utilization of processes still determines scheduling decisions of contemporary schedulers, we propose novel scheduling policies based on cache miss rates and information about synchronization. All data gathered at runtime are transformed into affinity values inside a metric space, so that threads migrate near to their (sub)optimal operation points defined by location and timing of execution. The distribution of data structures and the usage of locality information characterizes the proposed memoryconscious scheduling architecture. A prototype implementation shows that a localityconscious scheduler outperforms centralized and distributed approaches ignoring locality information.
Calculating the Meeting Point of Scattered Robots on Weighted Terrain Surfaces
, 2004
"... In this paper we discuss the problem of determining a meeting point of a set of scattered robots R = {r1,r2,...,rs} in a weighted terrain P which has n> s triangular faces. Our algorithmic approach is to produce a discretization of P by producing a graph G = {V G,E G} which lies on the surface of P. ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
In this paper we discuss the problem of determining a meeting point of a set of scattered robots R = {r1,r2,...,rs} in a weighted terrain P which has n> s triangular faces. Our algorithmic approach is to produce a discretization of P by producing a graph G = {V G,E G} which lies on the surface of P. For a chosen vertex p ′ ∈ V G, we define ‖Π(ri,p ′)‖ as the minimum weight cost of traveling from ri to p ′. We show that minp ′ ∈V G{max1≤i≤s{‖Π(ri,p ′)‖}} ≤ minp∗∈P{max1≤i≤s{‖Π(ri,p ∗)‖}} + W L  where L is the longest edge of P, W is the maximum cost weight of a face of P, and p ∗ is the optimal solution. Our algorithm requires O(snmlog(snm)+snm 2) time to run, where m = n in the Euclidean metric and m = n2 in the weighted metric. However, we show through experimentation that only a constant value of m is required (e.g., m=8) in order to produce very accurate solutions (< 1 % error). Hence, for typical terrain data, the expected running time of our algorithm is O(snlog(sn)). Also, as part of our experiments we show that by using geometrical subsets (i.e., 2D/3D convex hulls, 2D/3D bounding boxes and random selection) of the robots we can improve the running time for finding p ′, with minimal or no additional accuracy error when comparing p ′ to p ∗. 1
The Randomized Complexity of Maintaining the Minimum
, 1996
"... . The complexity of maintaining a set under the operations Insert, Delete and FindMin is considered. In the comparison model it is shown that any randomized algorithm with expected amortized cost t comparisons per Insert and Delete has expected cost at least n=(e2 2t ) \Gamma 1 comparisons for Fi ..."
Abstract

Cited by 7 (5 self)
 Add to MetaCart
. The complexity of maintaining a set under the operations Insert, Delete and FindMin is considered. In the comparison model it is shown that any randomized algorithm with expected amortized cost t comparisons per Insert and Delete has expected cost at least n=(e2 2t ) \Gamma 1 comparisons for FindMin. If FindMin is replaced by a weaker operation, FindAny, then it is shown that a randomized algorithm with constant expected cost per operation exists; in contrast, it is shown that no deterministic algorithm can have constant cost per operation. Finally, a deterministic algorithm with constant amortized cost per operation for an offline version of the problem is given. CR Classification: F.2.2 1. Introduction We consider the complexity of maintaining a set S of elements from a totally ordered universe under the following operations: Insert(x): inserts the element x into S, Delete(x): removes from S the element x provided it is known where x is stored, and Supported by the Danish...
Buckets strike back: Improved Parallel ShortestPaths
 Proc. 16th Intl. Par. Distr. Process. Symp. (IPDPS
, 2002
"... We study the averagecase complexity of the parallel singlesource shortestpath (SSSP) problem, assuming arbitrary directed graphs with n nodes, m edges, and independent random edge weights uniformly distributed in [0; 1]. We provide a new bucketbased parallel SSSP algorithm that runs in T = O(log ..."
Abstract

Cited by 6 (2 self)
 Add to MetaCart
We study the averagecase complexity of the parallel singlesource shortestpath (SSSP) problem, assuming arbitrary directed graphs with n nodes, m edges, and independent random edge weights uniformly distributed in [0; 1]. We provide a new bucketbased parallel SSSP algorithm that runs in T = O(log 2 n min i f2 i L + jV i jg) averagecase time using O(n+m+T ) work on a PRAM where L denotes the maximum shortestpath weight and jV i j is the number of graph vertices with indegree at least 2 i . All previous algorithms either required more time or more work. The minimum performance gain is a logarithmic factor improvement; on certain graph classes, accelerations by factors of more than n 0:4 can be achieved. The algorithm allows adaptation to distributed memory machines, too.
Two new methods for transforming priority queues into doubleended priority queues
 CPH STL Report
, 2006
"... Abstract. Two new ways of transforming a priority queue into a doubleended priority queue are introduced. These methods can be used to improve all known bounds for the comparison complexity of doubleended priorityqueue operations. Using an efficient priority queue, the first transformation can pr ..."
Abstract

Cited by 5 (5 self)
 Add to MetaCart
Abstract. Two new ways of transforming a priority queue into a doubleended priority queue are introduced. These methods can be used to improve all known bounds for the comparison complexity of doubleended priorityqueue operations. Using an efficient priority queue, the first transformation can produce a doubleended priority queue which guarantees the worstcase cost of O(1) for findmin, findmax, and insert; and the worstcase cost of O(lg n) including at most lg n + O(1) element comparisons for delete, but the data structure cannot support meld efficiently. Using a meldable priority queue that supports decrease efficiently, the second transformation can produce a meldable doubleended priority queue which guarantees the worstcase cost of O(1) for findmin, findmax, and insert; the worstcase cost of O(lg n) including at most lg n + O(lg lg n) element comparisons for delete; and the worstcase cost of O(min {lg m, lg n}) for meld. Here, m and n denote the number of elements stored in the data structures prior to the operation in question, and lg n is a shorthand for log 2 (max {2, n}). 1.
An Empirical Comparison of Priority Queue Algorithms
"... In the last three decades a considerable amount of research has been pursued in the efficient implementation of the pending event set (PES) associated with discreteevent simulation. The reason is simple: a fast event management has a very crucial impact in the total running time of both sequential ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
In the last three decades a considerable amount of research has been pursued in the efficient implementation of the pending event set (PES) associated with discreteevent simulation. The reason is simple: a fast event management has a very crucial impact in the total running time of both sequential and parallel simulations. This report focuses on this problem by studying the empirical performance of a number of solutions to the PES implementation in which we include a complete binary tree described in [26], 1 Introduction The PES is defined as the set of all the events generated during a discreteevent simulation and whose occurrence have not been simulated yet. In order to determine the next event to take place, it is necessary to extract the event with the least time from the PES. We call this operation extractmin. On the other hand, the occurrence of any event during the simulation can produce the insertion of new pending or future events in the PES; insert operation. These two b...
How to Find a Minimum Spanning Tree in Practice
 results and New Trends in Computer Science, volume 555 of Lecture Notes in Computer Science
, 1991
"... We address the question of theoretical vs. practical behavior of algorithms for the minimum spanning tree problem. We review the factors that influence the actual running time of an algorithm, from choice of language, machine, and compiler, through lowlevel implementation choices, to purely algor ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
We address the question of theoretical vs. practical behavior of algorithms for the minimum spanning tree problem. We review the factors that influence the actual running time of an algorithm, from choice of language, machine, and compiler, through lowlevel implementation choices, to purely algorithmic issues. We discuss how to design a careful experimental comparison between various alternatives. Finally, we present some results from an ongoing study in which we are using: multiple languages, compilers, and machines; all the major variants of the comparisonbased algorithms; and eight varieties of graphs with sizes of up to 130,000 vertices (in sparse graphs) or 750,000 edges (in dense graphs). 1 Introduction Finding spanning trees of minimum weight (minimum spanning trees or MSTs) is one of the best known graph problems; algorithms for this problem have a long history, for which see the article of Graham and Hell [6]. The best comparisonbased algorithm to date, due to Gabow...
Relaxed weak queues: an alternative to runrelaxed heaps
, 2005
"... Abstract. A simplification of a runrelaxed heap, called a relaxed weak queue, is presented. This new priorityqueue implementation supports all operations as efficiently as the original: findmin, insert, and decrease (also called decreasekey) in O(1) worstcase time, and delete in O(lg n) worstc ..."
Abstract

Cited by 4 (3 self)
 Add to MetaCart
Abstract. A simplification of a runrelaxed heap, called a relaxed weak queue, is presented. This new priorityqueue implementation supports all operations as efficiently as the original: findmin, insert, and decrease (also called decreasekey) in O(1) worstcase time, and delete in O(lg n) worstcase time, n denoting the number of elements stored prior to the operation. These time bounds are valid on a pointer machine as well as on a randomaccess machine. A relaxed weak queue is a collection of at most ⌊lg n ⌋ + 1 perfect weak heaps, where there are in total at most ⌊lg n ⌋ + 1 nodes that may violate weakheap order. In a pointerbased representation of a perfect weak heap, which is a binary tree, it is enough to use two pointers per node to record parentchild relationships. Due to decrease, each node must store one additional pointer. The auxiliary data structures maintained to keep track of perfect weak heaps and potential violation nodes only require O(lg n) words of storage. That is, excluding the space used by the elements themselves, the total space usage of a relaxed weak queue can be as low as 3n + O(lg n) words. ACM CCS Categories and Subject Descriptors. E.1 [Data Structures]: Lists, stacks, and queues; E.2 [Data Storage Representations]: Linked representations;
A Note on Worst Case Efficient Meldable Priority Queues
, 1996
"... We give a simple implementation of meldable priority queues, achieving Insert , Find min, and Meld in O(1) worst case time, and Delete min and Delete in O(log n) worst case time. 1 Introduction The implementation of priority queues is a classic problem in computer science. The fundamental operatio ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
We give a simple implementation of meldable priority queues, achieving Insert , Find min, and Meld in O(1) worst case time, and Delete min and Delete in O(log n) worst case time. 1 Introduction The implementation of priority queues is a classic problem in computer science. The fundamental operations are Insert and Delete min, but various extra operations, such as Find min, Meld, Delete, and Decrease key , have been considered. Fibonacci heaps [6] support all of these, in O(log n) time for the Delete min and Delete operations, and O(1) for the rest. These bounds are, however, only amortized. Some earlier proposals [4, 5, 8] achieve such bounds in the worst case sense for various subsets of the operations supported by Fibonacci heaps. None of these subsets includes the meld operation. This has been remedied recently by Brodal, who has given worst case solutions, first [2] for the set Insert, Delete min, Find min, Meld, and Delete, and later [3] for the full set of Fibonacci heap opera...