Results 1  10
of
262
Viceroy: A Scalable and Dynamic Emulation of the Butterfly
, 2002
"... We propose a family of constantdegree routing networks of logarithmic diameter, with the additional property that the addition or removal of a node to the network requires no global coordination, only a constant number of linkage changes in expectation, and a logarithmic number with high probabilit ..."
Abstract

Cited by 291 (16 self)
 Add to MetaCart
We propose a family of constantdegree routing networks of logarithmic diameter, with the additional property that the addition or removal of a node to the network requires no global coordination, only a constant number of linkage changes in expectation, and a logarithmic number with high probability. Our randomized construction improves upon existing solutions, such as balanced search trees, by ensuring that the congestion of the network is always within a logarithmic factor of the optimum with high probability. Our construction derives from recent advances in the study of peertopeer lookup networks, where rapid changes require e#cient and distributed maintenance, and where the lookup e#ciency is impacted both by the lengths of paths to requested data and the presence or elimination of bottlenecks in the network.
Skipnet: A scalable overlay network with practical locality properties
, 2003
"... Abstract: Scalable overlay networks such as Chord, Pastry, and Tapestry have recently emerged as a flexible infrastructure for building large peertopeer systems. In practice, two disadvantages of such systems are that it is difficult to control where data is stored and difficult to guarantee that ..."
Abstract

Cited by 280 (5 self)
 Add to MetaCart
Abstract: Scalable overlay networks such as Chord, Pastry, and Tapestry have recently emerged as a flexible infrastructure for building large peertopeer systems. In practice, two disadvantages of such systems are that it is difficult to control where data is stored and difficult to guarantee that routing paths remain within an administrative domain. SkipNet is a scalable overlay network that provides controlled data placement and routing locality guarantees by organizing data primarily by lexicographic key ordering. SkipNet also allows for both finegrained and coarsegrained control over data placement, where content can be placed either on a predetermined node or distributed uniformly across the nodes of a hierarchical naming subtree. An additional useful consequence of SkipNet’s locality properties is that partition failures, in which an entire organization disconnects from the rest of the system, result in two disjoint, but wellconnected overlay networks. 1
Stride Scheduling: Deterministic ProportionalShare Resource Management
, 1995
"... This paper presents stride scheduling, a deterministic scheduling technique that efficiently supports the same flexible resource management abstractions introduced by lottery scheduling. Compared to lottery scheduling, stride scheduling achieves significantly improved accuracy over relative throughp ..."
Abstract

Cited by 152 (1 self)
 Add to MetaCart
This paper presents stride scheduling, a deterministic scheduling technique that efficiently supports the same flexible resource management abstractions introduced by lottery scheduling. Compared to lottery scheduling, stride scheduling achieves significantly improved accuracy over relative throughput rates, with significantly lower response time variability. Stride scheduling implements proportionalshare control over processor time and other resources by crossapplying elements of ratebased flow control algorithms designed for networks. We introduce new techniques to support dynamic changes and higherlevel resource management abstractions. We also introduce a novel hierarchical stride scheduling algorithm that achieves better throughput accuracy and lower response time variability than prior schemes. Stride scheduling is evaluated using both simulations and prototypes implemented for the Linux kernel.
Randomized Search Trees
 ALGORITHMICA
, 1996
"... We present a randomized strategy for maintaining balance in dynamically changing search trees that has optimal expected behavior. In particular, in the expected case a search or an update takes logarithmic time, with the update requiring fewer than two rotations. Moreover, the update time remains ..."
Abstract

Cited by 139 (1 self)
 Add to MetaCart
We present a randomized strategy for maintaining balance in dynamically changing search trees that has optimal expected behavior. In particular, in the expected case a search or an update takes logarithmic time, with the update requiring fewer than two rotations. Moreover, the update time remains logarithmic, even if the cost of a rotation is taken to be proportional to the size of the rotated subtree. Finger searches and splits and joins can be performed in optimal expected time also. We show that these results continue to hold even if very little true randomness is available, i.e. if only a logarithmic number of truely random bits are available. Our approach generalizes naturally to weighted trees, where the expected time bounds for accesses and updates again match the worst case time bounds of the best deterministic methods. We also discuss ways of implementing our randomized strategy so that no explicit balance information is maintained. Our balancing strategy and our alg...
Approximate Nearest Neighbor Queries in Fixed Dimensions
, 1993
"... Given a set of n points in ddimensional Euclidean space, S ae E d , and a query point q 2 E d , we wish to determine the nearest neighbor of q, that is, the point of S whose Euclidean distance to q is minimum. The goal is to preprocess the point set S, such that queries can be answered as effic ..."
Abstract

Cited by 105 (10 self)
 Add to MetaCart
Given a set of n points in ddimensional Euclidean space, S ae E d , and a query point q 2 E d , we wish to determine the nearest neighbor of q, that is, the point of S whose Euclidean distance to q is minimum. The goal is to preprocess the point set S, such that queries can be answered as efficiently as possible. We assume that the dimension d is a constant independent of n. Although reasonably good solutions to this problem exist when d is small, as d increases the performance of these algorithms degrades rapidly. We present a randomized algorithm for approximate nearest neighbor searching. Given any set of n points S ae E d , and a constant ffl ? 0, we produce a data structure, such that given any query point, a point of S will be reported whose distance from the query point is at most a factor of (1 + ffl) from that of the true nearest neighbor. Our algorithm runs in O(log 3 n) expected time and requires O(n log n) space. The data structure can be built in O(n 2 ) expe...
A flexible framework for implementing software transactional memory
 In ACM Conference on ObjectOriented Programming, Systems, Languages, and Applications
, 2006
"... We describe DSTM2, a Java TM software library that provides a flexible framework for implementing objectbased software transactional memory (STM). The library uses transactional factories to transform sequential (unsynchronized) classes into atomic (transactionally synchronized) ones, providing a s ..."
Abstract

Cited by 97 (4 self)
 Add to MetaCart
We describe DSTM2, a Java TM software library that provides a flexible framework for implementing objectbased software transactional memory (STM). The library uses transactional factories to transform sequential (unsynchronized) classes into atomic (transactionally synchronized) ones, providing a substantial improvement over the awkward programming interface of our previous DSTM library. Furthermore, researchers can experiment with alternative STM mechanisms by providing their own factories. We demonstrate this flexibility by presenting two factories: one that uses essentially the same mechanisms as the original DSTM (with some enhancements), and another that uses a completely different approach. Because DSTM2 is packaged as a Java library, a wide range of programmers can easily try it out, and the community can begin to gain experience with transactional programming. Furthermore, researchers will be able to use the body of transactional programs that arises from this community experience to test and evaluate different STM mechanisms simply by supplying new transactional factories. We believe that this flexible approach will help to build consensus about the best ways to implement transactions, and will avoid the premature “lockin ” that may arise if STM mechanisms are baked into compilers before such experimentation is done.
LockFree Linked Lists Using CompareandSwap
 In Proceedings of the Fourteenth Annual ACM Symposium on Principles of Distributed Computing
, 1995
"... Lockfree data structures implement concurrent objects without the use of mutual exclusion. This approach can avoid performance problems due to unpredictable delays while processes are within critical sections. Although universal methods are known that give lockfree data structures for any abstract ..."
Abstract

Cited by 95 (1 self)
 Add to MetaCart
Lockfree data structures implement concurrent objects without the use of mutual exclusion. This approach can avoid performance problems due to unpredictable delays while processes are within critical sections. Although universal methods are known that give lockfree data structures for any abstract data type, the overhead of these methods makes them inefficient when compared to conventional techniques using mutual exclusion, such as spin locks. We give lockfree data structures and algorithms for implementing a shared singlylinked list, allowing concurrent traversal, insertion, and deletion by any number of processes. We also show how the basic data structure can be used as a building block for other lockfree data structures. Our algorithms use the single word CompareandSwap synchronization primitive to implement the linked list directly, avoiding the overhead of universal methods, and are thus a practical alternative to using spin locks. 1 Introduction A concurrent object is an...
Effective jumppointer prefetching for linked data structures
 In Proceedings of the 26th Annual International Symposium on Computer Architecture
, 1999
"... Current techniques for prefetching linked data structures (LDS) exploit the work available in one loop iteration or recursive call to overlap pointer chasing latency. Jumppointers, which provide direct access to nonadjacent nodes, can be used for prefetching when loop and recursive procedure bodies ..."
Abstract

Cited by 90 (1 self)
 Add to MetaCart
Current techniques for prefetching linked data structures (LDS) exploit the work available in one loop iteration or recursive call to overlap pointer chasing latency. Jumppointers, which provide direct access to nonadjacent nodes, can be used for prefetching when loop and recursive procedure bodies are small and do not have sufficient work to overlap a long latency. This paper describes a framework for jumppointer prefetching (JPP) that supports four prefetching idioms: queue, full, chain, and root jumping and three implementations: softwareonly, hardwareonly, and a cooperative software/hardware technique. On a suite of pointer intensive programs, jumppointer prefetching reduces memory stall time by 72 % for software, 83 % for cooperative and 55 % for hardware, producing speedups of 15%, 20 % and 22 % respectively. 1
Know thy Neighbor's Neighbor: the Power of Lookahead in Randomized P2P Networks
 In Proceedings of the 36th ACM Symposium on Theory of Computing (STOC
, 2004
"... Several peertopeer networks are based upon randomized graph topologies that permit e#cient greedy routing, e.g., randomized hypercubes, randomized Chord, skipgraphs and constructions based upon smallworld percolation networks. In each of these networks, a node has outdegree #(log n), where n de ..."
Abstract

Cited by 89 (5 self)
 Add to MetaCart
Several peertopeer networks are based upon randomized graph topologies that permit e#cient greedy routing, e.g., randomized hypercubes, randomized Chord, skipgraphs and constructions based upon smallworld percolation networks. In each of these networks, a node has outdegree #(log n), where n denotes the total number of nodes, and greedy routing is known to take O(log n) hops on average. We establish lowerbounds for greedy routing for these networks, and analyze NeighborofNeighbor (NoN)greedy routing. The idea behind NoN, as the name suggests, is to take a neighbor's neighbors into account for making better routing decisions.
Nearestneighbor searching and metric space dimensions
 In NearestNeighbor Methods for Learning and Vision: Theory and Practice
, 2006
"... Given a set S of n sites (points), and a distance measure d, the nearest neighbor searching problem is to build a data structure so that given a query point q, the site nearest to q can be found quickly. This paper gives a data structure for this problem; the data structure is built using the distan ..."
Abstract

Cited by 87 (0 self)
 Add to MetaCart
Given a set S of n sites (points), and a distance measure d, the nearest neighbor searching problem is to build a data structure so that given a query point q, the site nearest to q can be found quickly. This paper gives a data structure for this problem; the data structure is built using the distance function as a “black box”. The structure is able to speed up nearest neighbor searching in a variety of settings, for example: points in lowdimensional or structured Euclidean space, strings under Hamming and edit distance, and bit vector data from an OCR application. The data structures are observed to need linear space, with a modest constant factor. The preprocessing time needed per site is observed to match the query time. The data structure can be viewed as an application of a “kdtree ” approach in the metric space setting, using Voronoi regions of a subset in place of axisaligned boxes. 1