CN114745320B - Route protection method for single fault situation - Google Patents
Route protection method for single fault situation Download PDFInfo
- Publication number
- CN114745320B CN114745320B CN202210470601.3A CN202210470601A CN114745320B CN 114745320 B CN114745320 B CN 114745320B CN 202210470601 A CN202210470601 A CN 202210470601A CN 114745320 B CN114745320 B CN 114745320B
- Authority
- CN
- China
- Prior art keywords
- node
- priority
- executing
- nodes
- queue
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L45/00—Routing or path finding of packets in data switching networks
- H04L45/28—Routing or path finding of packets in data switching networks using route fault recovery
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L45/00—Routing or path finding of packets in data switching networks
- H04L45/22—Alternate routing
Landscapes
- Engineering & Computer Science (AREA)
- Computer Networks & Wireless Communication (AREA)
- Signal Processing (AREA)
- Data Exchanges In Wide-Area Networks (AREA)
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 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, reduce the message loss rate caused by network faults and further meet the requirement of the implementation application on the network availability. Therefore, the invention provides an effective solution for solving the routing availability problem for the Internet service provider.
Description
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 of the last 70 th century, the internet has entered a rapid development, and a large number of emerging applications and services have emerged on the internet, which put higher demands on 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, which is favored by the industry for its simplicity 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 can 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. For a destination node d ∈ V in the network, and rspt (d) is used to represent the reverse shortest path tree with node d as the 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 single failure situation, comprising 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, backup next hop from node m to destination node d is setSet to an empty set, i.e.: bn (m, d) = Φ, where priority (m) represents priority of node m, bn (m, d) represents backup next hop from node m to node d, V represents set of nodes in the network;
and 2, step: calculating a reverse shortest path tree (rspt) with a 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
u belongs to N (v), and an processor (u) ≠ processor (v), wherein the processor (u) represents a node with hop count of 2 in all ancestral nodes of the node u, the processor (v) represents a node with hop count of 2 in all ancestral 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 conditions that the priority (u) is more than or equal to 1 and the neighbor node v does not back up the next hop are 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 the processor (u) is the same as the processor (v), if the processor (u) ≠ processor (v), adding the node v to the backup next hop bn (u, d) = u { v } of the nodes u to d, executing step 13, and if the processor (u) = 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 } of the nodes u to d, 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 operator (u) is the same as the operator (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 representation of rspt (d) of 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.
Detailed Description
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) = priority (b) = priority (c) = priority (e) =0, setting backup next hops of the nodes as null sets, namely bn (a, d) = bn (b, d) = bn (c, d) = bn (e, d) = phi;
and 2, step: 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 M = { a, b, c, e };
step 3.2: because queue M is not empty, step 3.3 is performed;
step 3.3: when u = a, M = { b, c, e };
step 3.4: traversing neighbor nodes of the node a, wherein v = 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 = c;
step 3.5: because operator (a) = a, operator (c) = c, R = { a, c }, priority (a) = priority (c) =2;
step 3.6: since node c is not the last neighbor node of node a, step 3.4 is performed;
step 3.4: traversing neighbor nodes of the node a, wherein v = e;
step 3.6: step 3.2 is performed because node e is the last neighbor node of node a;
step 3.2: because queue M is not empty, step 3.3 is performed;
step 3.3: when u = b, M = { c, e };
step 3.4: traversing neighbor nodes of the node b, wherein v = 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 node c, wherein v = a;
step 3.5: because operator (a) = a, operator (c) = c, R = { a, c }, priority (a) = priority (c) =2;
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 = e;
step 3.5: because operator (e) = a, operator (c) = 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 = e, M = { };
step 3.4: traversing neighbor nodes of the node e, wherein v = 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 = c;
step 3.5: because operator (e) = a, operator (c) = c, R = { 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, the priority of these nodes is set to 2 and these nodes are added to a priority queue Q, when the priority queue Q = { (a, 2, id (a)), (c, 2, id (c)), (e, 2, id (e) };
and 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 = 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 = b;
and step 9: because priority (a) =2 and node b does not back up the next hop, node b is added to the priority queue, at which time priority queue Q = { (a, 2, id (a)), (c, 2, id (c)), (e, 2, id (e), (b, 0, id (b)) };
step 11: since operator (a) = operator (b), priority (a) =2, step 13 is performed:
step 13: because node a also has neighbor nodes, step 8 is executed;
and 8: traversing neighbor nodes of the node a, and storing the neighbor nodes of the node a in a variable v, wherein v = c;
and step 9: priority (c) =2, because node c is already in the queue, no operation is performed;
step 10: since the operator (a) ≠ operator (c), adding node c to the backup next hop bn (a, d) = { c } of nodes a to d;
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 = e;
and step 9: since priority (e) =0, no operation is performed:
step 11: since 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: because a backup next hop exists for nodes a through d, node a is deleted from the priority queue Q, at which time the priority queue Q = { (c, 2, id (c)), (e, 2, id (e), (b, 0, id (b)) };
step 15: step 6 is performed.
And 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 = 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 = a;
and step 9: because priority (c) =2 and node a already has a backup next hop, no operation is performed:
step 10: since the operator (a) ≠ operator (c), joining node a to the backup next hop bn (c, d) = { a } of nodes c-d;
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 = e;
and step 9: because priority (c) =2, node e is already in the queue, no operation is performed;
step 10: since the operator (e) ≠ operator (c), joining node e to the backup next hop bn (c, d) = { a, e } of nodes c to d;
step 13: since node e is the last neighbor of node c, step 14 is performed;
step 14: because a backup next hop exists for nodes c to d, node c is removed from the priority queue Q, at which time the priority queue Q = { (e, 2, id (e), (b, 0, id (b)) };
step 15: step 6 is performed.
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 = 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 = b;
and step 9: since priority (e) =2, node b is already in queue Q, no operation is performed:
step 11: since 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 = c;
and step 9: since priority (e) =2, node c already has a backup next hop, no operation is performed:
step 10: since the operator (e) ≠ operator (c), adding node c to the backup next hop bn (e, d) = { c } of nodes e-d;
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 nodes e to d, at which time the priority queue Q = { (b, 0, id (b)) };
step 15: executing the step 6;
and 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 = b;
and 8: traversing neighbor nodes of the node b, and storing the neighbor nodes of the node b in a variable v, wherein v = e;
and step 9: since priority (b) =0, no operation is performed;
step 11: since 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 the 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 = { };
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 (2)
1. A method of route protection for a single failure condition, comprising the steps of:
step 1: for nodes in the network
The destination node d belongs to V, the priority of the node m is set to 0, namely: priority (m) = priority0, setting the backup next hop from the node m to the destination node d as an empty set, namely: bn (m, d) = Φ, where priority (m) represents priority of node m, bn (m, d) represents backup next hop from node m to node d, V represents set of nodes in the network;
and 2, step: calculating a reverse shortest path tree (rspt) with a node d as a root according to a Dijkstra algorithm;
and 3, step 3: computing a set of nodes R using a reverse shortest path tree rspt (d), the nodes in the set satisfying
Wherein the operator (u) represents a node with the hop count of 2 in all ancestor nodes of the node u, the operator (v) represents a node with the hop count of 2 in all ancestor nodes of the node v, the N (v) represents a set of neighbor nodes of the node v, and the node v represents a neighbor node of the node u;
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 operator (u) is the same as the operator (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: 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;
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
The priority of the node is set to be 2, and the node is added 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 conditions that the priority (u) is more than or equal to 1 and the neighbor node v does not back up the next hop are 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 the processor (u) is the same as the processor (v), if the processor (u) ≠ processor (v), adding the node v to the backup next hop bn (u, d) = u { v } of the nodes u to d, executing step 13, and if the processor (u) = 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) = U [ v }) of the nodes u to d, 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.
2. 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:
(1) The head node of the queue 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.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210470601.3A CN114745320B (en) | 2022-04-28 | 2022-04-28 | Route protection method for single fault situation |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210470601.3A CN114745320B (en) | 2022-04-28 | 2022-04-28 | Route protection method for single fault situation |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN114745320A CN114745320A (en) | 2022-07-12 |
| CN114745320B true CN114745320B (en) | 2023-03-10 |
Family
ID=82286615
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210470601.3A Active CN114745320B (en) | 2022-04-28 | 2022-04-28 | Route protection method for single fault situation |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114745320B (en) |
Citations (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107426097A (en) * | 2017-04-24 | 2017-12-01 | 山西大学 | A kind of intra-area routes guard method based on increment SPF |
Family Cites Families (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7159211B2 (en) * | 2002-08-29 | 2007-01-02 | Indian Institute Of Information Technology | Method for executing a sequential program in parallel with automatic fault tolerance |
| US8996501B2 (en) * | 2011-12-08 | 2015-03-31 | Here Global B.V. | Optimally ranked nearest neighbor fuzzy full text search |
| US9253079B2 (en) * | 2013-10-11 | 2016-02-02 | Telefonaktiebolaget L M Ericsson (Publ) | High performance LFA path algorithms |
| US10063460B2 (en) * | 2015-09-30 | 2018-08-28 | The Mitre Corporation | Method and apparatus for shortening multi-hop routes in a wireless ad hoc network |
| CN112448900B (en) * | 2019-09-02 | 2023-05-19 | 华为技术有限公司 | Data transmission method and device |
-
2022
- 2022-04-28 CN CN202210470601.3A patent/CN114745320B/en active Active
Patent Citations (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107426097A (en) * | 2017-04-24 | 2017-12-01 | 山西大学 | A kind of intra-area routes guard method based on increment SPF |
Non-Patent Citations (7)
| Title |
|---|
| 《A Hybrid Link Protection Scheme for Ensuring Network Service Availability in Link-state Routing Networks》;Haijun Geng, Han Zhang, Xingang Shi,et.al;《JOURNAL OF COMMUNTICATIONS AND NETWORKS》;20200229;第22卷(第1期);全文 * |
| 《DC规则的高效实现方法》;张伟，李卓，耿海军，尹霞;《计算机应用研究》;20201031;第37卷(第10期);全文 * |
| 《LFA算法的一种高效实现方法》;耿海军，施新刚，王之梁，尹霞，尹少平;《软件学报》;20180313;第29卷(第12期);全文 * |
| 《PERFORMANCE EVALUATION OF FAULTNODES USING QUEUE THRESHOLD BASED ON N-POLICY PRIORITY QUEUEING MODEL》;P. Javaraian, R. Maheswar, G.R. Kanagachidambaresan.et.al;《IEEE》;20180731;全文 * |
| 《基于混合软件定义网络的单节点故障保护方法》;耿海军,王威,尹霞;《计算机科学》;20220331;第49卷(第2期);全文 * |
| 一种逐跳方式的域内单节点故障保护算法;耿海军等;《小型微型计算机系统》;20181115(第11期);全文 * |
| 基于改进Dijkstra算法的配用电通信网流量调度策略;向敏等;《计算机应用》;20180312(第06期);全文 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN114745320A (en) | 2022-07-12 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US8675493B2 (en) | Routing bandwidth guaranteed paths with local restoration in label switched networks | |
| US11848823B2 (en) | System and method to recover from link or node failure in a network | |
| JP5596149B2 (en) | Method for improving service restoration speed and path calculation element in transmission network | |
| US20020097680A1 (en) | Apparatus and method for spare capacity allocation | |
| US8036126B2 (en) | System and method for compressing internet protocol routing tables | |
| JP4968117B2 (en) | Route calculation apparatus and route calculation system | |
| US10320653B2 (en) | Route topology discovery in data networks | |
| CN114978978A (en) | Computing resource scheduling method and device, electronic equipment and medium | |
| US7218606B2 (en) | Transmission system and transmitting device | |
| CN113316918A (en) | System and method for reducing the size of a flooding topology | |
| EP3157211A1 (en) | Isis-based flooding method and device | |
| Barakabitze et al. | Multipath protections and dynamic link recoveryin softwarized 5G networks using segment routing | |
| Qiu et al. | Local restoration with multiple spanning trees in metro Ethernet networks | |
| US8750166B2 (en) | Route topology discovery in data networks | |
| CN114745320B (en) | Route protection method for single fault situation | |
| Wang et al. | Reliability as an interdomain service | |
| JP5190047B2 (en) | Detour route information creation device and detour route information creation method | |
| JP4408756B2 (en) | Route calculation system | |
| EP2923464A1 (en) | System and method for finding partially disjoint paths for spare capacity allocation in shared backup path protection for dual fiber cuts | |
| CN108712345B (en) | Distributed load balancing method based on hop-by-hop calculation | |
| CN114827010B (en) | Intra-domain route protection method based on node forwarding probability | |
| CN100525252C (en) | A searching method for message forwarding path, router and network | |
| CN115622937B (en) | Route protection method based on disjoint paths and related equipment | |
| CN116319537B (en) | Routing availability calculation method based on node sequence | |
| CN112272141B (en) | Intra-domain route protection method based on key network state |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |