CPSC 689: Discrete Algorithms for Mobile and Wireless Systems

CPSC 689: Discrete Algorithms for Mobile and Wireless Systems

Spring 2009

Prof. Jennifer Welch

Discrete Algs for Mobile Wireless Sys 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


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


19

37

Example Drawback of GLS


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 (?)


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.)


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.


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).

H

2k


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.


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


2k+1



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


H(t.id)

x

20

- Origin

- Some point x


- W0(t.id,x)

21

- W1(t.id,x)


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.


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,…


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.

Spiral Algorithm FIND

Publish path

Lookup pathNodes on the lookup spiralNodes on the publish spiral (or) Location serversSource

Destination

Origin


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)). (?)


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.


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.


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 (?).


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.

W9W10 W8 W7

W11 W13 W14 W6

W12

W1 W2 W3 W4

W15 W5W16X

H(t.id)

2k


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).


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.


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?


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.


Simulations

Routing: Connectivity percentage and cost/distance

Inference: Cost of routing to the closest virtual point is only a constant times the distance.


Simulations

Inference: The average cost of locating a mobile node is a constant factor from the optimum.

Lookup: Cost/distance, Cost/shortest path, Connectivity and flood percentages.


Simulations

Publish: Average hop distance Vs Average publish Cost

Inference: The cumulative cost of updating location pointers is proportional to length of average hop.

Date post:	02-Jan-2016
Category:	Documents
Upload:	quinlan-roberts
View:	29 times
Download:	0 times

CPSC 689: Discrete Algorithms for Mobile and Wireless Systems

Documents