CN114745320A

CN114745320A - Route protection method for single fault situation

Info

Publication number: CN114745320A
Application number: CN202210470601.3A
Authority: CN
Inventors: 耿海军
Original assignee: Shanxi University
Current assignee: Shanxi University
Priority date: 2022-04-28
Filing date: 2022-04-28
Publication date: 2022-07-12
Anticipated expiration: 2042-04-28
Also published as: CN114745320B

Abstract

The invention discloses a route protection method aiming at single fault situation, which solves the three problems existing in the existing route protection method: 1. hop-by-hop forwarding is not supported, 2. incremental deployment is not supported, 3. all possible single failure scenarios in the network cannot be protected. The method provided by the invention supports hop-by-hop forwarding and incremental deployment, has a smaller path stretching degree, and can also cope with all possible single fault situations in the network. The method provided by the invention can greatly improve the network availability and reduce the message loss rate caused by network faults, thereby meeting the requirements of implementation and application on the network availability. Therefore, the invention provides an effective solution for solving the routing availability problem for the Internet service provider.

Description

Route protection method for single fault situation

Technical Field

The invention belongs to the technical field of route protection schemes in internet domains, and particularly relates to a route protection method for a single fault situation.

Background

Since the birth date of the last 70 th century, the internet is in rapid development, a large number of emerging applications and services are emerging on the internet, and higher requirements are put forward on the routing availability of the internet. Therefore, the internet has been designed with a great deal of importance on routing availability, and adaptive dynamic routing protocols have been designed and used. However, when a fault occurs in the network, the routing protocol needs a certain convergence time to complete the route recalculation, and during the route convergence period, the consistency of the route cannot be guaranteed, so that the phenomena of routing loops, routing black holes and the like are caused, and finally packet loss and transmission service interruption are caused. For this reason, the industry proposes to use LFA (loop Free alternatives) scheme to cope with frequent failures in the network, and LFA is favored by the industry because of its simplicity in implementation and support of incremental deployment, however, LFA does not protect all possible single failure situations in the network. In order to solve the problem, researchers have proposed a Not-Via address-based fast rerouting algorithm, however, the algorithm needs assistance of an auxiliary address, and the calculation overhead and storage overhead are large, and thus, the algorithm is difficult to be supported by internet service providers.

Disclosure of Invention

Research shows that most faults in the network are single faults, and in order to solve the technical problem, the invention focuses on solving the single fault situation in the network, so that a route protection method for the single fault situation is provided.

For convenience of description, we first define some labels, which apply to the entire invention. The network topology may be represented by G ═ V, E, where V represents the set of all nodes in the network topology and E represents the set of all links in the network topology. For node m ∈ V in the network, n (m) represents a set of neighbor nodes of node m, wherein the neighbor nodes do not include a parent node, id (m) represents a node identifier of node m, priority (m) represents a priority of node m, and an operator (m) represents a node with hop count of 2 in all ancestor nodes of node m. Since the computation process is the same for each destination node, the destination node is assumed to be d. And for a destination node d epsilon V in the network, and using rspt (d) to represent a reverse shortest path tree taking the node d as a root. For any node pair m, d in the network, the backup next hop set from node m to node d is represented by bn (m, d).

The technical scheme is a route protection method aiming at a single fault situation, which comprises the following steps:

step 1: for nodes in the network

And the destination node d belongs to V, and the priority of the node m is set to 0, namely: priority (m) ═ 0, set the backup next hop from node m to destination node d to the empty set, i.e.: bn (m, d) ═ phi, where priority (m) denotes the priority of node mLevel, bn (m, d) represents the backup next hop from node m to node d, V represents the set of nodes in the network;

step 2: calculating a reverse shortest path tree rspt (d) taking the node d as a root according to a Dijkstra algorithm;

and step 3: computing a set of nodes R using the reverse shortest path tree rspt (d), the nodes in the set satisfying

Wherein an operator (u) represents a node with a hop count of 2 in all ancestor nodes of the node u, an operator (v) represents a node with a hop count of 2 in all ancestor nodes of the node v, n (v) represents a set of neighbor nodes of the node v, and the node v represents a neighbor node of the node u;

and 4, step 4: creating a priority queue Q, wherein the structure of elements in the queue Q is (u, priority (u) and id (u)), the priority (u) represents the priority of the node u, and the id (u) represents the node identification of the node u;

and 5: for nodes in the network

Setting the priority of the node to be 2, and adding the node into a priority queue Q;

step 6: judging whether the priority queue Q is empty, if not, executing the step 7, otherwise, ending;

and 7: reading a queue head node u in the priority queue Q, and storing the node u in a variable k;

and 8: traversing a neighbor node v of the node u;

and step 9: judging whether the priority (u) is more than or equal to 1 and the condition that the neighbor node v does not back up the next hop is met, if so, adding the neighbor node v into the priority queue Q, further executing the step 10, and if not, directly executing the step 10;

step 10: judging whether an processor (u) is the same as the processor (v), if the processor (u) is not equal to the processor (v), adding the node v to a backup next hop bn (u, d) ═ bn (u, d) · u } of the nodes u to d, executing step 13, and if the processor (u) is equal to the processor (v), executing step 11;

step 11: judging whether the node priority of the node u is equal to 2, if so, executing the step 13, otherwise, executing the step 12;

step 12: judging whether the node v has a backup next hop, if not, directly executing the step 13, otherwise, adding the node v into the backup next hop bn (u, d) ═ bn (u, d) < u { v }, setting the priority of the node u to be 1, and executing the step 13;

step 13: judging whether the node v is the last neighbor of the node u, if so, executing the step 14, otherwise, executing the step 8, and continuously traversing the next neighbor node;

step 14: and judging whether the backup next hop of the nodes u to d exists or not, if so, deleting the node u from the priority queue Q, and executing the step 6 again, otherwise, directly executing the step 6.

As further explained in the above technical solution, the method for calculating the node set R in step 3 is as follows:

step 3.1: creating a queue M for nodes in the network

Adding to the queue;

step 3.2: judging whether the queue M is empty, if not, executing the step 3.3, otherwise, executing the step 4;

step 3.3: taking out a node u from M, traversing the neighbor node of the node u, storing the neighbor node in a variable g, and executing the step 3.4;

step 3.4: judging whether the processor (u) is the same as the processor (v), if so, directly executing the step 3.6, otherwise, setting the priority of the node u and the node v to be 2, and executing the step 3.5;

step 3.5: judging whether the node u and the node v are in the set R, if so, directly executing the step 3.6, otherwise, adding the node u and the node v into the set R, and executing the step 3.6;

step 3.6: and judging whether the node v is the last neighbor of the node u, if so, executing the step 3.2, otherwise, executing the step 3.3, and continuously traversing the next neighbor node.

As further explained in the above technical solution, the head node of the priority queue Q in step 7 meets the following requirements:

(1) the head node selects the node with the maximum priority from all the nodes in the queue Q;

(2) if a plurality of nodes have the same priority, the head-of-line node is the node with the minimum node identification.

Compared with the prior art, the invention has the following advantages: 1. the method has the characteristics of supporting hop-by-hop forwarding and incremental deployment, having smaller path stretching degree and being capable of dealing with all possible single fault situations in the network. 2. The invention can deal with any single fault situation in the network, greatly improves the routing availability, reduces the network interruption time caused by the fault and improves the experience degree of the user to the network performance. Therefore, the invention provides an effective solution for solving the routing availability problem for the Internet service provider.

Drawings

FIG. 1 is a schematic flow diagram of an embodiment of the present invention;

FIG. 2 is a flow chart of a compute node set R in an embodiment of the invention;

FIG. 3 is a schematic diagram of a network topology G of an embodiment of the present invention;

FIG. 4 is a schematic diagram of rspt (d) in accordance with an embodiment of the present invention.

Wherein: in fig. 3, the numbers next to a link represent the corresponding cost for that link;

in fig. 4, solid lines represent links of the tree and dashed lines represent links in the network.

In order to make the technical solutions and advantages of the present invention clearer, the following describes the present invention in detail with reference to the network topology G in fig. 3 in conjunction with the flow ideas of fig. 1 and 2, and the following describes the specific implementation manner of this embodiment in detail:

step 1: setting priorities of nodes a, b, c, e in the network to 0, namely, priority (a), (b), (c), (e), (0), and setting backup next hops of the nodes to an empty set, namely, bn (a, d), (bn (b, d), (bn (c, d), (bn (e, d), (Φ);

step 2: for the destination node d ∈ V, calculating a reverse shortest path tree rspt (d) taking the node d as a root according to Dijkstra algorithm, as shown in FIG. 4;

and 3, step 3: and calculating a node set R by the following method:

step 3.1: creating a queue M, and adding nodes in the network into the queue, wherein the queue M is { a, b, c, e };

step 3.2: because queue M is not empty, step 3.3 is performed;

step 3.3: when u is a, M is b, c, e;

step 3.4: traversing neighbor nodes of the node a, wherein v is b;

step 3.6: step 3.4 is performed because node b is not the last neighbor node of node a;

step 3.4: traversing neighbor nodes of the node a, wherein v is c;

step 3.5: because an operator (a) and an operator (c) are c, R ═ { a, c }, priority (a) priority (c) ═ 2;

step 3.6: step 3.4 is performed because node c is not the last neighbor node of node a;

step 3.4: traversing neighbor nodes of the node a, wherein v is e;

step 3.6: since node e is the last neighbor node of node a, step 3.2 is performed;

step 3.2: because queue M is not empty, step 3.3 is performed;

step 3.3: when u is b, M is { c, e };

step 3.4: traversing neighbor nodes of the node b, wherein v is e;

step 3.6: step 3.2 is performed because node e is the last neighbor node of node b;

step 3.2: because queue M is not empty, step 3.3 is performed;

step 3.3: when u ═ c, M ═ e };

step 3.4: traversing neighbor nodes of the node c, wherein v is a;

step 3.6: step 3.4 is performed because node a is not the last neighbor node of node c;

step 3.4: traversing neighbor nodes of the node c, wherein v is e;

step 3.5: because an operator (a) and an operator (c) are c, R ═ { a, c, e }, priority (e) ═ 2;

step 3.6: step 3.2 is performed because node e is the last neighbor node of node c;

step 3.2: because queue M is not empty, step 3.3 is performed;

step 3.3: when u is e, M is { };

step 3.4: traversing neighbor nodes of the node e, wherein v is b;

step 3.6: step 3.4 is performed because node b is not the last neighbor node of node e;

step 3.4: traversing neighbor nodes of the node e, wherein v is c;

step 3.5: because operator (a) and operator (c) are c, R is { a, c, e }, priority (e) priority (a) priority (c) } 2;

step 3.6: step 3.2 is performed because node c is the last neighbor node of node e;

step 3.2: because queue M is empty, go to step 4;

and 4, step 4: creating a priority queue Q, wherein the structure of elements in the queue is (u, priority (u), id (u));

and 5: for nodes a, c, e in the network, setting the priority of these nodes to 2, and adding these nodes to a priority queue Q, at which time the priority queue Q { (a,2, id (a)), (c,2, id (c)), (e,2, id (e)) };

step 6: because the priority queue Q is not empty at this time, step 7 is executed;

and 7: reading a head node of the priority queue, and storing the head node in a variable u, wherein u is a;

and 8: traversing neighbor nodes of the node a, and storing the neighbor nodes of the node a in a variable v, wherein v is b;

and step 9: because priority (a) is 2 and node b does not back up the next hop, node b is added to the priority queue, when priority queue Q { (a,2, id (a)), (c,2, id (c)), (e,2, id (e)), (b,0, id (b)) };

step 11: because the controller (a) ═ controller (b) and the priority (a) ═ 2, step 13 is executed:

step 13: because node a also has neighbor nodes, step 8 is performed;

and 8: traversing neighbor nodes of the node a, and storing the neighbor nodes of the node a in a variable v, wherein v is c;

and step 9: priority (c) ═ 2, because node c is already in the queue, no operation is performed;

step 10: since the processor (a) ≠ processor (c), node c is added to the backup next hop of nodes a-d

bn(a,d)＝{c}；

Step 13: because node a also has neighbor nodes, step 8 is performed;

and 8: traversing neighbor nodes of the node a, and storing the neighbor nodes of the node a in a variable v, wherein v is e;

and step 9: because priority (e) is 0, no operation is performed:

step 11: because operator (a) ═ operator (e), priority (a) ═ 2, step 13 is performed;

step 13: since node e is the last neighbor node of node a, step 14 is performed;

step 14: deleting the node a from the priority queue Q because a backup next hop exists for the nodes a to d, when the priority queue Q { (c,2, id (c)), (e,2, id (e)), (b,0, id (b)) };

step 15: step 6 is performed.

and 7: reading a head node of the priority queue, and storing the head node in a variable u, wherein the u is c;

and 8: traversing neighbor nodes of the node c, and storing the neighbor nodes of the node c in a variable v, wherein v is a;

and step 9: because priority (c) is 2 and node a already has a backup next hop, no operation is performed:

step 10: since the processor (a) ≠ processor (c), joining node a to the backup next hop of nodes c to d

bn(c,d)＝{a}；

Step 13: since node c also has neighbor nodes, step 8 is performed;

and 8: traversing neighbor nodes of the node c, and storing the neighbor nodes of the node c in a variable v, wherein v is e;

and step 9: because priority (c) is 2, node e is already in the queue, no operation is performed;

step 10: since processor (e) ≠ processor (c), joining node e to the backup next hop of nodes c to d

bn(c,d)＝{a,e}；

Step 13: since node e is the last neighbor of node c, step 14 is performed;

step 14: deleting the node c from the priority queue Q because a backup next hop exists for the nodes c to d, at which time the priority queue Q { (e,2, id (e)), (b,0, id (b)) };

step 15: step 6 is performed.

and 7: reading a head node of the priority queue, and storing the head node in a variable u, wherein u is e;

and 8: traversing neighbor nodes of the node e, and storing the neighbor nodes of the node e in a variable v, wherein v is b;

and step 9: because priority (e) is 2, node b is already in queue Q, no action is performed:

step 11: because the operator (e) ═ operator (b), priority (e) ═ 2, step 13 is performed;

step 13: since node e also has neighbor nodes, step 8 is performed;

and step 8: traversing neighbor nodes of the node e, and storing the neighbor nodes of the node e in a variable v, wherein v is c;

and step 9: because priority (e) is 2, node c already has a backup next hop, no operation is performed:

step 10: since processor (e) ≠ processor (c), node c is added to the backup next hop of nodes e to d

bn(e,d)＝{c}；

Step 13: since node c is the last neighbor of node e, step 14 is performed;

step 14: deleting the node e from the priority queue Q because a backup next hop exists for the node e to d, wherein the priority queue Q { (b,0, id (b)) };

step 15: executing the step 6;

and 7: reading a head node of the priority queue, and storing the head node in a variable u, wherein u is b;

and 8: traversing the neighbor nodes of the node b, and storing the neighbor nodes of the node b in a variable v, wherein v is e;

and step 9: because priority (b) is 0, no operation is performed;

step 11: because the operator (e) ═ operator (b), priority (b) ═ 0, step 12 is performed;

step 12: adding node e to the backup next hop bn (b, d) ═ e } of nodes b to d because node e has a backup next hop; and setting the priority of node e to 1;

step 13: since node e is the last neighbor of node b, step 14 is performed;

step 14: deleting the node b from the priority queue Q because a backup next hop from the node b to the node d exists, wherein the priority queue Q is { };

step 15: step 6 is performed.

Step 6: since the priority queue Q is empty at this time, it ends.

The features and advantages of the present invention have been shown and described, it will be obvious to those skilled in the art that the embodiments of the present invention are not limited to the details of the foregoing exemplary embodiments, and therefore, the inventive concept and design concept of the present invention can be embodied in other specific forms without departing from the spirit or essential characteristics thereof, and it is intended to cover all modifications, equivalents, and equivalents of the subject matter recited in the claims. The present embodiments are therefore to be considered in all respects as illustrative and not restrictive, the scope of the invention being indicated by the appended claims rather than by the foregoing description, and all changes which come within the meaning and range of equivalency of the claims are therefore intended to be embraced therein.

Furthermore, it should be understood that although the present description refers to embodiments, not every embodiment may contain only a single embodiment, and such description is for clarity only, and those skilled in the art should integrate the description, and the embodiments may be combined as appropriate to form other embodiments understood by those skilled in the art.

Claims

1. A method of route protection for a single failure condition, comprising the steps of:

step 1: for nodes in the network

And the destination node d belongs to V, and the priority of the node m is set to 0, namely: priority (m) is 0, and node m is connected to the destination programThe backup next hop for point d is set to the empty set, i.e.: bn (m, d) ═ Φ, where priority (m) denotes the priority of node m, bn (m, d) denotes the backup next hop from node m to node d, V denotes the set of nodes in the network;

Wherein, operator (u) represents a node with the hop count of 2 in all ancestor nodes of the node u, operator (v) represents a node with the hop count of 2 in all ancestor nodes of the node v, N (v) represents a set of neighbor nodes of the node v, and the node v represents a neighbor node of the node u;

and 5: for nodes in the network

and 7: reading a head node u in the priority queue Q, and storing the node u in a variable k;

and 8: traversing a neighbor node v of the node u;

step 11: judging whether the node priority of the node u is equal to 2, if so, executing a step 13, otherwise, executing a step 12;

2. A method of route protection for single failure situations according to claim 1, characterized in that: the method for calculating the node set R in step 3 is as follows:

step 3.1: creating a queue M for nodes in the network

Adding to the queue;

3. A method of route protection for single failure situations according to claim 1, characterized in that: wherein the head node of the priority queue Q in step 7 meets the following requirements: