Draft Notes 1 : Scaling in Ad hoc Routing Protocols

Transcription

1 Draft Notes 1 : Scaling in Ad hoc Routing Protocols Timothy X Brown University of Colorado April 2, Introduction What is the best network wireless network routing protocol? This question is a function of what routing protocols do. The three basic functions of any routing protocol are: 1. Topology Discovery: What is connected to what in the network? 2. Route Choice: Given what we know about the network topology, what route do we choose? 3. Route Maintenance: How do we discover when a route is no longer good and what do we do to choose or discover a new route? 3 Flooding As a simple example, consider flooding. In flooding a source broadcasts a data packet along with a unique identifier (UID). This UID is used by every receiver to check if it has already heard this packet before or not. If not the receiver broadcasts the packet. In this way the data packet is eventually transmitted by every node in the network, except the receiver. How might we get a UID? The UID might be the source address and a distinct number assigned by that source. Flooding is simple in that it implicitly discovers the network topology, forming a tree of transmissions starting at the source and branching out to the other nodes in the network. It is robust since the message is repeated by many nodes in the network and thus a lost reception may not be significant if the receiver gets the packet from other nodes in the broadcast. The route choice is also implicit in that the packet follows all paths along the flooding tree. Route maintenance is also robust in the sense that it uses whatever connectivity exists at the time of the flood and assumes nothing based on prior floods. Flooding is a simple and robust protocol and so is a baseline against which to compare other protocols. How do we compare with other protocols? There might be several metrics related to packet delay, packet delivery ratio, and routing overhead. Delay might measure how much excess time it takes to deliver the data packet compared to the minimum time assuming the routing follows the shortest path. Packet delivery ratio is the ratio of packets 1

2 successfully delivered to the destination compared to the number of offered packets. Routing overhead might count the average number of packets sent in the network per packet successfully delivered. How does flooding hold up to these metrics? Flooding tends to follow shortest hop paths and so has excess delay close to zero. Since flooding sends packets via broadcast, there are no ACKs and a flood in a sparse network may fail to reach some areas of the network. Analyzing the packet delivery ratio is complex and in well connected networks with modest traffic is close to 1 so we will not consider it further here. Flooding s routing overhead depends on the number of nodes in the network. If there are n nodes in the network, each delivered packet will require n 1 packet transmissions (every node except the destination). 4 Scaling and Order notation: O( ), o( ), and Ω( ). We will be comparing several different classes of protocols. For a class of protocols the exact behavior may vary depending on implementation details. However, our concern is often to understand how the protocol scales, i.e. how a performance metric varies as the network somehow grows. Typical growth might be in terms of number of nodes, n, or total data traffic sent, D. Scaling is important because most protocols work well when the network is small and what we want to know is what becomes important or limiting as the network becomes large. As a network grows many factors may be in play, but a few will dominate and it is understanding how these dominating factors compare that is important. We might say that an algorithm is linear or logarithmic. The first we want to indicate that a doubling of the size might double the overhead. The second indicates that a doubling of the size might increase the overhead by a constant factor (log(2n) = log(n) + log(2)). Consider the case of flooding. The overhead is H(n) = n 1 packets per packet delivered. If we let n new = 2n then the new overhead is H(n new ) = 2n 1. This isn t an exact doubling since H(n new )/H(n) 2. Nevertheless, our intuition tells us that the 1 becomes insignificant as n becomes large and doubling n essentially doubles the overhead. To capture notion this we can write: H(n) = O(n) where the O(n) indicates that the overhead is growing essentially linear in n. Technically, H(n) = O(g(n))) implies H(n) ag(n) + b for some positive constants a and b. Thus H(n) = O(n) says that H(n) is upper bounded by a linear function, an + b. In other words we would say that the overhead grows no worse than a linear function. What if we say that H (n) = O(log n)? This implies that H (n) a log n + b. What is the base of the logarithm? Is it base 2 as in bits, or base 10 as in decibels, or natural logarithms? Can see that it does not matter? No matter what base, every log differs only by a constant factor. This constant factor only changes the a and b constants by the same factor. Since a and b are not explicitly defined, the base of the log is irrelevant. What can we say about H (n) = O(log n) versus H(n) = O(n)? We would know that for large enough n, H (n) < H(n) since for large enough n, log n n and a log(n) + b < an + b 2

3 for any set of positive a, a, b, and b. We would say that H (n) scales better than H(n). The key observation about order notation is that it allows us to compare the behavior of different algorithms or protocols without bogging down in the details of the exact implementation. It also allows us to highlight when differences are superficial (i.e. they have the same order) or fundamental. So you would never say that H(n) = O(7n + n). Although technically valid, it is customary to throw out everything that is captured by the factors a and b. Clearly, the 7 is not relevant since it is a constant factor. The square root is not relevant either since for large n, n n and could be captured by increasing a or b. 4.1 Order notation arithmetic If we do one algorithm followed by another then we add the two order notations. For example two O(log n) algorithms yields an O(log n) + O(log n) = O(2 log n) = O(log n) algorithm. As another example an O(n) algorithm followed by an O( n) algorithm yields an O(n) + O( n) = O(n + n) = O(n) If we repeat an O(n) algorithm a bounded number of times (e.g. at most B times)? Then it is O(Bn) = O(n). What if we repeat it n times? This factor of n can not be ignored. In this case, the complexity is O(n n). Thus, we get the rule that running a bounded number of algorithms has the order notation of the fastest growing algorithm. Running an algorithm an unbounded number of times generally increases the rate of growth. Finally, we note some pitfalls. First, though we say that two algorithms with the same order are superficially the same, they may differ by huge constants. An algorithm may be 2 times, 10 times, or 1,000 times worse but as long as they both have the same order such constants are lost. Second, though we say that one algorithm scales better than another again these are asymptotic results for when n is large. For some cases n may need to be really large to make a difference. For instance, H(n) = n = O(n) and H (n) = 10 6 log 2 n = O(log n). Though H (n) scales better, H(n) has lower overhead for all n < Only when n is larger than this does the better scaling become apparent. Third, some surprising statements can be made because O() is just a bound. For instance if H(n) = O(log n) then H(n) = O(n). Why? Because if H(n) a log n + b then there exists constants so that H(n) a n + b. How would we characterize the excess delay for flooding? Here we would say that D(n) = O(1). This is an alternative way of saying that the excess delay is bounded no matter how big the network. Why is this true? As the message propagates in the flood, it naturally will follow the shortest path to the destination Finally, we note that there are other order notations such as o(n) which serves as a lower bound and Ω(n) which serves as both an upper and lower bound. We will not define these here. 3

4 5 Ad hoc Routing Protocols We had discussed two classes ad hoc routing protocols in class, proactive and reactive protocols. Armed with our order notation we can say something about each of these classes without analyzing any specific protocol. 5.1 Reactive Protocols In a reactive protocol, the first packet that a source has to send to a destination requires a route discovery. If we assume that this discovery is a flooding mechanism, followed by a bounded number of responses from the destination then the discovery will require at most O(n) + O(Bn) = O(n). The first O(n) is the cost of the flood as computed above. The O(Bn) represents the bounded number of responses. In the worst case the network is a long chain of n nodes and the response has to traverse from one side of the chain to the other. In a more realistic topology, the response might go through only a few nodes but that is not relevant here since as we show here even the worst case assumption does not change the order for the route discovery. Now consider the forwarding of packets. Let us suppose that the route to forward a packet is typically O(R(n)) hops. Then the complexity to forward a single packet from one source to one destination is O(n) + O(R(n)) = O(n). This follows because in the worst case, the route will pass through O(n) hops as described in flooding. So, we see that reactive protocols are no better than flooding if we must discover a new route for each packet. Clearly, reactive protocols only improve over flooding if we can send many packets before we need to perform a route discovery. If the network is static, then a single discovery can be shared by all subsequent packets sent to the same destination. If we ultimately send S packets to the same destination then the cost of the initial flood can be amortized across the S packets sent. In this case, the cost to send S packets is: and the cost per packet is O(n) + O(SR(n)) O(n/S) + O(R(n)). Clearly if S grows with n and R(n) is sublinear then we can do better with reactive protocols than with flooding. For example, assume that a network is compact and roughly a square grid with n rows of n nodes. 1 In this case R(n) = n. Further, assume the network is very stable so that the first term can be ignored. In this case, the overhead of the reactive protocol is O( n) packets per packet delivered. 1 Embedded in this claim is the assumption that the area covered by the network is growing proportional to the number of nodes; a four times increase in nodes results in a 2 times increase in the width and height of the area covered. This implies that the expected number of hops between two random nodes grows as the square root of the number of nodes if the range of every node is bounded. This discussion emphasizes the importance of spelling out your assumptions. Other assumptions could have been made with different results. 4

5 5.2 Proactive Protocols Consider a simple distance vector protocol that sends periodic table announcements to its neighbors. Here the announcements are sent as broadcasts. Let S be the number of packets sent between each broadcasts by some node in the network. If as before, R(n) is the scaling of the expected route length then in one period we have n announcements sent (every node sends an announce ment) and we send S packets to their destination. Thus, the cost to send S packets is and the cost per packet is O(n) + O(SR(n)) O(n/S) + O(R(n)); exactly the same as for the reactive protocols. Another proactive protocol is a link-state protocol. We can ignore the initial topology dissemination. Why? Because this is done once and is amortized across all subsequent packets that are sent. Once every node has the topology, link changes are announced by the nodes on each side of the termination flooding out the change. So, again, if S packets are sent out between each change and each change yields an O(n) flood, then we get the exact same result as before. 5.3 Link Stability, S Now we should investigate the stability factor in more detail. A simple model has each link stable for a random time with some average time t. Now if we consider k links, then the average time before any one breaks is t = O( 1 ). Now if there are f flows being sent from k k some source to some destination, and each flow has the same expected rate, r, then the total rate is fr = O(f). Finally, if f flows are sending data for the period that k links are stable we see that the number of packets that are sent while all the links are stable is S = O( f ). k The values of f and k differ for each of the three examples that we have studied. In the case of the simple reactive protocol, f = 1 since we are considering only one route and k = O(R(n)) since the route can be used for as long as all the links on the route are stable. Thus, S = O( 1 ). R(n) With the proactive distance vector protocol we can assume that the number of flows is proportional to the number of nodes, f n. A lower bound on the period in which neighbor updates are sent is that they are sent at least as often as links break in the network. If node density is fixed, then with increasing n the number of neighbors stays constant and the number of links k n. Thus S = O(1). The same argument applies to the proactive link state protocol so that S = O(1). Note that S is a constant or decreases with n. This implies that n/s grows faster than linear. Since R(n) is at worst linear we can write O(R(n)) = O(n). But this term can be ignored compared to O(S/n). Combining these results yields the following table: 5

6 Protocol S cost per packet Reactive O( 1 R(n) O(nR(n)) Distance Vector O(1) O(n) Link State O(1) O(n) Flooding N/A O(n) From the table we see that none of the protocols scales better then flooding if the network is dynamic. In order to scale, it is clear that something more than the simple versions of these protocols described here are required. Most protocols use various techniques that do make them very efficient, but in the limit they scale no better than flooding. For this reason the protocols often specify a maximum size for which they are designed. 6