Abstract:
The invention is related to a method for resilient multi-path connections between edge devices of a communication network. First are determined connection-specific traffic distribution functions for the multi-paths depending on a plausible failure pattern of active and inactive paths of the multi-path of this connection. Further is selected the traffic distribution function for a multi-path depending on the current failure pattern of active an inactive paths of the multi-path of this connection and is distributed the traffic of the connection onto the path of the corresponding multi-path pursuant to the selected traffic distribution function. An essential advantage of the invention is a significant decrease of network capacity for resilient multi-path connections. Another advantage of the invention is the short reaction time in case of an outage of one or more paths of the multi-path connections.

Description:
CROSS REFERENCE TO RELATED APPLICATIONS 
       [0001]    This application is a continuation of U.S. patent application Ser. No. 10/570,650, filed Dec. 21, 2006, which is the U.S. National Stage of International Application No. PCT/EP2004/052034, filed Sep. 3, 2004 and claims the benefit thereof The International Patent Application claims the benefit of European Patent Application No. 03020840.9, filed Sep. 13, 2003 and European Patent Application No. 03014809.2, filed Sep. 3, 2003. All of the applications are incorporated by reference herein in their entirety. 
     
    
     FIELD OF THE INVENTION 
       [0002]    The inventive method is related to multi-path connections between edge devices in a communication network. The method is preferred provided for MPLS (Multi-Protocol Label Switching) communication networks. 
       BACKGROUND OF THE INVENTION 
       [0003]    Carrier grade networks are expected to provided a high degree of availability although of in the networks elements can fail. This challenge arises, e.g., for virtual private networks or in the terrestrial radio access network of the universal mobile telecommunication system (UMTS). In contrast Internet Protocol (IP) technology enables a global interconnection of computer controlled devices, e.g., hosts, servers and terminals, on a unreliable best effort basis. 
         [0004]    In time division networks, e.g., telephone networks, the reliability is ensured by hardware redundancy of the different network elements. Packet-oriented networks, e.g., the IP network, are protected against link failure by backup links or by ring shaped networks on the physical layer, e.g., SDH rings. However, these methods require a backup capacity which comprises at least the capacity of the failed network elements. 
         [0005]    In packed-switched networks, a high degree of reliability can be achieved by traffic deviation over alternative paths in case of local outages. The backup capacity may be shared among different traffic aggregates in different failure scenarios. Therefore, the required backup capacity can be reduced without compromising the failure resilience of the network. 
         [0006]    For the routing of the packets in packet switched networks there are two different routing methods. The routes in a destination address based routing used in the internet protocol (IP) are usually set up by the routing protocol like the open shortest path first protocol and the destination address transmitted in protocol header. Load balancing over multiple paths is possible if several routes to the same destination reveal the same costs. The traffic in connection-oriented routing used in MPLS networks is forwarded along virtual connections whereby each virtual connection is assigned a label. The virtual connections including the label are established or set up before the forwarding of the packets and the routes can be chosen arbitrarily, e.g. using an explicit route object in MPLS. 
         [0007]    In packet-switched networks like IP and MPLS networks, traffic is deviated over alternative paths in case of a local outage. There are basically two options for resilient mechanisms. 
         [0008]    With local path restoration in case of MPLS networks or with local rerouting in case of IP technology, a deviation path or route is only activated if a failure of the local network element is indicated. I.e., in IP networks a link failure is detected and indicated by missing hello messages of the open shortest path first protocol (OSPF). Backup capacity can be shared because no resources are bound to any aggregate before the failure is indicated. However, the reaction time of restoration mechanism especially for networks with high transmission rates is to long. 
         [0009]    To avoid long reaction time with path protection, the primary path failure is anticipated, i.e., a back up path is set up before a failure is indicated, whereby the traffic is transmitted simultaneously over the primary and the backup path. In this case a backup capacity sharing is not possible. 
         [0010]    A new approach for routing in packet-switched networks is multi-path routing. In the source network element, the traffic is distributed over the several paths wherein the paths are established connection-oriented. The distributed traffic is transmitted parallel over the paths and reassembled at the destination network element. If an outage of one or more network elements is indicated, i.e., if an inactive condition of the local network elements is indicated, the traffic is deflected to the remaining active paths. 
       SUMMARY OF THE INVENTION 
       [0011]    In the discussed networks, the backup capacity for resilience is not used effectively. Therefore, it is an object of the invention to amend the effectiveness of the resources in the well-known resilient networks especially in connection-oriented networks wherein the resilience of the networks should be maintained. 
         [0012]    According to the invention, a novel method for multi-path connections is provided for resilience of paths in communication networks. The method includes a calculation of connection-specific distribution functions for the multi-paths depending on path failure patterns of active an inactive paths of the multi-path of a specific connection. Furthermore, the selecting of the traffic distribution function is provided depending on the current path failure pattern and the distribution of the traffic pursuant to the selected traffic distribution function. An essential advantage of the invention is a significant decrease of network capacity for resilient multi-path connections. Another advantage of the invention is the short reaction time in case of an outage of one or more path of the multi-path connections. 
         [0013]    Preferable, the calculation of the connection-specific distribution functions for the multi-paths further depends on the topology of the communication network, the routes of the paths of the multi-path through the communication network, and both the expected traffic between the edge devices and the available link capacities. Additional, parameters may be used for this calculation to take constraints for different technologies, networks, or characteristics of determined routes into account. 
         [0014]    Pursuant further aspects of the invention, the paths of the multi-paths are logically or physically or link or node disjointed. Of particular importance are physically disjointed paths in multi-path connections because in case of a local outage of network elements the number of affected path is minimized. However, the computation of physically disjoint paths in multi-path connections depends on the topology of the network and can not always be achieved. Therefore, not all the paths of a mulit-paths may be disjoint. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0015]    The sole FIGURE shows a Multi-Protocol Label Switching communication network connection with edge devices. 
       
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
       [0016]    The inventive method is related to multi-path connections between edge devices in a communication network. The method is preferred provided for MPLS (Multi-Protocol Label Switching) communication networks. 
         [0017]    MPLS equipped with edge routers ER—see FIGURE. The edge routers ER are respectively connected to terminals T. In FIGURE, between two edge routers ER a multi-path connection mc which consists of three paths p 1  . . . p 3  is exemplarily depicted. A path p is formed by a sequence of transit routers TR and links L. These paths or routes are determined in assistance of well-known routing algorithms, for instance the Dijkstra algorithm. For the computation of the paths, advantageous restrictions should be considered, for example the paths of the multi-path connection should be physically disjoint. The first and second path p 1 , p 2  is composed of two transit routers TR and three links L. The third path p 3  comprises one transit router TR and two links L, wherein the first and second path p 1 , p 2  are partially physically disjoint. The first and second path p 1 , p 2  are respectively completely physically disjointed from the third path p 3 . 
         [0018]    For this embodiment is assumed that multi-path connections mc are established between the depicted edge routers ER are established multi-path connections with a different number of paths p. The number of paths and the sequence of transit router TR and links L depend on the topology of the MPLS network and the expected traffic transmitted over the paths p of the network. According to the invention a calculation of connection-specific distribution functions for the multi-paths depending on path failure pattern of this multi-path connection mc is provided. 
         [0019]    In the following, the computation of the traffic distribution function is described: 
         [0020]    Basic Notation: 
         [0021]    Let X be a set of elements, then X n  is the set of all n-dimensional vectors and X n×m  the set of all n×m-matrices with components taken from X. Vector x∈ X n  and matrices X∈ X n×m  are written bold and their components are written as 
         [0000]    
       
         
           
             x 
             = 
             
               ( 
               
                 
                   x 
                   0 
                 
                 
                   x 
                   
                     n 
                     - 
                     1 
                   
                 
               
               ) 
             
           
         
       
     
       and X 
       [0022]    
       
         
           
             
               ( 
               
                 
                   
                     x 
                     
                       0 
                       , 
                       0 
                     
                   
                    
                   
                       
                   
                    
                   … 
                    
                   
                       
                   
                    
                   
                     x 
                     
                       0 
                       , 
                       
                         m 
                         - 
                         1 
                       
                     
                   
                 
                 
                   
                     x 
                     
                       n 
                       - 
                       1 
                     
                   
                    
                   
                       
                   
                    
                   … 
                    
                   
                       
                   
                    
                   
                     x 
                     
                       
                         n 
                         - 
                         1 
                       
                       , 
                       
                         m 
                         - 
                         1 
                       
                     
                   
                 
               
               ) 
             
             . 
           
         
       
     
         [0000]    The scalar multiplication c·v and the transpose operator τ are defined a usual. The scalar product o two n-dimensional vectors u and v is written with the help of matrix multiplication 
         [0000]    
       
         
           
             
               
                 u 
                 ⊤ 
               
                
               v 
             
             = 
             
               
                 ∑ 
                 
                   i 
                   = 
                   1 
                 
                 n 
               
                
               
                 
                   u 
                   i 
                 
                  
                 
                   
                     v 
                     i 
                   
                   . 
                 
               
             
           
         
       
     
         [0000]    Binary operators o∈ {*,−,·} are applied componentwise. i.e. u o v=(u 0  o v 0 , . . . , u n-1  o v ne1 )τ. The same holds for relational operators o∈ {&lt;,≦,=,≧,&gt;}, i.e. u o v equals ∀=≦,i&lt;n:u i  o v i . For reasons of simplicity, we define special vectors 0=(0, . . . , 0)τ and 1=(1, . . . , 1)τ with context-specific dimensions. 
         [0023]    Links and Nodes: 
         [0024]    The Network N=(V,E) consists of n=|V| nodes and m=|E| unidirectional links that are represented a unit vectors v i ∈ {0,1} and e i ∈ {0,1} m , i.e. 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       ( 
                       
                         v 
                         i 
                       
                       ) 
                     
                     j 
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               
                                 0 
                               
                               
                                 
                                   i 
                                   ≠ 
                                   j 
                                 
                               
                             
                             
                               
                                 1 
                               
                               
                                 
                                   i 
                                   = 
                                   j 
                                 
                               
                             
                           
                            
                           
                             
 
                           
                            
                           for 
                            
                           
                               
                           
                            
                           0 
                         
                         ≤ 
                         i 
                       
                       , 
                       
                         j 
                         &lt; 
                         
                           n 
                            
                           
                               
                           
                            
                           and 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   1.1 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       ( 
                       
                         e 
                         i 
                       
                       ) 
                     
                     j 
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               
                                 0 
                               
                               
                                 
                                   i 
                                   ≠ 
                                   j 
                                 
                               
                             
                             
                               
                                 1 
                               
                               
                                 
                                   i 
                                   = 
                                   j 
                                 
                               
                             
                           
                            
                           
                             
 
                           
                            
                           for 
                            
                           
                               
                           
                            
                           0 
                         
                         ≤ 
                         i 
                       
                       , 
                       
                         j 
                         &lt; 
                         n 
                       
                     
                   
                 
               
               
                 
                   ( 
                   1.2 
                   ) 
                 
               
             
           
         
       
     
         [0025]    The links are directed and the operators α(e i ) and ω(e i ) yield the sending and the receiving router of a link. The outgoing and incoming incidence matrices A α  and A ω  describe the network connectivity, i.e. 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       ( 
                       
                         a 
                         α 
                       
                       ) 
                     
                     ij 
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             0 
                           
                           
                             
                               
                                 α 
                                  
                                 
                                   ( 
                                   
                                     e 
                                     j 
                                   
                                   ) 
                                 
                               
                               ≠ 
                               
                                 v 
                                 i 
                               
                             
                           
                         
                         
                           
                             1 
                           
                           
                             
                               
                                 α 
                                  
                                 
                                   ( 
                                   
                                     e 
                                     j 
                                   
                                   ) 
                                 
                               
                               ≠ 
                               
                                 v 
                                 i 
                               
                             
                           
                         
                       
                        
                       
                           
                       
                        
                       and 
                     
                   
                 
               
               
                 
                   ( 
                   1.3 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       ( 
                       
                         a 
                         ω 
                       
                       ) 
                     
                     ij 
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               
                                 0 
                               
                               
                                 
                                   
                                     ω 
                                      
                                     
                                       ( 
                                       
                                         e 
                                         j 
                                       
                                       ) 
                                     
                                   
                                   ≠ 
                                   
                                     v 
                                     i 
                                   
                                 
                               
                             
                             
                               
                                 1 
                               
                               
                                 
                                   
                                     ω 
                                      
                                     
                                       ( 
                                       
                                         e 
                                         j 
                                       
                                       ) 
                                     
                                   
                                   ≠ 
                                   
                                     v 
                                     i 
                                   
                                 
                               
                             
                           
                            
                           
                               
                           
                            
                           for 
                            
                           
                               
                           
                            
                           0 
                         
                         ≤ 
                         i 
                       
                       , 
                       
                         j 
                         &lt; 
                         
                           n 
                           . 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   1.4 
                   ) 
                 
               
             
           
         
       
     
         [0026]    The indicence matrix A∈−1,{0,1} n×m  id defined as A=A ω −A α . The j-th column of A indicates the source and target of link e j . The vector Ae j  yields a node vector. It has a −1 in the i-th row if the source node of e j  is v i , it has a 1 in the i-th row if the target node of e j  is v i , and there are zeros in all other positions. The j-th row of A indicates the outgoing and incoming links of node v j . The link vector v j τA has a −1 for all outgoing links, a 1 for all incoming link, and zeros in all other positions. Loops cannot be expressed by this formation. 
         [0027]    Traffic, Matrix, Paths, and Flows: 
         [0028]    The Matrix: The aggregate of all flows from an ingress router v i  to an egress router v j  is denoted by the edge to edge aggregate g vi,vj . All edge to edge aggregates compose the set g∈ G is given by c(g) and corresponds to an entry on the traffic matrix. 
         [0029]    Path: A path p g  of an an aggregate g∈ G between distinct nodes v α  and v ω  is a set of contiguous links presented by a link vector p g ∈ {0,1} m . This corresponds to a single path However, we usually apply the concept of multi-path p g ∈ {0,1} m , which is more general since the traffic may be split into several partial paths carrying a real fraction of traffic. A path follows conservation rules, i.e., the amount of incoming traffic equals the amount of outgoing traffic in a node which is expressed by 
         [0000]        Ap   g =( v   ω   −v   α ).   (1.5) 
         [0030]    While cycles containing only inner nodes can be easily removed, cycles containing the start and the end node of a path are more problematic. Therefore, it is formulated a condition preventing this case. The expression v α τA ω  and v ω τA α  yield the incoming edges of start node v α  and all outgoing edges of the end node v ω  of a path p g . Hence, cycles containing the start or end node can be prevented if the following equations hold: 
         [0000]      ( v   α   τA   ω ) p   g =0 and ( v   ω   τA   α ) p   g =0.   (1.6) 
         [0031]    Flows: The mere path of an aggregate g∈ G is p g . We get the corresponding flow by a scalar multiplication c(g)·p g  to take the rate of aggregate into account. 
         [0032]    Protected scenarios: A protected failure scenario is given by a vector of failed nodes s v  ∈ {0,1} n  and a vector failed links s ε ∈ {0,1} m . The set S contains all protected outage scenarios including s=0, i.e. the no failure case. 
         [0033]    Traffic reduction: During normal operation without any failure, all aggregates g∈ G are inactive. If routers fail, some may disappear. There are to consider several options. 
         [0034]    No Traffic Reduction: It is assumed that failed routers lose only their transport capability for transit flows but still able to generate traffic. Therefore G s =G. 
         [0035]    Source Traffic Reduction: An aggregate flow is removed from the traffic matrix if the source node v i  of aggregate g vi,vj  fails. If a failed node is the destination of a flow, “server push” traffic may still be transported through the network, hence 
         [0000]        G   s   =G\{g   vi,vj   :v   i   τs   v =1,1≦ j≦n,i≠j}.    (1.7) 
         [0036]    Full traffic reduction: In contrast to above it is assumed that the traffic with a failed destination is stalled. An aggregate flow is removed from the traffic matrix if a node fails which either the source or the destination of a flow, hence 
         [0000]    
       
         
           
             
               
                 
                   
                     G 
                     s 
                   
                   = 
                   
                     
                       G 
                        
                       \ 
                        
                       
                         { 
                         
                           
                             
                               
                                 
                                   
                                     
                                       g 
                                       
                                         vi 
                                         , 
                                         vj 
                                       
                                     
                                      
                                     
                                       : 
                                     
                                      
                                     
                                         
                                     
                                      
                                     
                                       v 
                                       i 
                                       ⊤ 
                                     
                                      
                                     
                                       s 
                                       v 
                                     
                                   
                                   = 
                                   1 
                                 
                                 , 
                               
                             
                           
                           
                             
                               
                                 
                                   1 
                                   ≤ 
                                   j 
                                   ≤ 
                                   n 
                                 
                                 , 
                                 
                                   i 
                                   ≠ 
                                   j 
                                 
                               
                             
                           
                         
                         } 
                       
                     
                     ⋃ 
                   
                 
               
               
                 
                   ( 
                   1.8 
                   ) 
                 
               
             
             
               
                 
                   
                       
                   
                    
                   
                     { 
                     
                       
                         
                           
                             
                               
                                 
                                   g 
                                   
                                     vi 
                                     , 
                                     vj 
                                   
                                 
                                  
                                 
                                   : 
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   v 
                                   j 
                                   ⊤ 
                                 
                                  
                                 
                                   s 
                                   v 
                                 
                               
                               = 
                               1 
                             
                             , 
                           
                         
                       
                       
                         
                           
                             
                               1 
                               ≤ 
                               j 
                               ≤ 
                               n 
                             
                             , 
                             
                               i 
                               ≠ 
                               j 
                             
                           
                         
                       
                     
                     } 
                   
                 
               
               
                 
                   ( 
                   1.9 
                   ) 
                 
               
             
           
         
       
     
         [0037]    Failure indication function: The failure indication function Φ(p,s) indicates whether a path p is affected by a failure scenario s. Path p is affected by a link failure scenario s ε  if s ε τ&gt;0. To formulate this analogously for node failures it is defined traces. The α-trace is tr α (p g )=A α p g  and the ω-trace is tr ω (p g )=A ω p g , respectively. It is obtained the interior trace ti by executing the corresponding end or start node of the α- or ω-trace, respectively, i.e. ti(p g )=A α  p g −v α= A ω  p g −v ω . Path p is affected by a node failure scenario s v  if s v τti(p)&gt;0. Finally, the failure indication function is 
         [0000]    
       
         
           
             
               
                 
                   
                     Φ 
                      
                     
                       ( 
                       
                         p 
                         , 
                         s 
                       
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           1 
                         
                         
                           
                             
                               
                                 
                                   s 
                                   ɛ 
                                   ⊤ 
                                 
                                  
                                 p 
                               
                               + 
                               
                                 
                                   s 
                                   v 
                                   ⊤ 
                                 
                                  
                                 
                                   ti 
                                    
                                   
                                     ( 
                                     p 
                                     ) 
                                   
                                 
                               
                             
                             &gt; 
                             0 
                           
                         
                       
                       
                         
                           0 
                         
                         
                           
                             otherwise 
                             . 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   1.10 
                   ) 
                 
               
             
           
         
       
     
         [0038]    Protection alternatives: A path restoration scheme introduces a backup path q g  which is activated if the primary path fails. This backup path protects against link and/or node failure of each primary path p g  depending on the required type of resilience. A backup path is link protected if 
         [0000]      q g τp g =0   (1.11) 
         [0000]    and is both link and node protectiong if the following holds 
         [0000]        ti ( q   g )τ ti ( p   g )=0.   (1.12) 
         [0039]    Objective function and capacity constrains: It is described the capacity of all links by a vector of edges b∈ (R 0   + ) m . The overall capacity in the network is the objective function that is to be minimized. It can be computed by 
         [0000]      wτb→min   (1.13) 
         [0000]    where w ∈ (R 0   + ) m  is a vector of weights, that is normally set to w=1. If the connectivity is maintained by backup path in case of failure scenario s∈ S, the following bandwidth constrains guarantee that enough capacity is available to carry the traffic generated by the aggregate g∈ G. 
         [0040]    Bandwidth reuse: In pure packet-switched networks, resources are not physically dedicated to any flow. If traffic is rerouted due to an outage, the resources can be automatically reuse for transporting other traffic. Under this assumption, the capacity constraints are 
         [0000]    
       
         
           
             
               
                 
                   
                     ∀ 
                     s 
                   
                    
                   
                     ∈ 
                     
                       
                         S 
                          
                         
                           : 
                         
                          
                         
                             
                         
                          
                         
                           
                             ∑ 
                             
                               g 
                               ∈ 
                               Gs 
                             
                           
                            
                           
                             
                               c 
                                
                               
                                 ( 
                                 g 
                                 ) 
                               
                             
                             · 
                             
                               ( 
                               
                                 
                                   
                                     ( 
                                     
                                       1 
                                       - 
                                       
                                         Φ 
                                          
                                         
                                           ( 
                                           
                                             
                                               p 
                                               g 
                                             
                                             , 
                                             s 
                                           
                                           ) 
                                         
                                       
                                     
                                     ) 
                                   
                                   · 
                                   
                                     p 
                                     g 
                                   
                                 
                                 + 
                                 
                                   
                                     Φ 
                                      
                                     
                                       ( 
                                       
                                         
                                           p 
                                           g 
                                         
                                         , 
                                         s 
                                       
                                       ) 
                                     
                                   
                                   · 
                                   
                                     q 
                                     g 
                                   
                                 
                               
                               ) 
                             
                           
                         
                       
                       ≤ 
                       b 
                     
                   
                 
               
               
                 
                   ( 
                   1.14 
                   ) 
                 
               
             
           
         
       
     
         [0041]    No bandwidth reuse: In optical networks, physical resources like fibers, wavelengths, or time slots are bound to connections. If a network element fails, there might not be enough time to free the resources of a redirected connection. This is respected by the following capacity constraints: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         ∀ 
                         s 
                       
                        
                       
                         ∈ 
                         
                           
                             S 
                              
                             
                               : 
                             
                              
                             
                                 
                             
                              
                             
                               
                                 ∑ 
                                 
                                   g 
                                   ∈ 
                                   Gs 
                                 
                               
                                
                               
                                 
                                   c 
                                    
                                   
                                     ( 
                                     g 
                                     ) 
                                   
                                 
                                 · 
                                 
                                   p 
                                   g 
                                 
                               
                             
                           
                           + 
                           
                             
                               ∑ 
                               
                                 g 
                                 ∈ 
                                 Gs 
                               
                             
                              
                             
                               
                                 c 
                                  
                                 
                                   ( 
                                   g 
                                   ) 
                                 
                               
                               · 
                               
                                 Φ 
                                  
                                 
                                   ( 
                                   
                                     
                                       p 
                                       g 
                                     
                                     , 
                                     s 
                                   
                                   ) 
                                 
                               
                               · 
                               
                                 q 
                                 g 
                               
                             
                           
                         
                       
                     
                     ) 
                   
                   ≤ 
                   
                     b 
                     . 
                   
                 
               
               
                 
                   ( 
                   1.15 
                   ) 
                 
               
             
           
         
       
     
         [0042]    Optimal solution summary: The free variables to be set by the optimization are 
         [0000]        b ∈( R   0   + ) m  and ∀  s∈ G:p   g   q   g ∈[0,1] m .   (1.16) 
         [0043]    Both the primary path p g  and the backup path q g  conform to the conversation rule equation (1.5) and exclude start and end nodes explicity from cycles by equation (1.6). The protection of path p g  is achieved if the backup path q g  respect either equation (1.11) or (1.12) for link protection or for link and node protection, respectively. The capacity constraints have to met either with or without bandwidth reuse ((equation (1.14) and (1.1)). The objective function in equation (1.13) is to be minimized while all these constraints are taken into account. 
         [0044]    Unfortunately, the path protection constraints (equation (1.11)) and the equation (1.12) are quadratic with respect to the free variables. Therefore, this description can not be solved by LP (linear program) solvers. In addition, the failure indication function Φ(p,s) cannot be transformed into a linear mapping. Thus, there is no efficient algorithm to compute the desired structures p g  and q g . If the complexity of the primary and the backup multi-paths is restricted, e.g. to single-paths, the computation becomes more difficult due to a required integer solution for p g  and q g . The modelling of disjoint multi-paths solutions is even more difficult. Therefore heuristics are used. 
         [0045]    Heuristic for path calculation: 
         [0046]    Due to the computational problems and due the difficulty of controlling the structure of multi-paths first should be calculated a suitable path layout and then should be derivate a suitable traffic distribution function. Then is calculated a link and a node disjoint multi-path structure by using an algorithm to compute the k disjoint shortest paths (kDSP). Another heuristic tries to place a primary path in preferred way for PP methods. If a primary path is given, the kDSP algorithm may be used for the computation of a link and a node disjoint multi-path for backup purposes. Another option is the computation of an optimal path layout together with traffic distribution function. This method yields a general multi-path and is, therefore, not suitable in practice. 
         [0047]    The k disjoint shortest path algorithm: 
         [0048]    Both PP method and the inventive approach require disjoint multi-paths for their path layout. A very simple solution to get disjoint paths is taking the shortest p which can be found by Dijkstra&#39;s algorithm, removing its interior node te(p) and links tr(p) from the network running Dijkstra&#39;s algorithm again. However, this procedure does not always find k disjoint paths in the network although the might be topology feasible. In contrast to online solutions, the k disjoint shortest path (kDSP) offline algorithm finds always up to k disjoint shortest path in the network if they exist. These paths may be taken as the equal paths of an safe protecting mult-path. If they are taken for layout of path protection mechanism, the shortest one of them should become the primary path and the other paths constitute the muliti-path for backup purposes. 
         [0049]    Primary path computation: minimum traffic routing: 
         [0050]    With path protection the primary path plays a distinguished role. If a network element carries a large amount of traffic and fails, this traffic has to be redistributed and requires a lot of backup capacity near the outage location. Therefore, a path layout is constructed that entails a minimum traffic load on each network element. 
         [0051]    Minimum traffic constraints: 
         [0052]    The overall traffic on all links is giver by the auxiliary vector a E  ∈ (R 0   + ) m  and the overall traffic on all links is given by the auxiliary vector a V  ∈ (R 0   + ) n , respecitively 
         [0000]    
       
         
           
             
               
                 
                   
                     a 
                     E 
                   
                   = 
                   
                     
                       
                         ∑ 
                         
                           g 
                           ∈ 
                           G 
                         
                       
                        
                       
                         
                           
                             f 
                              
                             
                               ( 
                               g 
                               ) 
                             
                           
                           · 
                           
                             p 
                             g 
                           
                         
                          
                         
                             
                         
                          
                         and 
                          
                         
                             
                         
                          
                         
                           a 
                           v 
                         
                       
                     
                     = 
                     
                       
                         ∑ 
                         
                           g 
                           ∈ 
                           G 
                         
                       
                        
                       
                         
                           f 
                            
                           
                             ( 
                             g 
                             ) 
                           
                         
                         · 
                         
                           ti 
                            
                           
                             ( 
                             
                               p 
                               g 
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   1.17 
                   ) 
                 
               
             
             
               
                 
                   
                     a 
                     E 
                   
                   = 
                   
                     ≤ 
                     
                       
                         
                           a 
                           max 
                           E 
                         
                         · 
                         1 
                       
                        
                       
                           
                       
                        
                       and 
                        
                       
                           
                       
                        
                       
                         a 
                         v 
                       
                     
                     ≤ 
                     
                       
                         a 
                         max 
                         v 
                       
                       · 
                       1 
                     
                   
                 
               
               
                 
                   ( 
                   1.18 
                   ) 
                 
               
             
           
         
       
     
         [0053]    The value f(g) may set to 1 of only the number of aggregates is to be minimized or it may be set to c(g) if their rate should be taken into account. In the embodiment is used f(g)=c(g). 
         [0054]    Objective Function: 
         [0055]    Both the maximum traffic per network element and the overall capacity (1τa E  or 1τ a V ) should be minimized but they represent potentially conflict goals. To avoid very long path, the objective function takes also the overall required capacity 1τa Y  into account: 
         [0000]        M   x ·≦α max   X +1 τa   Y →min.   (1.19) 
         [0056]    The constants M X ,M V ∈R 0   +  control the tradeoff between the conflicting goals. A small M X  favours little overall capacity while a large M X  favours little maximum traffic per network element. In the embodiment X=V and Y=V. 
         [0057]    Path constraints: 
         [0058]    Like above, the flow conservation rule (equation (1.5)) and the exclusion of start and end nodes from cycles (equation(1.6)) have to be respected. For a single-path solution p g ∈ {0,1} m  is required. This, however, leads to a mixed trigger LP that takes a long computation time. 
         [0059]    Therefore, p g ∈ {0,1} m  is used to get a non-integer LP. To obtain a desired single-path as primary path, the general multi-path is decomposed into single-paths and traffic distribution function. For the example is taken the single-path of the calculated multi-path structure with the largest traffic distribution function. Note that this decomposition is not unique and various results can be obtained depending on the implementation. This is very similar to the computation of a singe-shortest path. 
         [0060]    Backup path computation with kDSP: 
         [0061]    A set of disjoint single-path is required to build a backup path for a given primary path p g . They can be obtained using kDSP algorithm. For that objective, first the links tr (p g ) contained in the primary path from the network. If the backup path should be both link and node disjoint with the primary path, the interior node ti(p g ) are removed. Then the kDSP algorithm is running on the remaining network and the results provide the resulting structure of the backup path. If the primary path has not been found by the kDSP algorithm, a link and node disjoint backup path cannot always found although two disjoint paths may exist in the network. 
         [0062]    Computation of an optimum backup path: 
         [0063]    If a primary path is given, the optimum backup path together with the corresponding traffic distribution function can be obtained by a slight modification of the LP formulation. As p g  already fixed, it is removed from the set of free variables. Then, the quadratic conditions in term of free variables in equation (1.11) and (1.12) disappear. In addition, the failure indication function Φ(p,s) is independent of any free variables. Therefore, this modification yields an LP formulation which can be solved efficiently. The so obtained backup path structure may have circles that do not increase the required capacity. When this path layout is configured in real time system, these circles must be removed. The corresponding elementary graph-theoretical operations are omitted, which are simple because the source and destination nodes are prevented to be part of a circle (equation (1.6)). However, the structure of the resulting backup path is potentially still very complex since the partial edge to edge paths are not necessarily disjoint and, therefore, this method is rather intended for comparison purposes and not in practice. 
         [0064]    For the computation of disjoint multi-paths the kDSP algorithm is used which is simple and efficient to compute. However, it does not take general into account which is a different and a hard problem. Basically, the kDSP heuristic can be substituted by any other routing scheme yielding disjoint multi-path. 
         [0065]    Computation of the traffic distribution function: 
         [0066]    If the path layout for a safe protection multi-path or a path protection mechanism is given, a suitable traffic distribution function is required. First are presented some basics for failure-dependent traffic distribution and then are derived three different traffic distribution mechanism for safe protection multi-path. Finally, an adaptation to path protection is presented. 
         [0067]    Basics for failure-dependent traffic distribution: 
         [0068]    A self protecting multi-path consists kg link an (not necessarily) node disjoint paths (expect for source and destination) p g   i  for 0≦i&lt;k g  that be found, e.g. by a kDSP solution. It is represented by a vector of single path Pg=(p g   0 , . . . , p g   kg-1 )τ. These paths are equal in the sense that they all may be active without any network failure. 
         [0069]    Path failure pattern f g (s): 
         [0070]    The path failure pattern is defined fg(s)∈ {0,1} kg  that indicates the failed partial path of the safe protection multi-path for g depending on the failure scenario s. It is composed 
         [0000]        f   g ( s )=(Φ( p   g   0   ,s ), . . . , Φ( p   g   kg-1   ,s ))τ  (1.20) 
         [0000]    With a path failure pattern f g =0 all paths are working f g =1 connectivity cannot be maintained. The set of all different failures for safe protection multi-path Pg is denoted by Fg={f g (s):s∈ S}. 
         [0071]    Traffic distribution function: 
         [0072]    For all aggregates g∈ G, a traffic distribution function l g (f)∈ (R 0   + ) kg  must be found whose arguments are path failure pattern f∈ Fg, They have to suffice the following restrictions: 
         [0000]      1τ l   g ( f )=1.   (1.21) 
         [0073]    Furthermore, failed paths must not be used, i.e. 
         [0000]        fτl   g ( f )=0.   (1.22) 
         [0074]    Finally, the vector indicating the transported traffic aggregate g over all links is calculated by P g τl g (f)·c(g). 
         [0075]    Equal traffic distribution: 
         [0076]    The traffic may be distributed equally over all working paths, i.e. 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       I 
                       g 
                     
                      
                     
                       ( 
                       f 
                       ) 
                     
                   
                   = 
                   
                     
                       1 
                       
                         1 
                          
                         
                             
                         
                          
                         
                           T 
                            
                           
                             ( 
                             
                               1 
                               - 
                               f 
                             
                             ) 
                           
                         
                       
                     
                     · 
                     
                       ( 
                       
                         1 
                         - 
                         f 
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   1.23 
                   ) 
                 
               
             
           
         
       
     
         [0077]    Reciprocal traffic distribution: 
         [0078]    The traffic distribution factors may be indirectly proportional to the length of the partial path (1τp). They can be computed for all partial paths. 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       ( 
                       
                         lg 
                          
                         
                           ( 
                           f 
                           ) 
                         
                       
                       ) 
                     
                     I 
                   
                   = 
                   
                     
                       
                         
                           
                             1 
                             - 
                             fi 
                           
                           
                             
                               1 
                               ⊤ 
                             
                              
                             
                               
                                 ( 
                                 
                                   P 
                                   g 
                                 
                                 ) 
                               
                               i 
                             
                           
                         
                         
                           
                             ∑ 
                             
                               0 
                               ≤ 
                               j 
                               &lt; 
                               kg 
                             
                           
                            
                           
                             
                               1 
                                
                               
                                   
                               
                               - 
                               fj 
                             
                             
                               1 
                                
                               
                                   
                               
                                
                               
                                 T 
                                  
                                 
                                   ( 
                                   
                                     P 
                                     g 
                                   
                                   ) 
                                 
                               
                                
                               j 
                             
                           
                         
                       
                        
                       
                           
                       
                        
                       for 
                        
                       
                           
                       
                        
                       0 
                     
                     ≤ 
                     i 
                     &lt; 
                     
                       k 
                       g 
                     
                   
                 
               
               
                 
                   ( 
                   1.24 
                   ) 
                 
               
             
           
         
       
     
         [0079]    Optimized traffic distribution: 
         [0080]    Traffic distribution is optimal if the required capacity b to protect all aggregates g∈ G in all protected failure scenarios s∈ S is minimal. The free variables are 
         [0000]      b∈(R 0   + ) m , ∀g∈ G∀f∈ Fg:l g (f)∈ (R 0   + ) kg    (1.25) 
         [0081]    The objective function is given by equation (1.13). The traffic distribution function constraints in equation (1.21) and (1.22) must be respected by all l g (f) and the bandwidth constraints are newly formulated. 
         [0082]    Bandwidth constraints with capacity reuse: 
         [0083]    The capacity must be large enough to accommodate the traffic in all protected failure scenarios s∈ S: 
         [0000]    
       
         
           
             
               
                 
                   
                     ∀ 
                     s 
                   
                    
                   
                     ∈ 
                     
                       
                         S 
                          
                         
                           : 
                         
                          
                         
                             
                         
                          
                         
                           
                             ∑ 
                             
                               g 
                               ∈ 
                               Gs 
                             
                           
                            
                           
                             
                               Pg 
                               ⊤ 
                             
                              
                             
                               
                                 
                                   I 
                                   g 
                                 
                                  
                                 
                                   ( 
                                   
                                     
                                       f 
                                       g 
                                     
                                      
                                     
                                       ( 
                                       s 
                                       ) 
                                     
                                   
                                   ) 
                                 
                               
                               · 
                               
                                 c 
                                  
                                 
                                   ( 
                                   g 
                                   ) 
                                 
                               
                             
                           
                         
                       
                       ≤ 
                       
                         b 
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   1.26 
                   ) 
                 
               
             
           
         
       
     
         [0084]    Bandwidth constraints without capacity reuse: 
         [0085]    Releasing capacity unnecessarily leads to waste of bandwidth if it cannot be reused by other connections. Therefore, traffic distribution factor l g (f) if active paths must only increase in an outage scenario, except for failed paths for which they are zero. This quasi monotonictiy can be expressed by 
         [0000]      ∀ g∈ F   g   :l   g ( f )+ f≧l   g ( f   g (0)),   (1.27) 
         [0086]    are removed due to router failure. Thus, the bandwidth constraints are 
         [0000]    
       
         
           
             
               
                 
                   ∀ 
                   
                     g 
                     ∈ 
                     
                       S 
                        
                       
                         : 
                       
                        
                       
                           
                       
                        
                       
                         
                           
                             ∑ 
                             
                               g 
                               ∈ 
                               
                                 G 
                                 s 
                               
                             
                           
                            
                           
                             
                               
                                 c 
                                  
                                 
                                   ( 
                                   g 
                                   ) 
                                 
                               
                               · 
                               
                                 P 
                                 g 
                                 ⊤ 
                               
                             
                              
                             
                               
                                 I 
                                 g 
                               
                               ( 
                               
                                 
                                   
                                     f 
                                     g 
                                   
                                    
                                   
                                     ( 
                                     s 
                                     ) 
                                   
                                 
                                 + 
                               
                             
                           
                         
                         
                            
                           
                             
                               ( 
                               1 
                               ) 
                             
                              
                             
                                 
                             
                              
                             used 
                              
                             
                                 
                             
                              
                             capacity 
                           
                         
                       
                        
                       
                         
                           
                             ∑ 
                             
                               g 
                               ∈ 
                               
                                 G 
                                 s 
                               
                             
                           
                            
                           
                             
                               c 
                                
                               
                                 ( 
                                 g 
                                 ) 
                               
                             
                             · 
                             
                               
                                 P 
                                 g 
                                 ⊤ 
                               
                               ( 
                               
                                 
                                   
                                     f 
                                     g 
                                   
                                    
                                   
                                     ( 
                                     s 
                                     ) 
                                   
                                 
                                 · 
                                 
                                   
                                     I 
                                     g 
                                   
                                   ( 
                                   
                                     
                                       
                                         f 
                                         g 
                                       
                                        
                                       
                                         ( 
                                         0 
                                         ) 
                                       
                                     
                                     + 
                                   
                                 
                               
                             
                           
                         
                         
                            
                           
                             
                               ( 
                               2 
                               ) 
                             
                              
                             
                                 
                             
                              
                             inactive 
                              
                             
                                 
                             
                              
                             partial 
                              
                             
                                 
                             
                              
                             path 
                           
                         
                       
                        
                       
                         
                           
                             ∑ 
                             
                               g 
                               ∈ 
                               
                                 G 
                                 s 
                               
                             
                           
                            
                           
                             
                               
                                 c 
                                  
                                 
                                   ( 
                                   g 
                                   ) 
                                 
                               
                               · 
                               
                                 P 
                                 g 
                                 ⊤ 
                               
                             
                              
                             
                               
                                 I 
                                 g 
                               
                               ( 
                               
                                 
                                   
                                     f 
                                     g 
                                   
                                    
                                   
                                     ( 
                                     0 
                                     ) 
                                   
                                 
                                 ≤ 
                                 b 
                               
                             
                           
                         
                         
                            
                           
                             
                               ( 
                               3 
                               ) 
                             
                              
                             
                                 
                             
                              
                             removed 
                              
                             
                                 
                             
                              
                             aggregates 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   1.28 
                   ) 
                 
               
             
           
         
       
     
         [0087]    Note that the term f g (s)·l g (f(0) expresses an element-wise multiplication of two vectors. Hence, if bandwidth reuse is possible, equation (1.26) is used as bandwidth constraints, otherwise equations (1.27) and (1.28) must be respected. Neither protection constraints (equations (1.11) and (1.12)) nor path constraints (equation (1.5) and (1.6)) apply since the structure of the path is already fixed. 
         [0088]    Adaptation of path protection: 
         [0089]    The adaptation of the above explained traffic distribution scheme to path protection mechanism is simple. The primary path pg is denotes together with its disjoint backup single-paths as safe protection multi-path P g  with p g =(P g ) 0 . The essential difference between the path protection scheme and the safe protection multi-path is that the path failure pattern f g   PP (s) is described by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       f 
                       g 
                       PP 
                     
                      
                     
                       ( 
                       s 
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             u 
                             0 
                           
                         
                         
                           
                             
                               Φ 
                                
                               
                                 ( 
                                 
                                   
                                     p 
                                     g 
                                   
                                   , 
                                   s 
                                 
                                 ) 
                               
                             
                             = 
                             0 
                           
                         
                       
                       
                         
                           
                             
                               f 
                               g 
                             
                              
                             
                               ( 
                               s 
                               ) 
                             
                           
                         
                         
                           
                             
                               Φ 
                                
                               
                                 ( 
                                 
                                   
                                     p 
                                     g 
                                   
                                   , 
                                   s 
                                 
                                 ) 
                               
                             
                             = 
                             1 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   1.29 
                   ) 
                 
               
             
           
         
       
     
         [0000]    with u 0 =(0,1, . . . , 1)τ. By substituting the path failure pattern in equation (1.20) by (1.29), the traffic distribution optimization can be applied to path protection schemes. 
         [0090]    The approaches above for finding the structure—in our case linear programs—have to be taken also only as a favoured realization. It might be reasonable to use other or additional constraints that reflect additional networking side conditions. If the network becomes large, the solution approach with linear programs can fail due to the computational expenses. Then, faster heuristics (e.g. genetic algorithms or simulated annealing) must be applied to find the layout of the routing structures as well as a suitable load balancing to achieve suboptimal results. 
         [0091]    Apart from that there is a related problem that can be solved by the proposed forwarding paradigms. In the description above we took for the sake of simplicity a network topology, configured the structures, and dimensioned the link sizes of the network such that no quality of service (QoS) degradation is observed if traffic is rerouted in a failure case. The structures—primary path together with backup multi-path or SPM—can also be applied if the network topology is given together with the link capacities. Then, different algorithms approaches have to be taken to configure the forwarding structures and to maximize the amount of traffic that can be transported with resilience guarantees in the network. Above, the traffic amount is given and the required capacity is minimized while here link sizes are fixed and the amount of traffic is maximized. These algorithms and approximative heuristics are necessary to make best use of the network capacity in combination with our forwarding structures.