NOVEL ALGORITHMS FOR IP FAST REROUTE (DRAFT)

21 Introduction**IP** has come a long way to become a cost-eective bearing platform for commercialservices, providing scalable QoS, point-and-click management, secure VPN services,unpaired scalability, etc. The importance of improving **IP** in these ways stems fromthe numerous new applications with special needs for transporting trac types **IP**was never designed for. Nowadays, Internet has to transport a high amount of realtime trac, such as **IP**TV, Vo**IP** or trac of on-line gaming. Although several shortcomingswere vanished, an important piece of the puzzle still lags behind: a native **IP**resilience technique is needed, which is able to provide fast reroute upon failure rises.These days the resilience of **IP** networks lays on some outdated resilience methodslike plain Open Shortest Path First (OSPF) or Intermediate System to IntermediateSystem (IS-IS), width failure recovery time in the order of seconds. In contrast, currentrequirements usually forces operators to apply MultiProtocol Label Switching(MPLS) or other protocols below the **IP** layer in order to keep recovery time under50ms, indispensable to reach ve nines availability. The Internet Engineering TaskForce, therefore, has spearheaded the standardization of a fast, intra-domain, full-**IP**resilience mechanism. This eort gave rise to the **IP** Fast ReRoute (**IP**FRR) framework,which, as of this writing, is on its way to become an Internet RFC [Shand08].**IP**FRR is an eective reformulation of MPLS Fast Reroute on the context of **IP**.As the ones used in MPLS networks, these techniques decrease convergence time byusing Local and Proactive recovery. Here, Local means that only routers neighborthe failed resource change their state and it is not needed to inform other partsof the network for recovery. In this way saving the time of communication is possible.Moreover, Proactive means that routers prepare for the failure long before it occursin reality. Naturally, since preparing for unlimited number of failures in arbitrarynetworks is impossible, these techniques prepare only for single failures, which is definitelythe most common case. Then, while the failure is being handled by an **IP**FRRmethod, the network remains still operable giving the chance of reconguration andpreparing to another fast recovery.One may observe that local rerouting in **IP** networks is not trivial. Since forwardingdecision in **IP** bases exclusively on the destination address of the package, simplyforwarding to a node, which does not know about the change of topology commonlycauses loop. Thus, **IP**FRR algorithms need to mark packages on detour, either implicitlyor explicitly. Implicit marking is realizable by the incoming interfaces; if notonly the destination address but also the incoming interface is taken into considerationduring the forwarding decision, **IP** fast reroute becomes possible [Nel06]. Forexplicit marking, it is usually proposed to reserve some bits [Cicic07], or to create an**IP**-in-**IP** tunnel with a header containing a special destination address [Bry08].Although it is easy to see that the way of marking packets is extremely important

for Local rerouting, current solutions in the literature have focused too exclusivelyon this problem and have settled for some variations of shortest path as Proactivedetour computation. As shell be revealed below, sometimes giving up shortest pathscan carry signicant advantages.2 Research Objectives3 Methodology4 New Results4.1 Handling Multiple Failures with Interface-based **IP** FastReRouteIn this part I deal with the problem of interface-base **IP** fast reroute, techniquesusing interface-based forwarding. In contrast to traditional **IP** forwarding, whichselects the next hop based on the destination address of the packet, interface-basedforwarding takes into consideration both the destination address and the incominginterface. Since forwarding decision in modern routers is made by the linecards ofthe interfaces, it is very easy to realize this type of forwarding; if dierent forwardingtables are downloaded to these linecards, the next hop depends on the incominginterface as well. Using this extra information providing **IP** fast reroute becomespossible without new hardware. The rst interface-based **IP** fast reroute algorithmis the Failure Insensitive Routing (FIR [Nel06]), which can always avoid single linkfailures (if a path between the source and the destination still exists). Although theauthors presented two algorithms, the computed routes are the same, so I refer tothese as FIR in the sequel.THESIS 1: [C2][C3] I have shown that detours computed by FIR are not necessarilyloop-free. I proposed a new loop-free interface-based **IP** fast reroute method in orderto avoid this shortcoming.Forming loops in networks should always be avoided, since they may have devastatingeects. In a loop the number of packets can become very high, in this way theprobability of packet loss is increased as well and even those parts of the network canbecome unavailable, which were not eected by the original failure.The main reason of forming loops stems from the way of selecting default paths.If in the intact network shortest paths are used for default forwarding, it can not beguaranteed that detours are loop-free.THESIS 1.1: There does not exist an interface-based **IP** fast reroute technique that3

4Figure 1: Loop in a network with interface-based fast reroute.guarantees over arbitrary network topology and arbitrary additive edge costs that followingtwo claims both hold true at the same time:• the default path is the shortest one between any two nodes and• detours are always loop-free, even when multiple failures exist.Remark: Since FIR is an interface-based **IP** fast reroute technique, which usesshortest paths as default, it can create loops.The possibility of loops in detours when interface basad **IP** fast reroute is usedstems from the phenomenon of losing the state of packets. Since the failure of forwardinga packet is indicated by only the incoming interface, if a packet on a detourcan get back to a default path, this fact can be forgotten. Thus, when the forwardingof the packet fails again it will be forwarded along a detour, possibly back to thethe original failure. Moreover, if the default paths are the shortest ones between thenodes, leaving the detours can not always be avoided.An example for the previous phenomenon is depicted on Fig. 1. Suppose that nodeS tries to send a packet to node D, each link has uniform cost and the default pathsare the shortest ones. First it forwards the packet to node A along the shortest path.However, the link between node A and node B has failed, so the packet is reroutedback to node S. Thanks to interface-based forwarding the packet reaches node Efollowing the black arrows. Unfortunately, the link between node E and node B hasalso failed. Since node E gets the packet from node F, the packet arrives to node Ealong a shortest path, so node E does not know the other failure; the information wasforgotten when the packet got on a default path at node F. Thus, node E reroutesthe packet back to node F and a loop is formed.Observe that the detours of FIR can contain loops even when only a single nodeis failed (on Fig. 1 when node B fails). The failure of a node is similar to the failure

5Figure 2: Two edge-disjoint directed spanning trees for node D as a destinationof all the links connected to it. In this way, if FIR is used, which can correct only asingle link failure, even the failure of a single node can cause forwarding loops.On the other hand, one may observe that giving up the requirement of shortestpaths, creating a loop-free interface-based fast reroute technique may become feasible.THESIS 1.2: I proposed a new interface-based **IP** fast reroute method, called Loop-Free Failure Insensitive Routing (LFIR), which always avoids loops at the price ofusing non-shortest paths as default paths.It was discussed previously that the main reason of forwarding loops in detourssteams from the possibility of getting back to a default path after a failure. It ispossible to avoid this by nding a routing, where packets once entered detour cannever leave it. Observe that in **IP** networks routing to a given destination is usuallydone along a directed spanning tree. If it was possible to nd a pair of directed edgedisjointspanning trees for any given destination, packets would be able to follow oneof them as default path and the other one as detour.LFIR follows this idea. Since nding two edge-disjont directed spanning treesrooted at any given node of a 2-edge-connected graph is possible, LFIR can alwaysnd distinct default paths and detours in each 2-edge-connected components of thenetwork. In this way, if it is possible LFIR can avoid any single link failure. Moreover,if the forwarding of a packet on detour fails, LFIR drops the packet. Since packetscan only leave detour when they leave a 2-edge-connected component, no loops can beformed. Two directed spanning trees of the former network with node D as destinationare depicted on Fig. 2.THESIS 1.3: By means of extensive simulations on networks with real-world andarticial topologies, I have shown that in the presence of a single node failure andmultiple link failures FIR creates loops, in contrast to LFIR, which guarantees loopfreefailure recovery. Furthermore, the default paths of LFIR were at most 17% longerin average than the shortest ones.

6Figure 3: A pair of node-redundant trees rooted at node D.4.2 Finding Node-Redundant Trees in Linear TimeThis thesis deals with the problem of node-redundant trees (or simply redundant treesin the sequel), a pair of directed spanning trees commonly applied for resilience purposes[Méd99][Méd02][Zha05][Xue02][Cic07]. The rst algorithm with linear complexityfor nding such trees, now widely cited in the literature, was proposed in [Zha05].Denition 4.1. Given an undirected graph G and a root node r, a pair of redundanttrees of graph G rooted at node r is a pair of directed spanning trees of G with edgesdirected towards r. This node is reachable from any other node along both of thetrees, so that the paths in the two trees are node-disjoint.Remark: Obviously, redundant trees can only be found in 2-node-connected graphs,a requirement real networks may not be able to fulll. Lifting this articial assumptionis discussed in the next thesis. In this thesis I always assume that the graph is2-node-connected.Redundant trees can be easily used for resilience. If a single failure shows up, itcan ruin the connectivity towards the root in only one of the trees. Hence, any failurecan be avoided by switching the trac to the tree that remained intact. In the sequeln denotes the number of nodes and e denotes the number of edges of the graph. Apair of redundant trees is depicted on Fig. 3.THESIS 2: [C5][C6][C7] I have found a phenomenon, which makes the algorithm in[Zha05] to fail to nd a correct pair of redundant trees in linear time. I have proposeda centralized algorithm for nding a pair of redundant trees in strictly linear time,which does not suer from this shortcoming. Moreover, I have proposed a distributedalgorithm for nding a pair of redundant trees rooted at each node in linear time.THESIS 2.1: I have found a phenomenon, which makes the algorithm in [Zha05] tofail to give a correct result in linear time. I have shown an example, a graph with aparticular traversal, on which this pathological behavior shows up.

7Figure 4: A graph and a DFS traversal on which no proper address associationexists.Remark: The algorithm in [Zha05] can be modied in order to guarantee correctness,but in this way it necessarily loses linear complexity.The problem of the original solution stems from the fact that this algorithm needsto maintain a partial ordering on the nodes, with insertion and comparison both inO(1) time. Naturally, usual data structures (e.g. arrays, linked lists, binary trees)can not fulll this criteria, but associating platform native numbers to nodes canovercome this problem.Unfortunately, by associating numbers to nodes an address space is created(these are not real addresses, they are only used for comparing), which can run lowwithout proper assignment. Using the graph and the traversal depicted on Fig. 4I have shown that no proper assignment exists; the necessary size of address spacetherefore scales exponentially with the number of nodes of the graph, which can not behandled by the xed size of platform native numbers. Arbitrary precision arithmeticcan be applied, but it does not provide O(1) comparison or insertion.THESIS 2.2: I have proposed Algorithm 1, a correct algorithm for nding redundanttrees with strictly linear, O(e) complexity.Algorithm 1 uses a DFS tree to make an ear decomposition of the graph as theoriginal algorithm does, but in contrast to the algorithm presented in [Zha05], thismethod walks both upward and downward on this tree. In this way, the need ofsupporting a partial ordering is completely eliminated and keeping the complexitylinear becomes possible. Due to space limitations more detailed description can notbe presented here, but it can be found in [C7]. In order to help understanding thefollowing algorithm some notion is discussed here as well.First, DFS number at a given node x is the number of nodes visited before x (thesequence number). Lowpoint number of x is the smaller one from the minimum ofDFS numbers of neighbors and the minimum of lowpoint numbers of node's childrenin the DFS tree. Moreover, ADAG is a special directed spanning graph, usually

8almost fullling DAG properties. More details about ADAG can be found in [C7].Algorithm 1 Finding a pair of redundant trees for graph G and root node r1: Compute a DFS tree, compute the DFS and lowpoint numbers. Initialize theADAG A with the nodes of G and an empty edge set. Create an empty stack S.Set the ready bit at each node to false.2: Push r to S and set ready bit at r.3: while S is not empty4: current ← pop S5: for each not ready children of currentWalk down along the DFS tree from node n. Always choose the eldestchild until the lowpoint number comes from an ancestor. Add thispath to ADAG A, set the ready bit at the nodes of this path true and6: push them to stack S in reverse order.7: end for8: for each not ready neighbor of current which is not a childWalk up along the DFS tree from node n until a ready node is reached.Add this path to ADAG A, set the ready bit at the nodes of this pathtrue and push them to stack S in reverse order.9:10: end for11: end while12: Do two BFS on A from node r. Fist take the edges in their normal direction thenin reverse direction. The two BFS trees make up a pair of redundant trees.I enhanced the algorithm in [Zha05] with arbitrary precision arithmetic in orderto guarantee the correctness. Using extensive simulations I compared this enhancedversion of the algorithm in [Zha05] with the algorithm I proposed, and I have shownthat the algorithm I dened is signicantly more eective especially on large graphs.One may observe that in order to use redundant trees for resilience purposes intelecommunications networks, it is commonly desirable to compute a pair of redundanttrees with respect to each potential destination node as root node. Althoughnding a pair of redundant trees rooted at a given node has O(e) complexity, computinga pair of redundant trees with each node as a root is not linear any more, it needsO(ne) time. Moreover, since each spanning tree has n − 1 edges, 2n spanning treeshave 2n(n − 1) edges. Since only writing these edges to the memory needs at least2n(n − 1) steps, nding all these trees needs Ω(n 2 ) time, so no centralized algorithmfor computing all the trees cannot be linear any more.However, one may also observe that in real networks usually no node (router)needs complete redundant trees, but only the next hops in these trees, the edgesemanating from the node. Naturally, in this way all redundant trees are computed as

well, although the information is distributed in the network. Now, n processors canbe used, giving the possibility to further decrease the computation complexity.THESIS 2.3: I proposed Algorithm 2, a distributed algorithm for n processors withlinear, O(e) complexity for nding a pair of redundant trees rooted at each node of anundirected graph.Remark: Using this algorithm each router computes the next hops in each redundanttree towards the root in linear time. The technique is fully distributed, nocommunication is needed after the exploration of the topology.Algorithm 2 runs on each processor completely separated, only the input graph issupposed to be the same. It is also supposed that either each processor is a node ofthe input graph (e.g. the processors are routers in a network), or there is a one-toonemapping between them. Let the current processor be assigned to node x. Thealgorithm rst computes an ADAG with a global root (e.g. the node with the lowestID, let let this node be node r) in exactly similar way to Algorithm 1. Next, it splitsr to two nodes, to node r + and r − , so that edges only enter r + and only leave r − . Inthis way a DAG is created, let it be DAG D. DAG D gives the possibility of partiallyordering the nodes: let node u less than node v (u ≺ v), if and only if there is adirected path from u to v in D. Using this ordering, the algorithm nds the edges.4.3 Improving node-redundant treesPreviously, I was dealing with nding redundant trees, a useful but limited mathematicalobject. This thesis gives two ways of improving these trees. First, I lift thearticial assentation that graphs, in which redundant trees can be found, must be2-node-connected and generalize the concept of redundant trees on arbitrary graphs.Second, I propose a technique, with which it is possible to signicantly decrease thelength of paths in the redundant trees found, without increasing the computationalcomplexity.THESIS 3: [C7] I have generalized the concept of redundant trees from 2-nodeconnectedgraphs to arbitrary graphs. I call these generalized redundant trees as maximallyredundant trees. I have proven that my linear algorithm for nding redundanttrees can nd maximally redundant trees as well. Additionally, I have proven that thedistributed algorithm I proposed can also be applied on arbitrary graphs with minormodications, and it nds maximally redundant trees. Furthermore, I have proposeda technique to decrease the paths in the maximally redundant trees without increasingthe computational complexity.THESIS 3.1: I have generalized to concept of node-redundant trees from 2-connectedgraphs to arbitrary graphs.9

10Algorithm 2 Finding the edges (h P x (d) and h S x(d)) of the primary and secondaryredundant trees rooted at node d going out from node x.1: Compute an ADAG with a global root (e.g. the node with the lowest ID, let letthis node be node r).2: Create DAG D by splitting r to two nodes, to node r + and r − , so that edges onlyenter r + and only leave r − .3: Compute a BFS from x on DAG D using the edges in normal direction. Markthe nodes reached to indicate that they are elements of V + . Let f x + (d) denote therst edge of the path from x to d ∈ V + .4: Compute a BFS from x on DAG D using the edges in reverse direction. Markthe nodes reached to indicate that they are elements of V − . Let fx − (d) denote therst edge of the path from x to d ∈ V − .5: if x = r then6: h P r (d) = f r + (d) and h S r (d) = fr − (d)7: else8: if d ∈ V x+ then9: h P x (d) = f x + (d) and h S x(d) = fx − (r − )10: else if d ∈ Vx− then11: h P x (d) = f + x (r + ) and h S x(d) = f − x (d)12: else13: h P x (d) = f − x (r − ) and h S x(d) = f + x (r + )14: end if15: end if

11Figure 5: A pair of maximally redundant trees rooted at node D.Denition 4.2. Given an undirected graph G and a root node r, a pair of maximallyredundant trees of graph G rooted at node r is a pair of directed spanning trees of Gwith edges directed towards r. This node is reachable from any other node along bothof the trees, so that the paths in the two trees have the minimum possible number ofcommon nodes (only the cut vertices).Remark: Having only the cut vertices in common involves having the minimumnumber of common edges as well, since an edge with two cut vertices as both endpointsis a cut edge (bridge).A pair of maximally redundant trees are depicted on Fig. 5. Maximally redundanttrees gives us the maximum possible redundancy. If there are two node-disjoint pathsbetween two nodes, in maximally redundant trees the paths are node-disjoint as well.Otherwise, both paths will only include the minimum number of common nodes, thecut vertices, which can not be avoided by any path. Maximally redundant trees canbe found in arbitrary graphs.THESIS 3.2: I have proved that the algorithm I proposed for nding redundant treesin linear time (in Thesis 2.2) can be applicable on non-2-node-connected graphs aswell. On these graphs my algorithm nds maximally redundant trees and its complexityremains linear.Since all graphs are made up by some 2-node-connected components (possiblya component can contain only one node) and in these components the algorithm iscorrect and complete, the algorithm is correct and complete if and only if it can dealwith the borders of these 2-node-connected components. The two possible ways ofconnecting two components are depicted on Fig. 6.Two 2-node-connected components can have no or one common node, since twocomponents with more then one node in common would qualify as one component. Ihave proven that the Algorithm 1 handles both cases well.THESIS 3.3: I improved the distributed algorithm in Thesis 2.3 to make it capableto nd maximally redundant trees in arbitrary graphs in linear, O(e) time.

THESIS 3.4: I dened heuristics to cut down the length of the paths in redundanttrees or maximally redundant trees. These heuristics can only make paths shorter butnever longer, while still retaining the linear complexity of the maximally redundanttree algorithm.One may observe that the length of maximally redundant trees depends on theADAG found. One may also observe that usually there are some edges of the graphleft out from the ADAG. If it were possible to add these edges to the ADAG, it woulddecrease the number of hops along the paths in maximally redundant trees. Theproblem is that these edges can not be added to an ADAG in any direction to keepordering.When the graph is 2-node-connected, splitting the root would give a DAG, whichgives the partial ordering. Additionally, getting a topological ordering of this DAGis the same as completing this partial ordering to a complete ordering. By usingthis complete ordering a concrete number can be assigned to each nodes, and addingthe extra edges directed towards the node with smaller number keeps ordering. Theproblem steams from the fact that splitting the root is not enough to convert anADAG to a DAG if the original graph is non-2-node-connected.The solution is to modify the algorithm of creating a topological order. A commonway of nding topological order is to nd a node with no edges entering in it. Thisnode gets the rst number and it is removed. After removing this node there mustbe some nodes without edges entering in them again. One of these nodes could beremoved, the second number is assigned to it and so on. This algorithm can beperformed in linear time.I modied this algorithm. First, during the construction of the ADAG, my algorithmcounts at each node x the number of ears both emanating from and enteringto x. This number is the number of 2-node-connected components with x as a localroot. If the number of edges entering to a node reaches this number, x can be left,since now it is connected only to the components where x is a local root. In this waya number can be assigned to each nodes and using these numbers upkeep of orderingis possible.THESIS 3.5: By extensive simulations performed on real and random network topologies,I have shown that the proposed heuristics reduce the average length of the pathsin the redundant trees by at least 144% of the average length of the shortest ones.4.4 Lightweight Not-ViaTo our days, numerous **IP** fast reroute solutions came into existence, yet the largestindustrial backing is undoubtedly behind the technique based on the notion of Not-Via addresses [Bry08]. Although, this technique has some drawbacks Not-Via is stilla rather straight-to-the point solution. This thesis deals with the disadvantages of13

14Not-Via and a possible way to eliminate or at least to mitigate them.The most important drawback of Not-Via is based on that this technique uses**IP** addresses for indicating failed resource, making operators to face serious addressmanagement challenges. Furthermore, Not-Via needs numerous shortest path treecomputations, generating signicant additional complexity. Finally, Not-Via needstreating some special cases making the algorithm hard to trace for debugging ordevelopment purposes.THESIS 4: [C5][C6] I have shown that utilizing the concept of maximally redundanttrees for backup paths, the computational and management complexity of Not-via canbe reduced to a level that is on par with the complexity of traditional shortest pathrouting.THESIS 4.1: I have redened the backup path computing method of Not-via, sothat detours are organized over maximally redundant trees. I called the new **IP**FRRmethod as Lightweight Not-via.Instead of computing numerous shortest paths for backup paths, Lightweight Notviacomputes a pair of maximally redundant trees for all the nodes of the network asa root. Since I have not modied the computing of the default paths, if there is nofailure the shortest paths are used. If a failure shows up, Lightweight Not-via usestunnels to transport the packet to the next-next hop, as the original technique does,but now, packets on detour are forwarded along one of maximally redundant treesrooted at the next-next hop.THESIS 4.2: I have shown that Lightweight Not-via uses only three **IP** addressesper node at most.Remark: Lightweight Not-Via does not need additional **IP** addresses at all in mostof current **IP** networks.Since there are only maximally redundant trees rooted at a node, a default addressis needed for shortest path routing and two additional for selecting the propermaximally redundant tree. In contrast, three **IP** addresses is the absolute minimumof the original Not-via, reachable only in point-to-point networks with ring topology.Furthermore, the the number of additional **IP** addresses needed by the originalNot-via scales quadratic with the nodes in LANs.Moreover, since each node has only a constant number of **IP** addresses, in mostof current **IP** networks no additional address is needed at all. In these networks eachinterface has its own **IP** address, and the router itself has another loopback address.The loopback addresses can be used as default addresses and two interface addressesfor detours. Since rerouting needs networks to be 2-node-connected, at least twointerfaces per node is common.THESIS 4.3: I have shown that Lightweight Not-via asymptotically eliminates theadditional complexity penalty that stems from the need to compute backup paths for

**IP** Fast ReRoute.Computing the next hops on maximally redundant trees rooted at each nodeneeds only O(e) time. Additionally, since default paths are the shortest ones, usingDijkstra's algorithm is also needed. Thus, the overall complexity of computing thepaths of Lightweight Not-via is O(e + n log n + e) = O(n log n + e), which equals thecomplexity of the mere Dijkstra's algorithm.THESIS 4.4: By means of extensive measurements conducted on an **IP** Fast ReRouteprototype with real trac traces, I have shown that the extra management and computationalburden of the original Not-via is higher than that of the Lightweight Not-viaby at least one order of magnitude.I used the full-edged Not-via and Lightweight Not-via prototype network deployedat Department of Telecommunications and Media Informatics at BudapestUniversity of Technology and Economics. I injected articial Link State Advertisements(LSAs) of various real-life network topologies into the Link State Database ofthe routers and I measured the computational complexity and the number of addressesneeded.15

16References[Shand08] M. Shand, S. Bryant **IP** Fast Reroute framework Internet Draft, available online:http://tools.ietf.org/html/draft-ietf-rtgwg-ipfrr-framework-10, Feb 2009.[Cicic07] T. Cicic, A. F. Hansen, O. K. Apeland Redundant trees for fast **IP** recovery4th International Conference on Broadband Communications, Networks, andSystems (Broadnets), pp. 152159, Sept. 2007[Nel06] S. Nelakuditi, S. Lee, Y. Yu, Z. L. Zhang, C. N. Chuah Fast local reroutingfor handling transient link failures. Transactions on Networking, 37(12):4247,Dec 2006.[Méd99] M. Médard, R. G. Barry, S. G. Finn Redundant trees for preplanned recoveryin arbitary vertex-redundant or edge-redundant graphs.. IEEE/ACM Transactionson Networking, 7(5):641652, Okt 1999.[Méd02] M. Médard, R. A. Barry, S. G. Finn, W. He, S. S. Lumetta Generalized loopbackrecovery in optical mesh networks. IEEE/ACM Transactions on Networking,10(1):153164, Feb 2002.[Zha05] W. Zhang, G. Xue, J. Tang, and K. Thulasiraman Linear time constructionof redundant trees for recovery schemes enhancing QoP and QoS. INFOCOM2005, pp. 27022710, March 2005.[Xue02] G. Xue, L. Chen, and K. Thulasiraman Delay reduction in redundant trees forpreplanned protection against single link/node failure in 2-connected graphs.Global Telecommunications Conference, GLOBECOM '02. IEEE, pp.26912695, November 2002.[Cic07] T. Cicic, A. F. Hansen, and O. K. Apeland Redundant trees for fast **IP** recovery.Broadnets, pp. 152159., 2007.[Bry08] S. Bryant, M. Shand, and S. Previdi Inrernet Draft, February 2008.

17Publication of new results[J] Journals[J1] András Császár, Gábor Enyedi, Gábor Rétvári, Marcus Hidell, Peter Sjödin, Convergingthe Evolution of Router Architectures and **IP** Networks, IEEE Network Magazine,Special Issue on Advances in Network Systems Architecture, 21:4(814) 2007.[J2] Péter Fodor, Gábor Enyedi, Gábor Rétvári, Tibor Cinkler, Layer-Preference Policiesin Multi-layer GMPLS Networks, Accepted to Photonic Network Communications 2009.[J3] Gábor Enyedi, Gábor Rétvári, Gyors hibajavítás **IP** hálózatokban (hungarian), submittedto Híradástechnika[C] Conferences[C1] Péter Fodor, Gábor Enyedi, Tibor Cinkler, A Fast and Ecient Trac EngineeringMethod for Transport Networks, V Workshop in G/MPLS Networks (WGN5), pages129141, 2006.[C2] Gábor Enyedi, Gábor Rétvári, Tibor Cinkler, A Novel Loop-free **IP** Fast RerouteAlgorithm, 13th EUNICE Open European Summer School and IF**IP** TC6.6 Workshopon Dependable and Adaptable Networks and Services (EUNICE), Twente, TheNetherlands, 2007.[C3] Gábor Enyedi, Gábor Rétvári A Loop-Free Interface-Based Fast Reroute Technique,4th EURO-NGI Conf. on Next Generation Internet Networks (EuroNGI), Krakków,Poland, pages 3944, 2008.[C4] Péter Fodor, Gábor Enyedi, Gábor Rétvári, Tibor Cinkler, An Ecient and PracticalLayer-preference Policy for Routing in GMPLS Networks, 13th Int. TelecommunicationsNetwork Strategy and Planning Symposium (NETWORKS), Budapest,Hungary, 2008.[C5] Gábor Enyedi, Péter Szilágyi, Gábor Rétvári, Andr'as Császár, **IP** Fast ReRoute:Lightweight Not-Via, Accepted to IF**IP** Networking, May. 2009.[C6] Gábor Enyedi, Péter Szilágyi, Gábor Rétvári, Andr'as Császár, **IP** Fast ReRoute:Lightweight Not-Via without Additional Addresses, Accepted to INFOCOM-MiniConference, Apr. 2009.[C7] Gábor Enyedi, Gábor Rétvári, Andr'as Császár, On Finding Maximally RedundantTrees in Strictly Linear Time, Accepted to ISCC'09, July 2009.