Kirsten Hildrum

Distributed object location in a dynamic network

Modern networking applications replicate data and services widely, leading to a need for location-independent routing -- the ability to route queries directly to objects using names independent of the objects physical locations. Two important properties of a routing infrastructure are routing locality and rapid adaptation to arriving and departing nodes. We show how these two properties can be efficiently achieved for certain network topologies. To do this, we present a new distributed algorithm that can solve the nearest-neighbor problem for these networks. We describe our solution in the context of Tapestry, an overlay network infrastructure that employs techniques proposed by Plaxton, Rajaraman, and Richa [14].

Asymptotically Efficient Approaches to Fault-Tolerance in Peer-to-Peer Networks

In this paper, we show that two peer-to-peer systems, Pastry [13] and Tapestry [17] can be made tolerant to certain classes of failures and a limited class of attacks. These systems are said to operate properly if they can find the closest node matching a requested ID. The system must also be able to dynamically construct the necessary routing information when new nodes enter or the network changes. We show that with an additional factor of O(log2 n) storage overhead and O(log n) communication overhead, they can continue to achieve both of these goals in the presence of a constant fraction nodes that do not obey the protocol. Our techniques are similar in spirit to those of Saia et al. [14] and Naor and Wieder [10]. Some simple simulations show that these techniques are useful even with constant overhead.

A polynomial-time tree decomposition to minimize congestion

Räcke recently gave a remarkable proof showing that any undirected multicommodity flow problem can be routed in an oblivious fashion with congestion that is within a factor of O(log3 n) of the best off-line solution to the problem. He also presented interesting applications of this result to distributed computing. Maggs, Miller, Parekh, Ravi and Wu have shown that such a decomposition also has an application to speeding up iterative solvers of linear systems. Räckes construction finds a decomposition tree of the underlying graph, along with a method to obliviously route in a hierarchical fashion on the tree. The construction, however, uses exponential-time procedures to build the decomposition. The non-constructive nature of his result was remedied, in part, by Azar, Cohen, Fiat, Kaplan, and Räcke, who gave a polynomial time method for building an oblivious routing strategy. Their construction was not based on finding a hierarchical decomposition, and this precludes its application to iterative methods for solving linear systems. In this paper, we show how to compute a hierarchical decomposition and a corresponding oblivious routing strategy in polynomial time. In addition, our decomposition gives an improved competitive ratio for congestion of O(log2 n log log n). In an independent result in this conference, Bienkowski, Korzeniowski, and Räcke give a polynomial-time method for constructing a decomposition tree with competitive ratio O(log4 n). We note that our original submission used essentially the same algorithm, and we appreciate them allowing us to present this improved version.

Object location in realistic networks

We devise an object location scheme that achieves a guaranteed low stretch in a wider and more realistic class of networks than previous schemes. The distinctive feature of our scheme is that it is inherently adaptive to the underlying topology. In particular, the system achieves 1+ε stretch (for arbitrarily fixed ε>0), with a neighbor list size that depends on the local density around the node (but not on the global growth rate bound). As a byproduct, our scheme has several advantages over existing ones, such as robustness to errors in network measurements, and simpler design choices of system builders, which may lead to improved and more robust deployments.

Distributed Object Location in a Dynamic Network

Modern networking applications replicate data and services widely, leading to a need for location-independent routing—the ability to route queries to objects using names independent of the objects’ physical locations. Two important properties of such a routing infrastructure are routing locality and rapid adaptation to arriving and departing nodes.We showhowthese two properties can be efficiently achieved for certain network topologies. To do this, we present a new distributed algorithm that can solve the nearest-neighbor problem for these networks. We describe our solution in the context of Tapestry, an overlay network infrastructure that employs techniques proposed by Plaxton et al. [24].

On list update and work function algorithms

The list update problem, a well-studied problem in dynamic data structures, can be described abstractly as a metrical task system. In this paper, we prove that a generic metrical task system algorithm, called the work function algorithm, has constant competitive ratio for list update. In the process, we present a new formulation of the well-known list factoring technique in terms of a partial order on the elements of the list. This approach leads to a new simple proof that a large class of online algorithms, including Move-To-Front, is (2 - 1/k)-competitive, for k the list length.

Brief announcement: stretch between nearby peers

A peer-to-peer object location system is an evolving set of computers cooperating to store objects. In this brief announcement, we analyze the stretch in such a system. Stretch is the ratio of the distance traveled in the system to find a copy of the object to the direct distance to the closest copy. We give a simple example with low overall stretch (i.e., the average stretch over all pairs) but high stretch nearby pairs, and then show, via simulation, that the simple example is relevant to real networks. More details on this and the related issue of finding nearby neighbors to build systems for low stretch are in the accompanying technical report [1]. For the simple example, consider n overlay nodes at the integers on the number line, from 1 to n, such that adjacent nodes are separated by a distance of one. (We assume that n is a power of 2.) A particular object ID and the routes taken to that ID through the overlay create a logical tree on these nodes. Suppose the tree is “perfect”, meaning that exactly every other node is a leaf, and consider the pair of nodes (2k−1, 2k), for some k > 0. If 2k is a leaf, then 2k’s distance to its parent 2k− 1 is one, and 2k− 1’s distance to its parent (itself) is zero; the average distance from a node to its parent is 1 2 . To simplify the calculation, imagine a hypothetical average parent located at a distance of 1 2 from both nodes, at 2k − 1 2 . These are not physical nodes; rather, they the “average” over all possible choices. Figure 1 shows the resulting tree. In Tapestry [2], objects are published by placing pointers to them at each node along the path from the publisher to the root, and object location proceeds by checking for pointers along the path from the query source to the root. The stretch is determined by where the publish and search path first intersect, or in other words, the least common ancestor of the publisher and the query source. We now calculate the average stretch when the publisher and searcher are at distance one from each other. Half of such pairs of nearby nodes share the same parent, and so have location stretch of one, since the request need only travel a distance of one to reach the publisher. Half of the remaining pairs share the same grandparent, for these nodes, the stretch is three (see Figure 1 for an example). In general, for j ≤ log2 n there are 22 n−j pairs with location stretch 2j−1. The average stretch is then 1 n Plog2 n j=1 2 log2 n−j(2j− 1), or log2 n− Plog2 n j=1 1 2j , which is less than or equal to log n−1. Thus, the average stretch between nearby pairs is O(log n) (and one pair has stretch n), while the average stretch over all pairs is O(1). (The O(1) overall average follows because most pairs are

Brief announcement: randomized rumor spreading with fewer phone calls

Suppose a node has an update that it would like to send to n − 1 other nodes. The node with the update could send the message to every other node directly, but this takes θ(n) steps. Another option is to build a fixed-connection network (e.g., a phone tree). Then, a node with an update sends the update to its parent and its children, and the nodes that receive it send it on in a similar way. The update reaches everyone in O(log n) steps, and each node—including the node initiating the rumor—only does constant work. Further, the total number of messages and the total number of phone calls is optimal, n − 1. But if one node in the tree fails, a large subtree becomes unreachable. One solution to this problem is the use of rumor spreading algorithms. These algorithms have two basic operations: push and pull. In a push, a node that has the update and randomly sends the rumor to another participant. In a pull, a node without the rumor asks a random node for any new rumors. We consider two measures of efficiency for rumor spreading algorithms. The first is the number of connections (or phone calls) made. The second measure is the number of times the rumor is transmitted. If two nodes connect but neither of them know the rumor, a phone call may not result in a transmission. If the cost of the phone calls is amortized over many rumors, it makes sense to count transmissions rather than phone calls, but if rumors are rare, the number of phone calls may be more important. (Also important is the number of rounds, or steps, but we do not consider that here.) Among the first to use epidemic algorithms is Demers et. al. [2], in the context of maintaining loose consistency among replicated databases. Many applications followed. The observations here draw most from two phone calls transmissions n push+tree push&pull push&pull 16384 2.2 15.3 5.2 64436 2.1 17.4 5.9 262144 2.0 19.6 6.3 1048576 2.0 22.0 6.7 4194304 2.0 23.4 7.0 Figure 1: There are n nodes in the network, and 10% are dead. The push+tree scheme notifies about 90% of nodes (just a tree notifies less than 10%.) The push&pull algorithm is run until all nodes know the rumor. papers. Karp et al. [4] takes a theoretical approach and give an algorithm that distributes a …

On List Update and Work Function Algorithms

The list update problem, a well-studied problem in dynamic data structures, can be described abstractly as a metrical task system. In this paper, we prove that a generic metrical task system algorithm, called the work function algorithm, has constant competitive ratio for list update. In the process, we present a new formulation of the well-known list factoring technique in terms of a partial order on the elements of the list. This approach leads to a new simple proof that a large class of online algorithms, including Move-To-Front, is (2 - 1/k)-competitive.