1 TCOM 541 Session 2

2 Mesh Network Design Algorithms for access are not suitable for backbone design –Access designs generally are trees – sites connect to center Diverse access (redundancy) is another question, and only needed for special situations –Backbone designs require many-many connectivity

3 MENTOR Algorithm “High quality, low complexity” algorithm Originally developed for time division multiplexing –Works with other technologies

4 MENTOR Algorithm (2) Assume initially only a single link type of capacity C Divide sites into backbone sites and end sites –Backbone sites are aggregation points –Several algorithms to do this Threshold clustering is used

5 Threshold Clustering Weight of a site is sum of all traffic into and out of the site Normalized weight of site i is NW(i) = W(i)/C Sites with NW(i) > W are made into backbone sites –Where W is a parameter

6 Threshold Clustering (2) All sites that do not meet the weight criterion and are close to a backbone site are made into end sites –“Close” is defined as when the link cost from the end site e to the backbone site is less than a predefined fraction of the maximum link cost MAXCOST = max i,j cost(N i,N j ): cost(e,N i ) < MAXCOST*RPARM

7 Threshold Clustering (3) If all sites that pass the weight limit as backbone sites have been chosen and there are still edge sites “too far” from any backbone site, we assign a “merit” to each site –Assign coordinates to each site (e.g., V&H) –Compute center of gravity of sites

8 Center of Gravity (CG) Defined as (xctr, yctr) where xctr =  n x n W n /  W n yctr =  n y n W n /  W n Note: These coordinates need not correspond to any actual site

9 Distances to CG Define dc n = [(x n -xctr) 2 + (y n -yctr) 2 ] 0.5 maxdc = max(dc n ) maxW = max(W n ) Then merit n = 0.5(maxdc–dcn)/maxdc + 0.5(W n /maxW) That is, “merit” gives equal value to a node’s proximity to the center and to its weight

10 MENTOR Algorithm (3) From among remaining nodes, choose the one with the highest merit as a backbone node Continue until all nodes are either backbone nodes or within RPARM*MAXCOST of a backbone node Select backbone node with smallest moment to be center –Moment(n) =  dist(n,n*)W n* Construct a Prim-Dijkstra tree, parameter 

11 MENTOR Example Backbone node Edge node Radius = RPARM*MAXCOST C*G

12 MENTOR Example (2) Backbone node Edge node Radius = RPARM*MAXCOST C*G

13 MENTOR Example (3) Backbone node Edge node Radius = RPARM*MAXCOST C*G

14 MENTOR Example (4) Backbone node Edge node Radius = RPARM*MAXCOST C*G

15 MENTOR Example (5) Backbone node Edge node Radius = RPARM*MAXCOST C*G

16 Need for Improvement As we know, tree designs have several drawbacks, especially for large networks –Lack of redundancy increases probability of failure – Chain-like network (low  ) Aggregation of traffic in “central” links raises costs Large average hops in large networks –Star-like network network (high  ) May have low link utilization

17 Refining the Design in MENTOR We introduce the concepts of sequencing and homing to add links so as to make a better design by adding direct links where the traffic justifies it Use the Prim-Dijkstra tree to define a sequencing of the sites –A sequencing is an outside-in ordering –Do not sequence the pair (N1,N2) until all pairs (N1*,N2*) have been sequenced where N1 and N2 lie on the path between N1* and N2* –Roughly, the longest paths get sequenced first

18 Example of Sequencing A B C D E Sequence AE AF BE BF CE CF DA DB AC BC … DF F 3 hops 2 hops 1 hop

19 Comments on Sequences Sequences are not unique Different (valid) sequences do not influence the design greatly

20 Homing For each pair of nodes (N1, N2) that are not adjacent we select a home –If 2 hops separate N1 and N2, the home is the node between them –If they are more than 2 hops apart there are multiple candidates for their home

21 Homing (2) N1 N2 N3 N4 Candidate for home (N1,N2) Choose N3 as home(N1,N2) if: Cost(N1,N3) + Cost(N3,N2) < Cost(N1,N4) + Cost(N4,N2) Otherwise choose N4

22 Last Step Consider each node pair only once, add a link if it will carry enough traffic to justify itself Consider the traffic matrix T(Ni,Nj) –Assume it is symmetric –Recall that MENTOR was developed to design TDM networks, and muxes are bi-directional (usually)

23 Last Step (2) For each pair (N1,N2), execute the following algorithm: 1.If capacity of a link is C, compute n = ceil[T(N1,N2)/C] 2.Compute utilization u = T(N1,N2)/(n*C) 3.Add link if u > umin, otherwise move traffic 1 hop through the network I.e., add T(N1,N2) to both T(N1,H) and T(H,N2) And do same for T(N2,N1) Note – there is a special case when (N1,N2) belongs to the original tree In this case just add the link (N1,N2) to the design

24 Comments The link-adding algorithm aggregates traffic to justify links between nodes that are multiple hops apart If traffic between N1 and N2 cannot justify a direct link, it is routed through their home node H Eventually, in large networks, enough traffic is aggregated to justify a direct link

25 Comments (2) Performance of MENTOR is governed by utilization parameter umin and the Prim-Dijkstra tree-building parameter  How easy it is to add new links is controlled by umin  he shape of the initial tree is controlled by  –High  will build a star-like tree – then links will be added only between site pairs that have enough traffic without help from other nodes –Low  will build a more chain-like tree, so there will be more aggregation of traffic and likely addition of links

26 Performance of MENTOR Low-cost algorithm –Three main steps Backbone selection Tree building Link addition –All of O(n 2 ) –Possible to re-run many times, varying parameters

27 MENTOR Example Based on mux1.inp on Cahn’s FTP site 15 sites, kbps circuits

28 Initial Choice of Backbone Nodes (5) Backbone node

29 Initial Design x T1  = 0 Cost = $269,785/month 2 x T1

30 Review of Initial Design Backbone links have multiple (5) T1 links Probably not a good thing Design Principle: –If a design has multiple parallel high-speed links there is usually a better, meshier design Lower cost, greater diversity (= reliability) Note this is not mathematically provable

31 Revised Design umin = 0.7 Cost = $221,

32 “Best” 5-Node Backbone Design  = 0.1 umin = 0.9 Cost = 209,220

33 Comments Note that we produced multiple designs by varying some parameters and picking the best Of course, there is no guarantee that this design really is “best” In fact, changing number of backbone nodes yields much better designs –13-node backbone yields design costing only $191,395 –12-node backbone costs $198,975

34 Routing Now we have designed a good network, we consider how the traffic will actually flow across it This introduces a whole new class of problems that center on the performance of the routing algorithms

35 Feasibility Considerations For any pair of nodes N 0 and N 1, define a route by (N0, N1, h,n) Where n = 0 if h is adjacent to N 0 and n = 1 if h is adjacent to N 1 If N 0 and N 1 are adjacent, we have a direct route –Else the route is the link (N n,h) and the route (N 1-n,h,n*,n*) Continue until the full route is established

36 Feasibility Considerations This process establishes a feasible routing pattern for the network However, the muxes may not be smart enough to find this pattern As an example, consider single-route, minimum-hop (SRMH) routing

37 An SRMH Disaster Assume MENTOR adds link BF to carry traffic from B to F, G, H, I – but not traffic from F to ABC SRMH insists on carrying all traffic from A, B, C to F, G, H, I – result is overload on BF C A B D E F H I G

38 Feasibility and Routing In reality, few network-loading algorithms are as bad as SRMH However, network-loading algorithms do add to the design constraints –In particular, minimum-hop routing algorithms are fragile with respect to network capacity changes –Effective algorithms for redesign are not available

39 A More Realistic Loading Algorithm Flow-Sensitive, Minimum-Hop (FSMH) loader loads traffic onto a minimum-hop path, subject to using only links with enough free capacity to carry it –Allows overflow onto longer paths –If no path exists, traffic is blocked However, there is no guarantee that FSMH will do better than SRMH!

40 FSMH Failure Example A CD B ABCD A21 B1 C1 D Traffic: SRMH will block the second AB traffic and load 4 out of 5 requirements FSMH will load load both AB requirements, but block all the rest Note: order of loading traffic is significant! Each link has capacity 1

41 Comments on FSMH In the earlier example (15 sites), FSMH fails on the best designs –13-node, $191k design blocks 3.3% of traffic –12-node, $199k design blocks 6.7% of traffic Best design where FSMH does not block is 11-node, $201k

42 Approaches We cannot guarantee that a highly-optimized network design will work with a given routing algorithm Approaches –Test the loading algorithm against best designs Routing takes more computation than design Raises complexity to between O(n 3 ) and O(n 4 ) –Limit maximum link utilization to <100% Also increases reliability, allows for growth

43 Router Network Design Common routing algorithm for IP is OSPF (Open Shortest Path First) Implicit problem is design for minimum distance –Single-route, minimum distance loader (SRMD) Computes single shortest path between site pairs If traffic saturates the route, it’s discarded Designer chooses link lengths appropriately

44 SRMD Characteristics Traffic not forced onto illogical paths if link lengths are chosen properly Problems can still arise –Not dynamic –Cannot split traffic between different routes

45 OSPF Example C A B D E F H I G This link intended to carry traffic between A and H, and B to H but not traffic between A and G A-H traffic will take 1-hop path length 395 B-H traffic will take 2-hop path length 485 A-G traffic will take 5-hop path length 490

46 Important Difference Mux networks are designed for high utilization Router networks are not designed for high utilization –Allows some margin for error by the routing algorithm

47 Comments Can encourage the traffic to use the MENTOR routing as we add edges by setting the length of each tree edge to 100, and the length of a direct edge between N1 and N2 to: *hops(N1,N2)

48 Comments (2) Any routing algorithm should work for a tree Problems arise when design becomes more highly meshed Can manipulate solution by –Increasing length of overloaded links –Shortening under-utilized links –Adding or deleting capacity

49 Homework Assignment Cahn Exercises 8.2, 8.6 Read Cahn Chapter 9