Slide 1
Chapter 6
Multispeed Access Designs
Slide 2
OR OR
One-speed One-Center Design
Problem: Connecting sites to a backbone node, all links with the same capacity
Review
Slide 3
Capacitated Minimum Spanning Tree Problem(CMST)
CMST problem: Given a central node N0 and a set of other nodes (N1, …, Nn), a set of weights(w1,…,wn) for each node, the capacity of a link, W, and a cost matrix Cost(i,j), find a set of trees T1, …, Tk such that each Ni belongs to exactly one Tj and each Tj contains N0.
0,iTii
j
Ww
Trees Linksl
ll endendCost )2,1(min
Slide 4
The Esau-William Algorithm
Heuristic Algorithm but guarantees the tree meets the capacity constraint
Each node starts off in a tree with 1 node. Compute the tradeoff function for each node:
Tradeoff(Nk)=minj Cost(Nk, Nj)-Cost(Comp(Nk),Center)
If the tradeoff is negative, a merge is attractive Merge is allowed if
Tradeoff for merging components A and B computes the potential savings of going to a neighbor instead of going to the center node.
W))p(NWeight(Com))p(NWeight(Com JK
Slide 5
Overview
We need to introduce designs with multiple link types, because networks are built of a variety of different links.
The cost of links is set by the market or government regulations, not any law of nature.
Assume we have 3 different sorts of access links:
Slide 6
Multispeed Access Designs
Assume the weight of the access sites is in the range of 2,400 bps to 36 Kbps, what happens if we are allowed multiple link types and still use either the Esau-Williams or Sharma’s algorithm?
If we use 9.6 Kbps or 56 Kbps links, both algorithms fail because it’s impossible to fit 36 Kbps of flow on a single line and still keep the utilization under 50%.
If we use 128 Kbps links, we will massively overdesign the networks for the smaller nodes.
We need an algorithm that builds a tree with links of different capacity.
Slide 7
Continued
We’ll replace the capacitated MST problem with a multispeed MST problem.
Intuitively, the tree should have small-capacity links at the ends and should become “fatter” as we move toward the center of the networks, like the structure of a real tree.
To define this type of tree
we need a bit more notation.
Slide 8
Predecessor Function (definition 6.1)
A tree T rooted at a node Root can be represented uniquely by a predecessor function pred : V V on the set of vertices. The predecessor function moves 1 step closer to the root.
Requirement: pred(Root) = Root pred(N) N for any other node N For any node N, n > 0 such that pred n(N)=
RootA tree is defined by the set of vertices V and edges (N, pred(N)) for all N Root
Pred(5)=2
Root
21
3 4 5
Pred(Root)=Root
Pred(2)=RootPred(2) =
Pred(Pred(5))=Pred2(5)=Root
Slide 9
Ancestors (definition 6.2)
Given a tree T and the associated predecessor function, the ancestors of N are all the nodes N’ such that
pred n (N’) = N for some n > 0
65
7 8 9
Pred2(9)=4
Pred(6)=4
4
Node 5 through 9 are ancestors of node 4.
A misnomer?
Slide 10
Given the following notations:
A set of nodes N0, N1, N2, … , Nn.
A set of weights (w1, w2, … , wn) for each node
A set of link types L1, L2, … , Lm
Capacities W1, W2, … , Wm
A cost matrix C(i, j, k) that gives the cost of a link of type Lk between Ni and Nj
Slide 11
Multispeed CMST (definition 6.3)
The multispeed CMST problem is to find the tree rooted at N0 and the link assignments such that
(i)
(ii)
)(
))(,()(NAncestersN
NpredNLinkWiw
Linksl
lll typeendendc ),2,1(
65
7 8 9
4
If N is node 4, then
w(4)+w(5)+w(6)+w(7)+w(
8)+w(9)< Wlink(4,pred(4))
is a minimum
A set of link types L1, L2, … , Lm
Clearly if m=1, this problem becomes the CMST problem
Slide 12
Multispeed Local Access Algorithm(MSLA) Assign each node the smallest link l possible to
connect it to the center. For each node n, compute spare_capacity(n)=Wl -wn and set pred(n)=0
Calculate trade-offs (savings from linking site n to site i rather than linking directly to the center). And upgrade links to carry additional traffic:
Tradeoffn(i)= c(n,i, l ) + Upgrade(i,wn) – c(n,0, l )
Tradeoff(n)= mini Tradeoffn(i)
Add the edges as long as the tradeoffs are less than or equal to zero. Terminate when the tree is built and each edge is assigned to its link type.
Assume the center is node 0
- Upgrade(i,wn) is the cost of adding wn units to the links that connect i and 0.
Slide 13
MSLA Example
Initial State (Utilization=0.5)
spare_capacity(1)=0.5*56000-20000=8000
spare_capacity(2)=0.5*9600-2400=2400
spare_capacity(3)=0.5*56000-9600=18400
spare_capacity(4)=0.5*9600-4800=0
L0
L1
L2
1. Use the links shown in Table 6.1 at a 50% utilization:
Define D96 as link type L0
Define D56 as link type L1
Define F128 as link type L2
2. Assume N0 is center.
We have 4 access nodes and their weights in Figure 6.1:
Table 6.1
Figure 6.1
Initial state
L1
L0
L1
L0
Slide 14
State 2: N2 is furthest away from N0. It is closer to N4. For N2 to go through N4, require (4,0) to upgrade from 9.6 Kbps to 56 Kbps. Upgrade(4,2400)= c(4,0,1) – c(4,0,0) ;Tradeoff2(4)=c(2,4,0)+(c(4,0,1)–c(4,0,0)) – c(2,0,0)Positive, not pick.
Let N4 goes through N3,no upgrade is needed.It’s the best tradeoff. w3=w3+w4=9600+4800=14400
spare_capacity(3)=18400-4800=13600
L0L1L2
L1
L0
L1
L0 Initial
state
L1
L1
L0
L0
State 3: Next, the most attractive tradeoff is route N2 through N3. Again no upgrade is needed.
w3=w3 + w2 =14400 + 2400 =16800spare_capacity(3)=13600-2400=11200
L0L
0
L1
L1
State 2
State 3
Slide 15
Finally, connect N3 to N1 and increase (1,0) to 128 Kbps link.
Spare_capacity(1)=0.5*128000-16800-20000=27200
My question: why not use state 3 ?
L0L
0
L1
L1
State 3
L0
L0
L1
L2
Final design
•spare_capacity(3)=13600-2400=11200
•spare_capacity(1)=8000 (initial)
Reason: Final design might make good use of the economy of scale offered by the higher speed links.
L0L1L2
Slide 16
A realistic example of MSLA Algorithm:
We have 20 nodes in Squareworld and the weights of the nodes are generated according to the above TABLE TRAFDIST.
Weights of nodes are shown in the TABLE SITES. Note that the weight of N0 is normalized so that it sums to the traffic from all the other sites.
To simplify the mathematics, we assume that every line can be used to 100% of capacity.
Slide 17
Esau Williams: 20 nodes with 9.6Kbps links
Cost = $26,963
Only 9 sites share links to N0, more like a star.
Slide 18
Esau Williams: 20 nodes with 56Kbps links
Cost = $30,160
A nice tree structure, but the cost is higher because out on the periphery of the network there is too much capacity.
Slide 19
MSLA: 20 nodes with multispeed links
Cost = $22,760 the best
There is a central D56 tree and a peripheral D96 tree
Slide 20
Chapter 7
MultiCenter Local-Access Design
Slide 21
What happens if there are multiple centers? Must build a forest instead of a tree. So what is a forest?
Definition 7.1
A forest F = ( V,E ) is a simple graph without cycles.
Note: a forest need not be connected.
Slide 22
Notations:
A set of backbone sites (B0, …, Bm) = B
A set of access nodes (N1, … , Nn) = N
A set of weights (w1, … , wn) for each access node
A upper limit of weight, W.
A cost matrix Cost(i,j) giving the costs between each backbone/access pair of sites.
Slide 23
MultiCenter Local Access Problem(MCLA) Definition 4.2 The multicenter local – access problem is to
find a set of trees T1, … , Tk such that
(1) Exactly 1 backbone site belongs to each tree
(2)
(3) is a minimum
WwjiTN i
Trees Linksl ll endendCost )2,1(
Slide 24
An example
Circle 3 backbone nodes X, Y and Z
Square 17 access nodes A, B, C and D, etc
Slide 25
Comments:
This problem is a bit more complex than the single-center one
Suppose we have n access nodes that we want to partition into 3 sets. The number of possible partitions is :
Each partition of the access sites results in 3 capacitated MST problems each of which can be attacked by the Esau-Williams algorithm
n
k
kn
k
n2
Even for the modest number 17,
the complexity is daunting!
Slide 26
Nearest-Neighbor Esau-Williams(NNEW) For each b in B, let Sb={ nN | Cost(n,b) < Cost(n,b’) b’B}
If n is equidistant between several backbone nodes, add n to one Sb at random.
Use Esau-Williams to construct a capacitated MST on each set bSb.
Example:
A definitely belongs to X (since X is not only the closest backbone node to A; it is almost the closest node to A) B, C and D not clear
Slide 27
Creditability Test Test: reattach the leaves to a different tree and see if it
reduces the cost. The creditability of NNEW is not good
Let us look at two failed examples.
Slide 28
Example 1: a 10-site bad design
Slide 29
Example 2: another 10-site bad design
Slide 30
Design Principle 7.1
In local-access design with multiple centers, the location of the other access nodes cannot be ignored when deciding which access nodes should home to which center.
What do we deduce from the 2 examples?
Slide 31
MultiCenter Esau-Williams algorithm(MCEW or Kershenbaum-Chou)
A variant of the original Esau-Williams algorithm
Recall that, in Esau-Williams algorithm, we calculate the tradeoff as the saving by linking Ni to Nj instead of linking it directly to the center.
Tradeoff(Ni)=minjCost(Ni, Nj) - Cost(Comp(Ni),Center) MCEW algorithm replaces the tradeoff function as:
Tradeoff(Ni)=minjCost(Ni, Nj) - Cost(Comp(Ni),Center(Ni))
Initially, we set Center(Ni) to be the closest center.
As node Ni is merged with node Nj, update Center(Ni)=Center(Nj).
Slide 32
NNEW vs. MCEW
Only a slight cost advantage of using MCEW as opposed to NNEW.
MCEW is far more creditable than NNEW.
Slide 33
Practical Suggestions
Design Principle 7.2
The designer needs to be inventive and agile when dealing with unusual constraints.
From GÖdel’s theorem: Given any set of algorithms, it is always possible to formulate a problem for which they provide no good solution.
Slide 34
Some access trees contain too many nodes.
EW tests only if the combined weight of the two components doesn’t exceed the upper bound weight_limit.
Solution: add additional size_limit constraints that prohibit the merge of two components with too many nodes.
Slide 35
Some access trees contain too many hops.
Solution: add depth checking constraint,
i.e., depth-limit the tree built by EW
Each site maintains a value depth[ni]
Initially set to 1, update when we evaluate the tradeoff between n1 and n2,
Depth[n2] = max (depth[n2], depth[n1] +1)
and compare against threshold.
Slide 36
Some site in the access tree has too many links
Solution: add degree constraint, or a “valence” constraint.
Initialize the valence of each site to 1, when we accept the merge from n1 to n2 then we increase the valence of n2 by 1. Do not accept merges that violates the constraint.
Slide 37
A central site has too many links
Solution 1: Modify the tradeoff function as
Tradeoff(Ni)=minj Cost(Ni,Nj)-a*Cost(Comp(Ni),Center))
where a > 1. By adjusting a we limit the links that connect to a center.
Solution 2: If we have multiple centers and EW has overloaded a given site, use NNEW or MCEW with initial assignment of centers overridden to low utilization center.
Slide 38
Some site fails too often
If a given site is known to have availability problems, it shouldn’t be an interior point.
Solution: Mark it as not being able to be set as a predecessor of other sites.
Slide 39
To overcome such constraints without the ability to rewrite programs is hopeless!
Design Principle 7.3
Designers need to be able to modify algorithms to deal with unusual constraints. This may necessitate adding a programmer to the design team but it will be well worth the effort and expense. The programmer needs to know the code and to understand the idea that is being carried out in the algorithm. This requires a deeper understanding than can be obtained from reading the comments in the existing code.
Slide 40
Design a connected topology that connects nodes 1, …, 4 to center 0. The link types are listed below. Cost tables are listed on the next slide.
HW #7 Due Date: July 04
NODE WEIGHT
1 20,000
2 2,400
3 9,600
4 4,800
Link Type Capacity
0 4.8 K
1 28 K
2 64 K
Slide 41
0 1 2 3 4
0 - 5 7 5 7
1 5 - 7 6 6
2 7 7 - 5 6
3 5 6 5 - 5
4 7 6 6 5 -
Link 0
0 1 2 3 4
0 - 10 15 10 15
1 10 - 10 12 12
2 15 10 - 12 10
3 10 12 12 - 10
4 15 12 10 10 -
Link 1
0 1 2 3 4
0 - 20
25
20
25
1 20
- 20
22
22
2 25
20
- 22
20
3 20
22
22
- 20
4 25
22
20
20
-
Link 2
Cost Tables
Slide 42
THE END
Thank you!Thank you!