CPSC 689: Discrete Algorithms for Mobile and Wireless Systems

1. CPSC 689: Discrete Algorithms for Mobile and Wireless Systems Spring 2009 Prof. Jennifer Welch

2. Lecture 18 • Topic: • More location services • Sources: • Abraham, Dolev, & Malkhi • MIT 6.885 Fall 2008 slides • CPSC 689 slides from Spring 2006 by Sai Siddarth Discrete Algs for Mobile Wireless Sys

3. Drawbacks of GLS • Handling of updates and out-of-date information: • when a node crosses a grid boundary, updating its role can take a lot of resources • Lack of scalability: • two nodes can be very close but the smallest square containing both of them cain be arbitrarily large • Expensive in sparse networks: • routing to location server can be much more expensive than just directly routing to destination Discrete Algs for Mobile Wireless Sys

4. 37 19 Example Drawback of GLS Discrete Algs for Mobile Wireless Sys

5. Locality-Aware Location Service (LLS) • Location service for unit-disk graph model. • Edge (u,v) iff dist(u,v), Euclidean distance between u and v, is ≤ 1. • Try to obtain performance for FIND and MOVE that depends on geographical distances: • Cost of MOVE(s,t), average case: O(d log d), where d = dist(s,t). • Cost of a FIND(t) from s, average case: O(d), where d = dist(s,t). • Averages taken over all pairs (s,t) of locations. • Cost of a FIND(t) from s, worst case: O(d2), where d is the minimum cost of a path from s to t. • Costs: • Cost of an edge = its length (can generalize this measure) • Cost of a path = sum of costs of edges • Cost of a MOVE or FIND = total costs of all edges traversed in the implementation (?) Discrete Algs for Mobile Wireless Sys

6. Geographic Routing • Assume availability of geographic routing algorithm, which can broadcast to a known location. • Worst-case cost O(d2), average cost O(d), where d = dist(source, target). • (Study such algorithms next.) Discrete Algs for Mobile Wireless Sys

7. Model • n mobile nodes in M  M square, coordinates in [0, M], each u with a unique identifier, u.id. • Unit disk graph network. • All nodes know their own locations, and identities and locations of their neighbors. • Assume lower bound on dist(u,v); claim this assumption could be removed using a connected dominating set backbone network [Kuhn, et al.] • Virtual nodes: • For any point p in the square, at any time, define l(p) to be the closest mobile node to p. • Assume the geographical routing algorithm, when sending to p, will reach l(p). • Essentially assume that each p has a (virtual) node. Discrete Algs for Mobile Wireless Sys

8. H Hierarchical Lattice Structure • Focus on MOVE/FIND for one mobile node t. • Define a hierarchical lattice just for t, based at a geographical point H(t.id). • Different lattices for different nodes are used to balance workload. • Consists of lattices Lk = Lk(t.id) at different levels k. • Lattice Lk is the set of grid points for a grid of squares of side 2k in both directions, starting from H = H(t.id). 2k Discrete Algs for Mobile Wireless Sys

9. Origin of Lattices for t • For each node identifier we build a hierarchy of lattices associated with the node identifier. • For node t, we use a double hash function H : V to [0,M] x [0,M] that maps node identifier to coordinates inside M x M: • H(t.id)={h1(t.id), h2(t.id)} • H(t.id) is the primary virtual home of node t. • H(t.id) never changes! It serves as the origin for all the lattices for t. Discrete Algs for Mobile Wireless Sys

10. 2k+1 Hierarchical Lattice Structure • For node t and all k = 0, 1, …, log M, define Lk(t.id) to be the lattice consisting of all corner points of the tiling with squares of size 2k x 2k having H(t.id) as its origin. H(t.id) 2k Discrete Algs for Mobile Wireless Sys

11. Hierarchical Lattice Structure • Now consider any point x in the overall square (location where t might move, or from which someone might try to find t). • For each k = 0, 1, …, log M, define Wk(t.id,x) to be the set of 4 corner points of the square of Lk(t.id)that contains x (break ties somehow). H x Discrete Algs for Mobile Wireless Sys

12. 21 x - W1(t.id,x) Hierarchical Lattice Structure H(t.id) - Origin - Some point x 20 - W0(t.id,x) Discrete Algs for Mobile Wireless Sys

13. Three algorithms • Spiral algorithm • Efficient FIND, average case. • Expensive MOVE. • Spiral-Flood algorithm • Efficient FIND, worst case. • Expensive MOVE. • LLS algorithm • Efficient FIND, worst case. • Efficient MOVE, average case. Discrete Algs for Mobile Wireless Sys

14. Spiral Algorithm • Record t’s location at the 4 corner nodes of the square that contains t’s current location, in all the lattices. • That is, at the points in Wk(x), for all k, where x is t's current location. • MOVE(x,y): • Expensive • Remove t’s old location information from the previous Wk(x) nodes. • Put t’s new location info in all the Wk(y) nodes. • They depict the strategy, in Figure 2, as “following a spiral”, which proceeds outward, in order k = 1, 2,… Discrete Algs for Mobile Wireless Sys

15. Spiral Algorithm FIND • FIND(t): Invoked from s, to find the current location x of t. • This queries corner nodes of the lattice squares that contain s, that is, the nodes in Wk(s). • Query proceeds in an outward spiral, in order k = 1, 2,… • Eventually, the spiral used by this FIND will intersect the spiral used by the most recent MOVE, that is, it will hit some point in Wk(x), for some k. • Guaranteed to happen at the first level of the hierarchy at which s and x are in (possibly diagonally) adjacent squares. • Then the FIND learns the actual location. Discrete Algs for Mobile Wireless Sys

16. Publish path Lookup path Nodes on the lookup spiral Nodes on the publish spiral (or) Location servers Source Destination Origin

17. Complexity Claim • Theorem: In Spiral, the cost of a FIND(t) from s, averaged over pairs (s,t), is O(d), where d = dist(s,t). • Assumes O(d) cost geographical routing. • Proof sketch: • FIND gets the info it needs by the time it reaches the lowest level, k, of the hierarchy where s and t are in adjacent squares. • It is possible that s and t are arbitrarily close together, and yet this could be a very high level in the hierarchy. • They avoid this problem by averaging over all (s,t) pairs, saying: “On the average”, dist(s,t) is proportional to the length of the side of the square at level k. (?) • Node at s must communicate with 4 nodes at each level up to k, distance proportional to 20 + 21 + …+ 2k, or O(2k), or O(dist(s,t)). • Geographical routing ensures actual cost of this communication is is O(dist(s,t)). (?) Discrete Algs for Mobile Wireless Sys

18. Spiral-Flood • Spiral has a problem near the boundaries, which prevents worst-case FIND behavior from depending only on geographical distance. • Spiral-Flood FIND: • Combines (interleaves) Spiral FIND algorithm with an Iterative Bounded Flooding (IBF) algorithm, which floods FIND requests from s to successively doubling distances. • Namely, s queries nodes along the same spiral-shaped path followed by the Spiral FIND algorithm. • But when the Spiral FIND has accumulated sufficient cost (22i), s floods a FIND query to depth 2i; this policy ensures that the combined cost is not more than a constant times the cost of Spiral alone. • But also, the cost doesn't exceed the cost of IBF alone, which is O(d2) in the worst case. • Here, d is min cost of a path from s to t, rather than geographical distance. • Uses density restriction. Discrete Algs for Mobile Wireless Sys

19. Spiral-Flood Complexity • Theorem: In Spiral-Flood: • The average cost of a FIND(t) from s is O(d), where d = dist(s,t). • The worst-case cost of a FIND(t) from s is O(d2), where d is the minimum cost of a path from s to t. Discrete Algs for Mobile Wireless Sys

20. LLS • Improves Spiral-Flood’s MOVE cost. • So far, info about t’s location is inserted in, and deleted from, all the Wk nodes by brute force; leads to cost O(k), where k is the max level that changes. • Could be much larger than distance moved. • New strategy attempts to update lazily, using ideas of [Awerbuch, Peleg], to keep cost proportional to distance moved. • But, they claim this only on the average (?). Discrete Algs for Mobile Wireless Sys

21. LLS • For each level k, store t’s location info not only in the corners of the square containing x (in Wk(x), where x is t’s current location), but also the corners of the 8 surrounding squares---16 nodes, called Zk(x). • When t moves within a 9-square area at level k, nothing changes at level k. • Update location info when t leaves the 9-square area, by which time the distance traveled by t must be at least 2k, the side of one square; thus, amortized cost of updating is kept low, a function of distance traveled. • Info stored at the Zk(x) nodes is not simply t’s location x, but rather, a forwarding pointer to the Wk-1(x) nodes (similar to [Awerbuch, Peleg]). • These nodes are lower in the hierarchy, and should contain better (finer, more recent) information for reaching t. • The Z0(x) nodes contain the actual location x. Discrete Algs for Mobile Wireless Sys

22. H(t.id) W9 W8 W10 W7 W11 W13 W14 W6 X W12 W16 W15 W5 W1 W2 W3 W4 2k

23. LLS MOVE Operation • MOVE from x to y: • If W0(x) = W0(y), no update is required (same lowest-level square). • Otherwise, do a spiral search from the new location y, to find the lowest level k, all of whose Wk(y) nodes have location info for t. • If k = 0, update Z0(x) and Z0(y) to delete and add location info, and return. (? Not in paper) • Otherwise, k > 0. • This means that t has moved outside the current level-(k-1) 9-square region. • Starting from location info in Wk(x), erase all location info for levels < k. • Then update each Zj(y) node, 1 ≤ j ≤ k, with a forwarding pointer to Wj-1(y). Discrete Algs for Mobile Wireless Sys

24. LLS FIND Operation • FIND, starting from s: • Start a spiral from s as before, but now the search ends when a forwarding pointer of the form Wk-1(y) is found in some Zk(y) node. • Once such a pointer is found, FIND can just follow the forwarding pointers to locate t. Discrete Algs for Mobile Wireless Sys

25. LLS Analysis • Theorem: In LLS: • The average cost of a FIND(t) from s is O(d), where d = dist(s ,t). • The worst-case cost of a FIND(t) from s is O(d2), where d is the minimum cost of a path from s to t. • The average cost of a MOVE(x, y) is O(d), where d = dist(x, y). • Analysis: LTTR. • The key idea is to amortize costs over a series of MOVE operations, making sure that before info is updated, the node has moved correspondingly far. • Justify their average calculations---are some independence assumptions needed? Discrete Algs for Mobile Wireless Sys

26. LLS Analysis • Simulations validate the theoretical average-case claims. • Fault-tolerance: They claim some fault-tolerance properties, because of: • Redundancy provided by using multiple nodes. • Locality of information-processing • The use of flooding. Discrete Algs for Mobile Wireless Sys

27. Simulations Routing: Connectivity percentage and cost/distance Inference: Cost of routing to the closest virtual point is only a constant times the distance. Discrete Algs for Mobile Wireless Sys

28. Simulations Lookup: Cost/distance, Cost/shortest path, Connectivity and flood percentages. Inference: The average cost of locating a mobile node is a constant factor from the optimum. Discrete Algs for Mobile Wireless Sys

29. Simulations Publish: Average hop distance Vs Average publish Cost Inference: The cumulative cost of updating location pointers is proportional to length of average hop. Discrete Algs for Mobile Wireless Sys