For network service providers, the effectiveness of a restoration scheme can be ... of our proposed algorithm through simulation of a typical intercity backbone.
Efficient Segment-by-Segment Restoration
Dongmei Wang, Guangzhi Li, Jennifer Yates and Chuck Kalmanek {mei,gli,jyates,crk}@research.att.com AT&T Labs – Research, NJ 07932-0971, USA
Abstract: A dynamic approach is proposed for segment-by-segment restoration in intelligent optical networks. This approach significantly improves the failure restoration time whilst bounding the restoration path length and maintaining low bandwidth overbuild. 1. Introduction Intelligent optical networks, such as those enabled by Generalized Multi-Protocol Label Switching (GMPLS), facilitate the use of efficient and rapid restoration of connectivity from failures through procedures such as shared mesh restoration [1]. In shared mesh restoration, each connection is provided via two failure-disjoint (e.g., link/node/SRLG disjoint) paths: a service path and a restoration path. To enable restoration bandwidth to be shared among multiple restoration paths, the restoration paths are established after failure, with bandwidth optionally reserved before failure. For network service providers, the effectiveness of a restoration scheme can be measured according to two key factors: the speed and the restoration overbuild. The restoration overbuild is the ratio of the total restoration capacity to the total service capacity. The restoration time for a specific connection includes the failure notification and restoration path establishment times. In general, the failure notification time increases with increasing service path length, and the restoration path establishment time increases with increasing restoration path length. Hence, keeping both the service path and the associated restoration path length small typically reduces the restoration time. The restoration path selection scheme has a direct impact on the restoration overbuild: as shown in [2], significant savings can be achieved by sharing restoration bandwidth reservations among service paths that are failure-disjoint. However, selecting restoration paths to maximize bandwidth sharing typically increases restoration path lengths, leading to longer restoration times [3]. One approach to improving restoration speed and reducing overbuild is to use segment restoration, in which the service path is split into multiple segments, with each segment independently recovering from failures [4]. Both the lengths of the service path of each segment and the corresponding restoration path are expected to be shorter than the lengths of the service and restoration paths for the end-to-end restoration, generally corresponding to improved restoration times. However, selecting appropriate segments and restoration paths is a challenging problem. This paper provides an efficient Dynamic Segment Selection (DSS) heuristic that selects the segments and corresponding restoration paths in a bid to minimize bandwidth overbuild subject to maximum restoration and service path length constraints. We demonstrate the efficiency of our proposed algorithm through simulation of a typical intercity backbone network and compare it with two established algorithms, namely the shortest disjoint path (SDP) and the static segment algorithms (SSA). The simulation results show that the DSS heuristic proposed here reduces the average restoration path length by 50% compared with SSA, whilst simultaneously reducing the bandwidth overbuild. DSS also reduces the bandwidth overbuild by 20% compared with the SDP algorithm with only small increases in the average restoration path length. 2. Dynamic Segment Selection 4 H
2 0
G 3
3 0
D ε
2 0
F
0
J
5
Figure 1: A directed graph sample
Optimal selection of segments and restoration paths is an NPhard problem – this can be proved simply by recognizing that this problem reduces to the calculation of end-to-end restoration paths, which is known to be NP-hard. We thus propose the DSS heuristic, which selects both segments and restoration paths so that bandwidth overbuild is minimized subject to the segment restoration path length bound. DSS assumes that the end-to-end service path is pre-selected using whatever algorithm is deemed appropriate. We also assume that the optical cross-connects (OXCs) have wavelength conversion capabilities (all-optical or
opto-electronic). The idea behind DSS is to dynamically split the service path into service segments such that the maximum length for both service segments and restoration paths is bounded. This is achieved by enumerating all of the acceptable service segments – i.e., the set of segments whose path length is no more than the pre-defined maximum segment path length. Once we have selected these segments, we calculate the “best” possible restoration path for each segment (one that minimizes overbuild), subject to restoration path length constraints. Then we select the “best” combination of segments and associated restoration paths from the set of possible segments.
We use Figure 1 to illustrate our algorithm. Our service path is defined from source H to destination J, passing through nodes G, D and F in an optical network. The first step of the algorithm is to construct a directed graph by enumerating the set of possible segments that can be constructed along the service path, along with weights denoting the "cost" of a restoration path. The nodes in the directed graph are the nodes along the service path, namely H, G, D, F, and J. We then define the edges of the graph to be the set of service path segments that can be constructed which have segment lengths less than a pre-defined maximum: SPmax (defined according to any measure of cost; here we use hop count). In Figure 1, we define SPmax = 2, so that the segments are at most 2 hops. The edges are uni-directional, from source to destination. However, to allow the algorithm to select segments that overlap, we also define zero cost edges in the reverse direction between service path nodes (i.e., between J - F, F - D, D - G, and G H). Once we have identified the edges in the directed graph (the set of possible segments and associated restoration paths), we assign edge weights. The aim is to select paths that minimize the overall bandwidth overbuild, while ensuring that the restoration path length associated with each segment does not exceed a pre-defined maximum, RPmax. For each segment defined in the graph (i.e., each forward edge), we compute a SRLG (or fiber span) disjoint restoration path with length no more than RPmax (set to 5 in Figure 1), and calculate the additional bandwidth required on the links along this path. If there is no path that satisfies the RPmax constraint, we remove the edge from the directed graph. However, if we do find a path, we assign the additional bandwidth required by the calculated restoration path to be the weight of the associated edge in the directed graph. If the weight is zero (i.e., no additional restoration capacity needs to be assigned to protect this segment due to bandwidth sharing), then the segment weight is set to a small number ε. This serves to minimize the number of segments used. Once we have this weighted directed graph, we calculate the shortest path from source to destination. The result is a restoration path that “minimizes” the overall additional restoration capacity for the connection. In Figure 1, the shortest path is H-D-G-F-J, which splits the service path into three segments H-D, G-F, and F-J. Note that when two protection segments overlap with one another, we use the segment with the nearest upstream end point as the protection segment. To calculate the restoration paths for a given segment, we extend the restoration path calculation algorithm from [2] to constrain the restoration paths to a maximum length. The heuristic in [2] calculates a restoration path that “minimizes” the bandwidth overbuild without considering the restoration path length. Here, we introduce an additional parameter, α, that is added to all of the link weights defined in [2] to increase their values. We then iterate through the restoration path selection process of [2], starting with α = 0 and incrementing α by a small value in successive iterations. Since the same constant α is added to each link in the network, increasing α affects the restoration path computation by selecting fewer hops along the restoration path. In fact, as α becomes large, this heuristic selects the shortest disjoint path without attempting to minimize the extra restoration capacity. We slowly increase until we find a restoration path with length no more than the restoration path length upper bound, RPmax. Once the restoration path is found, the link weight on the directed graph is set to the sum of the extra restoration capacity along the restoration path in the optical network. 7
11
6
10 9
5
number of hops
number of hops
3. Performance Evaluation
4 3
8 7
DSS
6
2
DSS
5
SSA
1
SSA
4
SDP
SDP
3
0 250
500
750
1000
1250
1500
n um ber of dem ands
Figure 2: Service path segment lengths
1750
2000
2 250
500
750 1000 1250 1500 1750 2000 number of demands
Figure 3: Restoration path segment length
To investigate the performance of our dynamic segment selection algorithm, we compare the service segment lengths, segment restoration path lengths, and bandwidth overbuilds with two other algorithms: shortest disjoint path restoration (SDP) and static segment restoration (SSA). The SDP uses a single, end-to-end failure disjoint shortest
path between each connection’s source and destination, while the SSA splits the service path into segments of fixed length SPmax and computes the restoration path for each segment using the greedy algorithm defined in [2]. We used the 78-node, 128-link network used in [2] as input to our simulation study. This network is representative of a typical intercity backbone network. The demands are randomly generated from an intercity demand forecast matrix using the technique described in [2]. Each demand is assumed to be of unit bandwidth. Connections arrived one at a time, with service paths, segments and restoration paths calculated upon connection request. Service paths were established here along the shortest path between source and destination. When calculating the segments and restoration paths, we set RPmax=15 and SPmax=4. We calculated the average service path segment and restoration path length as well as the maximum restoration path length. The results are presented in Figures 2, 3, and 4 respectively. Each data point is the average over 100 random runs. To calculate the restoration path for each segment, we started with =0, and increased in steps of 0.1 until we found a restoration path with length no more than RPmax, as described in section 2. If >0.5, we declared that no restoration path could be found. However, in our experiment, we were always able to find a restoration path after = 0.5. 33
0.9
29
0.85 bandwidth overbuild
number of hops
25 21
0.8
DSS SSA
0.75
17 13
DSS SSA
9
SDP
0.7
0.65
SDP
0.6
5
250
500
750
1000
1250
1500
1750
2000
number of demands
Figure 4: Maximum restoration path lengths
250
500
750 1000 1250 1500 1750 2000 number of demands
Figure 5: Restoration overbuild
Figure 2 shows that the average service path segment length with SDP is about twice that of DSS and SSA – this is because there is only a single segment per connection with SDP. Figures 2 and 3 show that although the average restoration path length for DSS is marginally higher than for SDP, our algorithm significantly reduces the maximum restoration path length (bounding it by 15 hops), and presumably the corresponding restoration time. In contrast, SSA increases both the average and the worst-case restoration path length compared with both SDP and DSS. This is because the restoration path calculation attempts to minimize the bandwidth overbuild only, thus often selecting longer paths than the simple shortest path. Figure 5 illustrates the bandwidth overbuild for the three algorithms. Our DSS approach outperforms the other algorithms, reducing the restoration overbuild by 20% compared with the SDP algorithm. These results demonstrate that our algorithm reduces overbuild while significantly improving the worst-case restoration path length. Although the algorithm’s computational complexity appears large, the search space is only along the service path, which is typically a relatively small number of nodes. Experience in our 78-node experiment demonstrated that the computation time is easily acceptable for real-time calculation. 6. Conclusion In this paper, we propose the Dynamic Segment Selection (DSS) heuristic that selects the segments and corresponding restoration paths in a bid to minimize bandwidth overbuild subject to maximum restoration and service path length constraints. In the backbone network studied, the heuristic reduces the maximum restoration path length by 50% compared with the static segment algorithm, and by 20% compared with the shortest path algorithm. In addition, our DSS heuristic reduces the restoration overbuild by 20% compared with the shortest path algorithm and also outperforms the static segment algorithm. 6. Reference
[1] R. Doverspike, et al., “Fast restoration in a mesh network of optical cross-connects,” OFC 1999. [2] G. Li et al., “Efficient restoration path selection for restorable optical networks,” Infocom 2001. [3] C. Qiao et al, , “New models for efficient shared-path protection”, OFC 2002. [4] H. Zang et al., “Sub-path protection for scalability and fast recovery in WDM mesh networks,” OFC 2002
