A single-link failure routing protection method based on reconstructed SPT

Abstract

The application belongs to the technical field of Internet, and relates to an intra-domain failure routing protection scheme, which discloses a single-link failure routing protection method based on reconfiguration SPT. The application calculates backup next hops for nodes in a network by using reconfiguration SPT, so as to realize single-link failure routing protection based on a network layer, and effectively solve problems such as difficulty in actual deployment of an existing routing protection scheme, low failure protection rate, and large calculation cost. The protection scheme provided by the application can effectively solve the situation of single-link failure in the network, can greatly improve the failure protection rate in the network, and is easy to realize and deploy. Therefore, the scheme can provide an effective solution for network operators to improve network service quality and routing protection.

Description

Technical Field

[0001] This invention belongs to the field of Internet technology and relates to intra-domain fault routing protection schemes, specifically to a single-link fault routing protection method based on SPT reconstruction. Background Technology

[0002] The true internet can be traced back to the 1970s and 80s, when it was still in its early stages, a simple collection of various computer networks. With the rapid development of the internet, the network scale has continuously expanded, and various types of devices and terminals have connected to form a vast and complex network system. However, within this network system, data packets are forwarded along predetermined network routes, but various unpredictable hardware or software failures can occur during forwarding, leading to link failures and interruptions in data packet forwarding. This significantly impacts the normal operation of the internet, posing a huge challenge to the operation of applications deployed on it. To solve these problems, an effective routing protection scheme needs to be designed to reduce the impact of faulty routes and ensure stable data packet transmission.

[0003] Faced with frequent network routing failures, researchers both domestically and internationally have conducted extensive research and proposed several routing protection schemes, which can be broadly categorized into two types: hop-by-hop forwarding and non-hop-by-hop forwarding. ECMP, LFA, and DMPA are all based on hop-by-hop routing. For example, Equal Cost Multiple Paths (ECMP) is a relatively easy-to-implement routing protection scheme. Its operation mainly involves two scenarios: First, if multiple shortest paths with equal cost exist between node pairs, one is selected as the default route, and the others are used as backup routes. Second, if no shortest paths with equal cost exist between node pairs, no backup routes are used. ECMP's advantage is its ease of implementation and deployment, but its disadvantage is a relatively small improvement in route availability. Additionally, Not-Via and segment routing are based on non-hop-by-hop routing. For example, Not-Via is a method that calculates backup paths by marking whether nodes or links have failed. By default, data packets are forwarded along the shortest path. When a router node receives a data packet marked "Not-Via," the router will bypass the failed node or link marked "Not-Via" and forward the packet normally to its destination node. The advantage of Not-Via is that it helps improve routing availability, but the disadvantages are that it has high computational complexity and is not easy to deploy.

[0004] The above research reveals that most protection schemes are based on Shortest Path Tree (SPT) calculations, but they do not adequately optimize the SPT. Modifying the SPT structure can significantly improve routing availability, making it easier to deploy and implement in practice. Furthermore, single-link failures account for approximately 70% of routing failures in network routing.

[0005] In summary, the new routing protection scheme needs to focus on the protection of single-link routing failures, calculate backup next hops for nodes in the network, and use SPT reconstruction to achieve single-link failure routing protection based on the network layer. Summary of the Invention

[0006] To address the various problems that exist in the implementation of existing routing protection schemes in the background art, we utilize reconstructed SPT to calculate backup next hops for nodes in the network, thereby realizing single-link failure routing protection based on the network layer. Based on this, we propose a single-link failure routing protection method based on reconstructed SPT.

[0007] To facilitate understanding of our solution, we will first define and describe some symbols, which will be applicable to the entire invention.

[0008] First, the network topology is represented as G = (V, E, W), where V represents the set of nodes in topology G, E represents the set of links in topology G, and W represents the cost set of all links in topology G. `route(G)` represents a routing table generated based on G, containing each source-destination node pair and the optimal next-hop node from the source node to the destination node. In the routing table, if the optimal next hop of node a is node b, then node a is the parent node, and node b is the child node. The initial shortest path tree rooted at destination node d is denoted as `spt(d, G)`. `neighbors(d)` represents the neighbor nodes of node d. `child(d)` represents the child node of node d, and `parent(w)` represents the parent node of node w. The link connecting node d and node v is denoted as (d, v). `subtree(u, spt(G))` represents the subtree branch rooted at node u in `spt(G)`. Furthermore, dependency means that the parent of node u does not belong to the `subtree(u, spt(G))` branch but to another branch. bn(w,d,G) represents the set of backup next-hop nodes of node w in the topology graph G rooted at d.

[0009] This invention provides a single-link fault route protection method based on SPT reconstruction. Taking the destination node d as the root node, the specific calculation includes the following steps:

[0010] A single-link fault routing protection method based on SPT reconstruction includes the following steps:

[0011] Step 1: Initialize the node and link information in the topology graph G, and generate the initial routing table route(G);

[0012] Step 2: Based on the initial routing table route(G), run the shortest path tree algorithm to generate the initial shortest path tree spt(d,G) corresponding to the topology graph G;

[0013] Step 3: Determine if all neighboring nodes of node d have been traversed. If so, the algorithm ends; otherwise, proceed to step 4.

[0014] Step 4: For v∈neighbors(d), disconnect link (d,v) and generate a new routing table route(G), run the shortest path tree algorithm, and generate a new shortest path tree spt(G);

[0015] Step 5: Compare spt(G) with spt(d,G). For a node u∈s spt(G), if parent(u) and u do not belong to the same branch, then store it in set l.

[0016] Step 6: Get the first node u in the set l, and perform a depth-first traversal of the branch rooted at u, subtree(u,spt(G));

[0017] Step 7: For w∈subtree(u,spt(G)), if parent(w)=child(w,spt(d,G)) or w=u is true, execute step 8; otherwise, execute step 10.

[0018] Step 8: Add parent(w) to bn(w,d,G);

[0019] Step 9: Determine if all nodes of subtree(u,spt(G)) have been traversed. If so, proceed to step 3; otherwise, proceed to step 7.

[0020] Step 10: For w∈subtree(u,spt(G)), disconnect (w,parent(w)) and generate a new routing table route(G), run the shortest path tree algorithm, generate a new spt(G), and continue to execute step 5.

[0021] In the above steps, running the shortest path tree algorithm based on the routing table route(G) specifically includes the following steps:

[0022] Step 1: Use the Floyd algorithm to obtain the routing table route(G) and find the optimal next-hop node for each node;

[0023] Step 2: Arrange the nodes and their best next-hop nodes according to the parent-child relationship to construct the shortest path tree.

[0024] Compared with existing routing protection schemes, the present invention has the following advantages:

[0025] 1. This invention proposes a single-link failure routing protection method based on reconstructed SPT (Single-Link Triggering). This method can effectively solve single-link failure scenarios in networks, and can calculate backup next-hop nodes for all nodes in the network. It can effectively address the problems of computational overhead, failure protection rate, and path stretching that existing routing protection schemes lack.

[0026] 2. This invention not only boasts a high fault protection rate and low path stretching, but also exhibits low computational complexity, making it easy to implement and deploy. Therefore, this invention can provide network operators with an effective solution for improving network service quality and implementing route protection. Attached Figure Description

[0027] Figure 1 This is a flowchart illustrating the single-link fault routing protection method based on SPT reconstruction of the present invention.

[0028] Figure 2 This is a schematic diagram of the initial network topology G in an embodiment of the present invention;

[0029] Figure 3 This is an embodiment of the present invention. Figure 2 Schematic diagram of the reconstructed network topology G'. Detailed Implementation

[0030] To better illustrate the calculation process, technical solution, and advantages of this invention, the following description is in conjunction with the appendix. Figures 1 to 3 The present invention will be further described below.

[0031] The following will describe each step in this embodiment in detail. Because this invention calculates the situation of all nodes, the following explanation only uses the destination node d as an example and lists the case of disconnecting the faulty link (d, b). To better illustrate the calculation process, technical solution, and advantages of this invention, the invention will be further described below in conjunction with the accompanying drawings.

[0032] The following will describe each step in this embodiment in detail. Since the present invention calculates the situation of all nodes, the following will only take the destination node d as an example and list the situation of disconnecting the faulty link (d,b).

[0033] Step 1: Initialize the node and link information in the topology graph G. The node set V = {a,b,c,d,e,f,g}, and the link set E = {(a,d),(b,d),(c,a),(e,b),(f,e),(g,f),(f,a),(g,c)}.

[0034] Step 2: Construct the routing table route(G), and run the shortest path tree algorithm to generate the initial shortest path tree spt(d,G) corresponding to the topology graph G, specifically as follows;

[0035] Step 2.1: Use the Floyd algorithm to obtain the routing table route(G), and find the optimal next-hop node for each node. The information in the routing table consists of multiple triples, where the values ​​in the triples represent the source node, the destination node, and the optimal next-hop node, respectively. That is, {(a,d,d),(b,d,d),(c,d,a),(e,d,b),(f,d,e),(g,d,f)}. Therefore, the optimal next hop for node a is node d, the optimal next hop for node b is node d, the optimal next hop for node c is node a, the optimal next hop for node e is node b, the optimal next hop for node f is node e, and the optimal next hop for node g is node f.

[0036] Step 2.2: Arrange the nodes and their optimal next-hop nodes according to the parent-child relationship to construct the shortest path tree, i.e., spt(d,G)={(d,a),(d,b),(a,c),(b,e),(e,f),(f,g)};

[0037] Step 3: Not all neighboring nodes of node d have been traversed, proceed to step 4;

[0038] Step 4: For b∈neighbors(d), disconnect the link (d,b), construct the routing table route(G), and run the shortest path tree algorithm to obtain a new shortest path tree spt(G), specifically:

[0039] Step 4.1: Use the Floyd algorithm to obtain the routing table route(G), find the optimal next-hop node for each node, and the routing table information is {(a,d,d),(b,d,e),(c,d,a),(e,d,f),(f,d,a),(g,d,f)};

[0040] Step 4.2: Arrange the nodes and their optimal next-hop nodes according to the parent-child relationship to construct the shortest path tree, i.e., spt(G) = {(d,a),(a,c),(a,f),(f,g),(f,e),(e,b)};

[0041] Step 5: Compare the obtained spt(G) with the spt(d,G) obtained in Step 2. For a node f∈spt(G), if parent(f) and f do not belong to the same branch, then store it in set l.

[0042] Step 6: Get the first node f in the set, and perform a depth-first traversal of the subtree rooted at f, subtree(f,spt(G));

[0043] Step 7: For f∈subtree(f,spt(G)), determine if f=f is true, then proceed to step 8;

[0044] Step 8: Add parent(f) = a to bn(f,d,G) = {a};

[0045] Step 9: Since not all nodes of subtree(f,spt(G)) have been traversed, continue to step 7;

[0046] Step 7: For e∈subtree(f,spt(G)), determine if parent(e)=child(e,spt(d,G))=f is true, then execute step 8;

[0047] Step 8: Add parent(e) = f to bn(e,d,G) = {f};

[0048] Step 9: Since not all nodes of subtree(f,spt(G)) have been traversed, continue to step 7;

[0049] Step 7: For b∈subtree(f,spt(G)), determine if parent(b)=child(b,spt(d,G))=e is true, then execute step 8;

[0050] Step 8: Add parent(b) = e to bn(b,d,G) = {e};

[0051] Step 9: Since not all nodes of subtree(f,spt(G)) have been traversed, continue to step 7;

[0052] Step 7: For g∈subtree(f,spt(G)), parent(g)=child(g,spt(d,G)) is not true, then execute step 10;

[0053] Step 10: For g∈subtree(f,spt(G)), disconnect (g,parent(g)=f), construct the route table route(G), run the shortest path tree algorithm, construct spt(G), and execute step 5.

[0054] Furthermore, it should be understood that although this specification describes embodiments, not every embodiment contains only one independent technical solution. This narrative style is merely for clarity. Those skilled in the art should consider the specification as a whole, and the technical solutions in each embodiment can also be appropriately combined to form other embodiments that can be understood by those skilled in the art.

Claims

1. A single-link fault routing protection method based on SPT reconstruction, comprising the following steps: Step 1: Initialize the node and link information in the topology graph G and generate the initial routing table. ; Step 2: Based on the initial routing table Run the shortest path tree algorithm to generate a topology graph. G The corresponding initial shortest path tree ; Step 3: Determine the target node If all neighboring nodes have been traversed, the algorithm ends; otherwise, proceed to step 4. Step 4: Destination Node and nodes The links connecting them are represented by the symbol . ,for Disconnect the link And generate a new routing table Run the shortest path tree algorithm to generate a new shortest path tree. , Indicates the destination node The neighboring nodes; Step 5: and For the comparison, for the nodes , and If they do not belong to the same branch, store them in In the set; Step 6: Obtain The first node in the set Depth-first traversal Branches of the root ; Step 7: For ,if or If successful, proceed to step 8; otherwise, proceed to step 10. Represents a node The parent node, Indicates in Middle node The set of child nodes; Step 8: [The text appears to be incomplete and contains several grammatical errors. A more accurate translation would require the full context.] Join middle, Represents a node In Topological graph with roots G The set of backup next-hop nodes in the data; Step 9: Determine If all nodes have been traversed, proceed to step 3; otherwise, proceed to step 7. Step 10: For ,disconnect And generate a new routing table Run the shortest path tree algorithm to generate a new one. Continue with step 5.

2. The single-link fault routing protection method based on SPT reconstruction according to claim 1, characterized in that: According to the routing table Running the shortest path tree algorithm specifically includes the following steps: Step 1: Obtain the routing table using the Floyd-Warshall algorithm. Find the optimal next-hop node for each node; Step 2: Arrange the nodes and their best next-hop nodes according to the parent-child relationship to construct the shortest path tree.

Images