CN1604558A

CN1604558A - Route iteration system and method thereof

Info

Publication number: CN1604558A
Application number: CNA031272525A
Authority: CN
Inventors: 王军
Original assignee: Huawei Technologies Co Ltd
Current assignee: Huawei Technologies Co Ltd
Priority date: 2003-09-30
Filing date: 2003-09-30
Publication date: 2005-04-06
Anticipated expiration: 2023-09-30
Also published as: CN100583806C

Abstract

This invention relates to a network path realization method and discloses a path iterate system and its method and realizes the path iterate functions and path plane gapless update and load sharing path iterate. The path iterate system comprises virtual iterate interface whose iterate interface property is a subset of the physical interface.

Description

Route iteration system and method thereof

Technical Field

The present invention relates to a method for implementing network routing, and more particularly, to a method for implementing network routing iteration through a virtual port.

Background

A Router (Router) is a network device that operates in the third layer, i.e., the network layer, of the international standard Interconnection/Open System Interconnection ("ISO/OSI") model of the international Organization for standardization, has the capability of connecting different types of networks, and is capable of selecting a data transmission path. Routers have three features: first, it operates at the network layer. The router operates at the third layer of the ISO/OSI model, the network layer, and if a packet is received, it checks the network address of the third layer, e.g., the IP address, and if the destination address is that of the local network, it forwards the packet out of the local network, if it is that of another network. Secondly, it can connect different types of networks, such as ethernet, Asynchronous Transfer Mode ("ATM") network, Fiber Distributed Data Interface ("FDDI") network, token ring network, etc. The formats and sizes of data units, frames (frames), transmitted by different types of networks are different, data is transmitted from one type of network to another type of network, Frame format conversion is necessary, and the router has the function of Frame format conversion. Third, it can select a path for data transfer. In the internet, a plurality of paths are possible from one node to another node, and the router can select a smooth and quick approach, so that the communication speed is greatly improved, the communication load of a network system is reduced, and the network system resources are saved. Routers generally have three types:

and accessing the router. An access router refers to a router device that accesses local area network users into a wide area network.

An enterprise level router. Enterprise level routers are used to connect thousands of computers within a large enterprise. Compared with an access router, an enterprise-level router supports multiple Network protocols, is fast in speed, needs to process various Local Area Network types, supports multiple protocols including Internet protocol (Internet protocol, abbreviated as "IP"), Internet Packet Exchange protocol (IPX), and the like, and also supports a firewall, Packet filtering, a large number of management and security policies, and a Virtual Local Area Network (VLAN).

And (4) backbone level routers. The internet is currently composed of dozens of backbone networks, each of which serves thousands of small networks, and backbone level routers realize the interconnection of enterprise level networks.

Inside the router there is a routing table that indicates where, if you want to go, you should go next. The router receives a data packet from a certain port, firstly removes the packet header of a link layer, namely unpacking, reads a destination IP address, then searches a routing table, if the next step of sending is determined, then packs the packet header of the link layer and forwards the data packet; if the next address cannot be determined, a message is returned to the source address and the packet is dropped.

The routing algorithm writes various information in the routing table, and the router selects the best path according to the destination to which the data packet is to arrive and sends the data packet to the next router which can reach the destination. When the next router receives the data packet, the next router also checks the destination address of the data packet, and continues to transmit the data packet to the following router by using the appropriate path. And so on until the packet reaches the final destination. This manner of forwarding from one router to another is referred to as hop-to-hop (hop-to-hop) routing, and the next router to forward is referred to as the next hop router.

The following contents are mainly contained in one routing table entry: destination address and mask, next hop array, egress interface array, and flags used by some routing protocols, e.g., flag RTS _ GATEWAY indicates a non-direct route, flag RTS _ STATIC indicates a STATIC route, etc. The destination address and the mask code are binary indexes used for searching routing table items, the next hop array and the outgoing interface array are used for specifically forwarding the message, and the IP address of the next hop router and the index of the output interface of the router are respectively stored.

Because there may be more than one path with the same cost from the current device to the destination, a plurality of next hops and egress interfaces are stored in an array form in one routing table entry, and any one of the egress interfaces can be selected for forwarding according to the requirement. These same cost outbound interfaces and next hops with different paths are referred to as equivalent routes to the destination. Generally, the next hop array in the routing table entry is filled in by each routing protocol including static routing protocol, etc. according to the address of the opposite end receiving the message, and the outgoing interface is calculated by the device itself according to the next hop. A precondition is implicit here: the elements in the next hop array are in one-to-one correspondence with the elements in the interface array, so that each next hop and egress interface pair is combined into an equivalent route. If multiple outgoing interfaces can be found from one next hop, this cannot be supported in the current implementation. This is because this premise complicates the functional requirements of other nodes that do not meet the premise, such as routing iterations under load sharing.

Generally, the next hop of the route is an opposite-end router directly connected to the device, and the so-called route iteration is that the next hop of the route is not directly connected to the current device, and thus cannot find an interface directly according to the next hop, like an ordinary Interior Gateway Protocol (IGP), i.e. an intra-domain route, such as an Open Shortest Path First Protocol (OSPF), a Routing Information Protocol (RIP), and the like, but needs to check a Routing table again by using the next hop as a destination address. If the active route, i.e. the valid route, can be found, the actual outgoing interface of the active route is used as the actual outgoing interface of the current route, and this process is called route iteration. Where the active route is referred to as a contributor, the route using a next hop lookup table is referred to as an iterative route, and the next hop looked up is referred to as a far-end next hop. Route iteration is used when configuring a static route or receiving a Border Gateway Protocol (BGP) route, because the next hop of the static route is manually configured and the next hop of the BGP route is a BGP peer connected through a Transmission Control Protocol (TCP), which may not be directly connected locally, and therefore a route iteration mechanism needs to be employed to actually take effect of the generated route. From the mechanism of route iteration, it has several characteristics different from the general route:

1. the content of the iterative route depends on the information of the contributors, and if the information of the contributors changes, the contributors do not exist or better contributors appear, the content of the iterative route also needs to be updated in real time.

2. Since there may be multiple equal-cost routes, it is possible to iterate through multiple real outbound interfaces over one far-end next hop. If all the real outgoing interfaces are accepted, the premise that the elements in the next hop array and the elements in the interface array are in one-to-one correspondence is violated, and otherwise, the load sharing function brought by the equivalent routing cannot be supported.

3. The routing iterations support recursive iterations, i.e. contributors are still iterative routes. This recursion can theoretically go on indefinitely, so that after the contributors at the lowest level change, all the above iterative routes need to be updated accordingly.

4. After supporting Virtual Private Network (VPN) extension, Routing iteration is also supported in the Private Network, and even Routing iteration of cross-Virtual Routing and Forwarding (VRF) is also supported, that is, a route to be iterated is located in one VRF, and a far-end next hop for iteration is located in another VRF.

In the current implementation, the interfaces of a router are represented by a two-level structure: a structure representing a physical interface of the router and a structure representing a logical interface of the router. The logical interface is an IP address configured on the physical interface. The physical interface is provided with a logical interface chain, which connects all logical interfaces corresponding to all IP addresses configured on the physical interface in series for fast search, and simultaneously, the logical interface also stores a pointer of the physical interface so as to find the index of the physical interface when the table entry is sent. In a route, the outgoing interface does not directly store a pointer to a physical interface, but a pointer to a logical interface.

In practical applications, the above scheme has the following problems: routing iteration can only make limited support for iterative routing in the public network, and there are many limitations on the supported functions, including:

1. when an iterative route is configured with a plurality of next hops, iteration can be performed only for the first next hop, even if the iteration is unsuccessful, and iteration cannot be performed on other next hops which can be successfully searched, for example, when the iteration of the first next hop is unsuccessful and the iteration of other next hops is successful, the route cannot be validated and is only performed by changing the sequence for configuring the next hops, but because contributors are constantly changing, the method for manually changing the configuration is difficult to adapt;

2. when the contributor can be found and the contributor has an equivalent route, the iterative route can only take the first outgoing interface from the contributor to use, but does not use the equivalent route therein, i.e. load sharing is not supported;

3. routing iteration is not supported in the private network, for example, when a Multi-hop (Multi-hop) BGP (border gateway protocol) runs in the private network, the problem of routing oscillation, namely the problem of repeated change of a routing table, which occurs when an interface fails due to occasional occurrence can be avoided, but an iteration function also needs to be supported in the private network, but the iteration function cannot be realized in the current realization;

4. routing iteration crossing the VRFs is not supported, for example, when a private network user accesses the Internet through an interface between a Provider Edge (PE) and a Customer Edge (CE), routing iteration crossing the VRFs needs to be supported, namely, an iteration route is located in the private network, and the next hop is located in the public network, so that the function is difficult to be completely supported in the current implementation.

One of the main reasons for this is that the original routing model does not take into account the above-mentioned requirements of routing iterations, which are different from those of general routes, and is based on the premise that: the next hop array in the route and the elements in the egress interface array need to be strictly in one-to-one correspondence. Such an assumption can be guaranteed when iteration is not supported, but such a correspondence exists only when load sharing is not supported after iteration is supported. This premise is difficult to satisfy if load sharing is supported. Once the premise is removed, the codes in many original places need to be modified again, which is very easy to cause system instability. Therefore, any acceptable implementation must be based on maintaining the original one-to-one relationship between the next hop and the outbound interface, which results in the routing iteration having limited support and limited functionality for the iterative routing in the public network.

Disclosure of Invention

The technical problem to be solved by the present invention is to provide a route iteration system and method thereof, which can break through the limitation of the original route model by a few changes on the original route model, realize the perfect route iteration function, and can make the kernel part maintain the original flow, and realize the function of route iteration under the seamless upgrade and load sharing of the route plane.

In order to solve the above technical problem, the present invention provides a routing iteration system, which includes a virtual iteration interface, where the attributes of the iteration interface are a subset of the attributes of a physical interface, and for a module that needs to use the physical interface and the iteration interface simultaneously, the attributes of the iteration interface and the attributes of the physical interface are completely consistent in number and nature.

The attributes of the iteration interface comprise types, states, names, reference counts, real next hop arrays and output interface arrays; and a logic interface is established on the iteration interface, and the pointer of the logic interface is stored in an output interface array of the iteration interface.

The system also comprises an iterative interface linked list module, an iterative interface operation module, an iterative interface refreshing module, an iterative interface maintenance module and a route issuing module;

the iteration interface linked list module is responsible for storing all iteration interfaces and organizing an index table for all iteration interfaces;

the iterative interface operation module is responsible for indexing the iterative interface linked list module, increasing reference count and returning a query result when a matched iterative interface is indexed, and informing the iterative interface maintenance module to establish the iterative interface when no matching is performed;

the iterative interface refreshing module is responsible for refreshing the iterative interface linked list module when other modules are called or refreshing the iterative interface linked list module at regular time;

the iterative interface maintenance module is responsible for creating an iterative interface when the iterative interface is not retrieved by the system, and deleting the iterative interface when the reference coefficient of the iterative interface is zero;

and the route issuing module is responsible for issuing the route according to the system requirement, and expanding and filling the iterative interface during issuing.

The iterative interface linked list module generates a hash table organization index table by using a hash algorithm.

The iterative interface linked list module stores hash tables with real next hops and physical interfaces as key values for all iterative interfaces, the iterative interface operation module uses each real next hop and physical interface packaged by the iterative interface as input, the key values are calculated according to a predefined hash value generating function, and the key values are matched one by one on a conflict chain of the hash table.

The iterative interface linked list module stores a hash table with the far-end next hop of the iterative route as a key value for all the iterative interfaces, the iterative interface operation module uses the far-end next hop packaged by the iterative interface as input, and the key values are calculated according to a predefined hash value generation function to be matched one by one on a conflict chain of the hash table.

The iterative interface linked list module manages two hash tables for all iterative interfaces: a first hash table taking a far-end next hop of the iterative route as a key value and a second hash table taking a real next hop and a physical interface as key values; the iteration interface operation module firstly uses the remote next hop as input, calculates key values to be matched one by one on a conflict chain of the first hash table according to a predefined hash value generation function, does not continue to search if the key values are matched, and calculates the key values to be matched one by one on a conflict chain of the second hash table according to the predefined hash value generation function by using the real next hop and the physical interface as input if the key values are not matched.

The iterative interface refreshing module obtains a direct connection next hop and a real outgoing interface from the contributor route according to a certain rule no matter whether the route changes during refreshing, and then replaces the original outgoing interface of the iterative route with all the information.

The iterative interface refreshing module firstly judges whether the route of the depended contributor changes or not during refreshing, and if the route of the depended contributor does not change, the route is not updated; otherwise, according to a certain rule, obtaining the direct connection next hop and the real output interface from the contributor route, and then replacing the original output interface of the iterative route with the information.

The iterative interface refreshing module firstly judges whether the route of the depended contributor changes or not during refreshing, and if the route of the depended contributor does not change, the route is not updated; otherwise, whether the real outbound interfaces originally selected by the iterative route are still valid in the new contributor route is checked, if the real outbound interfaces are still valid, the real outbound interfaces do not need to be replaced, and otherwise, only the real outbound interfaces which are not valid are replaced.

The invention also provides a method for starting and initializing the routing iteration in the routing iteration, which comprises the following steps:

a, searching a real outgoing interface according to an incoming next hop, if all the interfaces are the real outgoing interfaces, performing conventional routing processing, and otherwise, entering the step B;

b, inserting the route into a bidirectional linked list used in route iteration, marking an iteration interface on the route, wherein the insertion position is the position of a current iteration breakpoint pointer;

c, checking whether the route has a real output interface, if so, directly starting the route iterative processing, otherwise, starting the route iterative processing process after marking that the route can not be realized.

The invention also provides a method for route iteration processing in route iteration, which comprises the following steps:

d, judging whether the current iterative route to be processed is legal or not, if so, entering a step E, and otherwise, entering a step I;

e, respectively searching corresponding routing tables by using each next hop of the iterative route to be processed currently, and judging whether the searched route is legal or not, if so, entering step F, otherwise, entering step G;

f, stringing the searched contributors in a temporary linked list and judging whether the route needs to be updated, if so, entering a step H, otherwise, entering a step I;

g, a null pointer is strung on the temporary linked list and marks the iteration routing failure, and then step I is carried out;

h, acquiring a real outgoing interface from the contributor route, updating the iterative route, using the real interface as input to search the iterative interface, generating a corresponding logic interface, and updating the iterative route by using the information;

and I, after pointing the pointer to the next iteration route to be processed, subtracting 1 from the number of processing loops and judging whether the loops are finished, if so, finishing, and otherwise, entering the step D.

The invention also provides a method for managing the iterative interface in the routing iteration, which comprises the following steps:

j, when the system is initialized, calculating a key value according to an actual interface in an iterative interface and a direct connection next hop, and hanging the iterative interface on different conflict chains of the hash table according to the key value;

k, judging whether an iteration interface needs to be searched, if so, entering a step L, and otherwise, entering a step M;

l, calculating key values according to the transmitted real output interface information, matching the key values with the real output interfaces one by using a direct connection next hop on the corresponding conflict chain, if the key values are matched with the real output interfaces, increasing the reference count by 1 and returning a search result, and if the key values are not matched with the real output interfaces, creating a new iteration interface and hanging the new iteration interface on the corresponding conflict chain;

m judges whether the interface is updated or the route is released, if yes, the reference count of the corresponding iteration interface is reduced by 1;

and N, judging whether the reference count of the iteration interface is 0, if so, deleting the iteration interface from the hash table, otherwise, entering the step K.

The invention also provides a method for issuing the route in the route iteration, which comprises the following steps:

checking the interface type of the to-be-issued route and judging whether an iterative interface exists, if so, unfolding the iterative interface into a real outbound interface;

and the P fills the message structure by using the real output interface index information and sends the filled message structure to other modules.

Compared with the prior art, the technical scheme of the invention is different from the prior art in that a virtual routing interface-iteration interface is creatively adopted to realize routing iteration under load sharing on the premise of 'strict one-to-one correspondence of elements in a next hop array and an outgoing interface array in the routing'.

The difference of the technical scheme brings obvious beneficial effects, namely the scheme overcomes all defects in the existing routing iteration scheme, realizes routing iteration under relatively universal load sharing, and the scheme adopts an abstract data structure-iteration interface which is identical to a common interface in appearance to represent a set of a plurality of specific and real interfaces, so that the system has great flexibility and expansibility, can inherit the existing codes to the maximum extent, realizes seamless fusion of a new scheme and the original system, and can also support interfaces in other forms.

Drawings

FIG. 1 is a routing virtual interface architecture according to a preferred embodiment of the present invention;

FIG. 2 is a flowchart of initiating routing iterations and initialization according to a preferred embodiment of the present invention;

FIG. 3 is a process flow of route iteration according to a preferred embodiment of the present invention;

FIG. 4 is an iterative interface management flow according to a preferred embodiment of the present invention;

fig. 5 is a flow of route delivery according to a preferred embodiment of the present invention.

Detailed Description

In order to make the objects, technical solutions and advantages of the present invention more apparent, the present invention will be described in further detail with reference to the accompanying drawings.

First, the basic principle of the present invention is explained, and in order to support the premise that the original routing model is based on that the elements in the next hop array and the outgoing interface array in the route need strict one-to-one correspondence, the present solution uses an extensible virtual routing interface, and overcomes the disadvantages of the existing routing iteration solutions.

The method has the basic idea that concrete real output interfaces are abstracted, the real output interfaces are packaged into a virtual interface, and a universal interface model is constructed, so that the surface still conforms to the specification that only one output interface is arranged in one next hop. Other modules which need to use the routing interface only see the virtual routing interface, regardless of the specific information contained therein, and only in individual modules, such as the routing issuing module, can realize the distinction. All the operations of other modules on the routing interface are realized through a predefined interface function, so that the safety of data is ensured. When a new requirement is put forward for the routing interface, the internal implementation of the virtual interface is enriched by using the required specific information and the adaptation work of the virtual interface is carried out on the input and output boundaries of the module, while the kernel part can keep the original flow, thereby realizing the seamless upgrade of the routing plane.

The basic principles of the invention are described below in connection with a preferred embodiment of the invention.

The key to the present invention is the routing virtual interface-iterative interface, which is described in more detail below.

In the scheme of the invention, each route has two arrays: a next hop array and an egress interface array. The next hop array stores the IP address pointer of the opposite router, and for the iterative routing, the next hop is the IP address pointer of the far end next hop. And the pointer of the output interface of the equipment is stored in the output interface. From the aspect of an iterative implementation mechanism, it is possible to obtain a plurality of real outbound interfaces by looking up a routing table from one next hop, and if a real outbound interface pointer is stored in a next hop array according to the original idea, the principle that the next hop and the outbound interfaces are in one-to-one correspondence is necessarily violated. Therefore, the idea needs to be changed, whether the route is a normal route or an iterative route, the understanding of the next hop is the same, and the next hop represents the opposite end address, so that the elements in the next hop array do not need to be modified. The crux of the problem is that a plurality of real output interfaces iterated from one next hop cannot be placed at the same position of an output interface array to meet the one-to-one correspondence principle, so that the mode of storing output interface information in the output interface array needs to be modified. According to a preferred embodiment of the present invention, the plurality of real outbound interfaces are represented by an abstract structure that looks like a normal outbound interface and internally represents the plurality of iterative real outbound interfaces, thereby satisfactorily resolving such conflicts. Specifically, to support routing iteration, a plurality of real egress interfaces obtained through iteration may be encapsulated in a virtual interface data structure, i.e., an iteration interface, and then the location where the real egress interface information is originally stored in the route is replaced with the location where the iteration interface is stored, so that load sharing of the plurality of egress interfaces can be realized on the premise that the original principle is satisfied, and most of the processing flow can be kept unchanged.

In the existing solution, the pointer of the physical interface is not directly stored in the egress interface in a route, but the pointer of the logical interface. The newly created iterative interface corresponds to the physical interface of the router, and in order to keep the same with the original mechanism, a different logical interface is also created on the iterative interface as if it were the IP address on the real interface. Pointers to these logical interfaces are stored in the output interface array of the iterative route, and because the logical interfaces on the iterative interfaces and the logical interfaces on the physical interfaces both use the same data structure, and are distinguished only by one of the special labels, the iterative interface label, such a substitution is transparent to each protocol using the route. Only when the iterative route is issued to the forwarding module, the real interface and the iterative interface need to be distinguished. If the iteration interface is found, the indexes of each real interface stored in the iteration interface need to be acquired again for issuing.

In a preferred embodiment of the invention, for an iterative interface, because it is very different from a normal physical interface, the structure of the physical interface is not reused, but a new structure type is recreated. But also some basic information common to the physical interface is kept, such as type, state, name, reference count, etc., where the reference count is to keep the reference frequency of the interface to delete the interface when the reference count is zero, and two arrays to keep the real next hop and exit interfaces are added. In most cases, each routing protocol only accesses the logical interface, rarely uses the physical interface, and even if the routing protocol is used, only accesses the common information in the physical interface, and does not need to distinguish whether the structure stores the real interface or the iterative interface, so that the two-stage structure inherits the original code to the maximum extent, and the impact on other modules of the routing is reduced.

All physical interfaces are chained into a global doubly-linked list according to the size of the index. In use, a search is conducted with the interface index as the KEY (KEY). For the iteration interface, no physical interface corresponds to the iteration interface, and no corresponding index can be used. In order to solve the problem of fast positioning and reusing of the iterative interface and avoid the influence of the iterative interface on the original physical interface, the iterative interface and the real interface are not strung on the same doubly linked list, but a separate index table is additionally constructed, for example, a HASH (HASH) table is used for organization in a preferred embodiment of the invention. In use, the relevant information is employed as a KEY to index the iteration interface.

Due to the universality of the virtual interface, other forms of interfaces can be supported by adopting the scheme. For example, in an environment supporting Multi-Protocol Label Switching (MPLS), a Label Switched Path (LSP) may be virtualized as a point-to-point interface. The interface internally contains various parameters such as labels and the like representing the LSP, and the interface still represents the form of a physical interface. When the LSP is broken, it can be equivalent to that the point-to-point virtual interface fails, and the corresponding route also fails. This allows the routing established through the LSP to be supported naturally without changing the processing flow of the kernel.

The routing virtual interface architecture of one embodiment of the present invention is shown in fig. 1. Wherein, the dotted line frame is the added structure of the invention.

In a preferred embodiment of the present invention, the iterative routing system comprises: the system comprises an iterative interface linked list module, an iterative interface operation module, an iterative interface refreshing module, an iterative interface maintenance module and a route issuing module.

These modules all operate around the iterative interface linked list module.

The iteration interface linked list module is responsible for storing all iteration interfaces and organizing an index table for all iteration interfaces, wherein the stored information of the iteration interfaces comprises: the method comprises the steps of creating different logic interfaces on an iteration interface, and storing pointers of the logic interfaces in an output interface array of the iteration interface. It should be noted that, considering that different protocols define different addresses of next hops, the next hop in the table entry is a pointer pointing to an address, so as to obtain greater flexibility, for example, the requirement of Ipv6 can be met, and the IPX protocol, VPN identifier, and the like are supported. In a preferred embodiment of the present invention, a hash algorithm is used to generate the hash table organized index table. Those skilled in the art will appreciate that, in addition to the hash table, the index table may be organized in a variety of ways; when the index table is organized by using the hash table, different information can be used as the KEY for indexing, and a plurality of hash tables can be organized to facilitate query. For example, in a preferred embodiment of the present invention, the iterative interface linked list module manages two hash tables for all the iterative interfaces, which are a hash table with the real next hop and the physical interface stored in the iterative interface as KEYs and a hash table with the far-end next hop as a KEY.

The iterative interface operation module is responsible for indexing the iterative interface linked list module and returning a query result. The iterative interface operation module correspondingly has various mode indexes according to different organizations of the iterative interface hash table by the iterative interface linked list module, and the iterative interface operation module respectively uses different information as KEY, which is respectively explained as follows:

1. and taking the real next hop and the physical interface stored in the iteration interface as KEY. When the method is used, each real next hop and physical interface packaged by the iterative interface are used as input, a KEY is calculated according to a predefined hash value generating function, and the real next hop and physical output interface pairs are matched one by one on a conflict chain of a hash table, namely a table chain matched with the KEY value. If the matching is complete, the required iteration interface is generated, the structure can be reused, and only the reference count needs to be increased; otherwise, a new iterative interface structure needs to be created and then populated with the real out interface information. The method considers that the virtual interface is only encapsulation of real interface information, and is only related to a real interface without any relation with a far-end next hop, so that only the real interface information contained in the virtual interface is considered, and the far-end next hop is not considered, and the KEY value is not included in the calculation. The benefit of this approach is that the data redundancy generated by the virtual interface can be effectively reduced. Since different remote next hops may get exactly the same real outgoing interface over iterations. Thus, no matter how many next hops are at the far end, the data structures of the same virtual interface are shared. This approach is more suitable for situations where there are more remote next hops, and these remote next hops are often all limited real outgoing interfaces.

2. And taking the far-end next hop of the iterative route as KEY. When in use, the remote next hop is used for accurately matching the remote next hop stored in each iteration interface on the conflict chain. If found, the reference count is incremented and the existing virtual interface is used directly, otherwise a new data structure is created and populated with the real next hop and physical out interface pairs. This approach is more efficient. Because the routing table is queried by the remote next hop, then the real outgoing interface is obtained by the contributor route, and finally the KEY is calculated by the real outgoing interface information to search the data structure of the virtual interface, the series of operations is time-consuming, and a process is required to be performed for each route that needs iteration, and actually, most of the iteration routes are generated by the BGP protocol, and the remote next hops are all IP addresses of BGP opposite-end neighbors under the default condition, that is, the remote next hops with a large number of routes are all the same, for example, the remote next hop is an address in a network segment. Only the complex operation is needed to be carried out on the first iterative route, and the rest of the iterative routes of the same far-end next hop can directly share the virtual interface generated by the first iterative route without repeating the process. This approach is more suitable for the case where there are fewer remote next hops, and many routes share a few remote next hops.

3. Combining the two modes, managing a hash table for the far-end next hop, and hanging a plurality of iterative routes with the same far-end next hop on a double linked list. In actual use, the hash table is searched according to the far-end next hop, if hit can be achieved, it is indicated that the route is iterated by the far-end next hop, and the real outgoing interface is successfully found. Thus, the virtual interface resulting from a route that has been successfully iterated before can be used directly after the reference count is incremented. Otherwise, according to the mode 1, the real next hop and the physical interface stored in the iterative interface are used as KEY for searching again. After the iteration is successful, the route needs to be hung in another HASH table with the remote next hop as KEY, so as to facilitate the iteration processing of other subsequent routes. In a preferred embodiment of the invention, the indexing of the iterative interface is performed in this manner.

The iterative interface refreshing module is responsible for refreshing the iterative interface linked list module at fixed time, and the refreshing time is fixed by the system; this module may also be invoked by other modules to make an immediate update of the route. There are various methods of refreshing:

1. according to a certain rule, a direct connection next hop and a real outgoing interface are obtained from the contributor route, and then the information is used for replacing the original outgoing interface of the iterative route. This is the simplest to implement, it updates all routes regardless of whether the route changes, it does not need to compare the relationship between the new outgoing interface and the original outgoing interface, but it is inefficient. Since in most cases, once the far-end next hop of the iterative route is determined, those contributor routes that are relied upon are also determined. After the system is stable, the routing information changes little, and the routing information does not need to be updated repeatedly as long as the iteration is successful. However, the method ignores the situation that the updating operations are carried out at intervals, thereby wasting CPU resources and increasing the burden of the downstream module of the routing module.

2. Firstly, judging whether the route of the depended contributor is changed or not, and if not, not updating; otherwise, processing according to scheme 1. This approach may avoid the inefficient drawbacks of approach 1, but is still too coarse and still suffers from unnecessary ringing when dependent contributor routes change. For example: after the originally selected outgoing interface is closed, other outgoing interfaces are selected instead to refresh the iterative route, and then when the outgoing interfaces are restarted, the outgoing interfaces are selected again, so that the interfaces which are not closed are replaced. In fact, it is not necessary to do so because they are all equivalent routes, and there is no difference between their merits and their demerits, which is entirely a result of human choice. As long as this egress interface is not turned off, it should be used all the time, reducing the impact on the system.

3. Firstly, judging whether the route of the depended contributor is changed or not, and if not, not updating; otherwise, whether the real outbound interfaces originally selected by the iterative route are valid in the current new contributor route is checked, namely whether the new contributor route also comprises the real outbound interfaces in the iterative route, if the new contributor route still works, the real outbound interfaces do not need to be replaced, and otherwise, only the real outbound interfaces which are not valid are replaced. Therefore, the original effective real output interface is kept to the maximum extent, and only the changed parts are refreshed, so that the impact on the downstream module is reduced. This is an optimal solution.

In a preferred embodiment of the present invention, a refresh operation is performed using scheme 3.

The iterative interface maintenance module is responsible for creating and deleting iterative interfaces. For example, when the system receives a far-end next hop, the iterative interface operation module indexes the iterative interface linked list module and does not find the iterative interface of the route, the iterative interface maintenance module creates a new iterative interface in the iterative interface linked list module and informs the iterative interface refreshing module to fill the newly inserted iterative interface; when the reference count of one iteration interface is zero, the iteration interface maintenance module deletes the iteration interface.

And the route issuing module is responsible for issuing the route according to the system requirement, and expanding and filling the iterative interface during issuing. For example, in a preferred embodiment of the present invention, the module performs interface check of the route before issuing the route, and if an iterative interface is found in the route to be issued, the module expands the iterative interface, fills the iterative interface with the index information of the real outgoing interface, and then issues the route.

The process of starting routing iteration and initializing according to a preferred embodiment of the present invention is shown in fig. 2, and is executed when the system sends a next-hop request to find a route. Most of the steps of the flow are completed in the iterative interface maintenance module.

Step 110 is entered first to find the real outgoing interface based on the incoming next hop. This step is exactly the same as the existing routing module processing, i.e. the egress interface of the next hop directly connected to the route is searched.

Then, step 120 is entered, and it is determined whether all the interfaces are real outgoing interfaces, if yes, step 140 is entered, otherwise, step 130 is entered. If one interface is not the real output interface, the next hop of the interface is not directly connected with the local computer, and iteration is needed at the moment, and an iteration flow is started.

In step 130, the route is strung on a doubly linked list used within the routing iteration. Where the linked list holds all routes that have not been iterated successfully and that have been iterated successfully. The inserted position is the position of the saved current iteration breakpoint pointer so as to ensure that the route is processed immediately after the route iteration processing function is called to enter the route iteration processing flow. Step 150 is then entered.

In step 140, a general routing process is performed. At this time, since the next hop is directly connected with the local machine, the processing does not involve iterative routing, and the processing method is the same as the existing scheme. So far, it is explained that the next hop does not need to perform routing iteration, and the flow ends so far.

In step 150, the route is marked with an iteration interface. The iterative interface mark is used for distinguishing a real interface from an iterative interface so as to carry out different processing according to different interfaces when the interface processing and the routing are issued.

Then step 160 is entered, whether the route has a real outbound interface is checked, if yes, step 180 is entered, otherwise, step 170 is entered. In this step, if at least one real outbound interface can be found, it indicates that the route, although in the iterative process, can still pass through the existing real outbound interface until forwarding; otherwise, it means that the route does not have any real outbound interface and cannot be directly forwarded.

In step 170, the route is marked as unavailable. In a preferred embodiment of the present invention, the specific implementation is to change the priority of the route to a negative number, which indicates that the route cannot take effect, and prevent the system from refreshing the route and issuing it to other modules, and change the priority to a positive number to issue the entry when the iteration succeeds later. Step 180 is then entered.

In step 180, a route iteration process function is invoked. The routing iteration processing function is responsible for the processing flow of the iteration interface. When called, it is distinguished from the timing process normal to the routing iteration by the introduction of specific parameter values. Because the insertion position is exactly the current breakpoint position, that is, the pointer of the current to-be-processed iterative interface in the route iterative processing function points to the inserted new iterative interface, the newly inserted route is immediately subjected to iterative processing in the processing function. In a preferred embodiment of the invention, the incoming parameter values are empty.

And ending the flow of starting routing iteration and initializing.

The process flow of the routing iteration of a preferred embodiment of the present invention is shown in fig. 3, and is invoked at system timing or after the system initiates the routing iteration. Most steps of the flow are completed in the iterative interface refresh module.

Step 200 is entered first to obtain the number of cycles. In particular implementations, this step determines the number of loops by receiving parameters that are passed in at the time of the function call. In a preferred embodiment of the present invention, if the incoming parameter is null, it indicates that the function is not normally processed at a fixed time, but calls the function to start the iterative process when the route is increased or changed, and only needs to process the currently newly inserted route, and the cycle number is 1; otherwise, the number is the number of iterative routes to be processed in one loop in the linked list, and the number is predefined by the system and is at most 500.

Then, step 210 is entered to determine whether the current iterative route to be processed is legal, if so, step 220 is entered, otherwise, step 310 is entered. For example, if the iterative interface flag is marked on the current iterative route to be processed or the current iterative route is being deleted, it is not legal.

Step 220 is then entered to use each next hop of the iterative route currently to be processed to respectively search the corresponding routing table. In a preferred embodiment of the present invention, the system manages a hash table for the remote next hop, and all routes having the same remote next hop are hung on a doubly linked list, and the hash table is looked up with the next hop as KEY during the lookup. It should be noted that, for simplicity of explanation, the following process only discusses the search of one next hop, and it will be understood by those skilled in the art that this description does not affect the understanding and implementation of the present invention.

Then, step 230 is entered to determine whether the found route is legal, if so, step 240 is entered, otherwise, step 250 is entered. For example, in a preferred embodiment of the present invention, a determination is made as to whether it is a default route, and if so, it is not legitimate; whether it is in a deleted state, and if so, it is illegal.

In step 240, the found contributors are chained together in a temporary linked list. The linked list in this step is temporary, and is only temporarily used in the route iteration processing flow, and the flow is deleted when the flow is finished. Step 270 is then entered.

In step 250, a null pointer is strung over the temporary linked list. The null pointer indicates that the current far-end next hop of the iterative route has no corresponding contributor, i.e., the current next hop cannot find the route. Step 260 is then entered.

In step 260, the iterative routing failure is flagged. In a preferred embodiment of the invention, this step is implemented by calling a routing change handling function. Step 310 is then entered.

In step 270, it is determined whether a route update is required, if so, step 280 is entered, otherwise, step 310 is entered. This step is typically performed in conjunction with step 280.

In step 280, the true outbound interface is retrieved from the contributor route and the iterative route is updated. The step is closely related to the step 270, the step 270 has a plurality of judgment methods, the step 280 also has a plurality of updating methods, and the specific method is described in detail in the iterative interface refreshing module.

Step 290 is then entered, where the iteration interface is looked up for the input using the real interface and a corresponding logical interface is generated. The real interface in this step is obtained after updating in step 280.

Step 300 is then entered to update the iterative route. In a preferred embodiment of the present invention, this step is accomplished by calling a routing change handling function with the information obtained in step 290 as a parameter. Step 310 is then entered.

In step 310, the pointer is pointed to the next iteration route to be processed. In this step, the pointer is a pointer pointing to the current iterative route to be processed in the route iterative processing flow. In a preferred embodiment of the invention, this is done by incrementing or decrementing the pointer by a fixed value.

The process then proceeds to step 320 where the number of processing cycles is decremented by 1. This step represents one iterative route in the loop being processed.

Then, step 330 is entered to determine whether the number of cycles is 0, if yes, the process is ended, otherwise, step 210 is entered. The step is to judge whether the loop is finished or not, and if not, the next iteration routing processing is started.

And ending the route iteration processing flow.

The iterative interface management flow of a preferred embodiment of the present invention is shown in fig. 4, which is a large loop.

Step 400 is entered first, and a key value is calculated according to an actual interface and a direct next hop in an iterative interface. In a preferred embodiment of the invention, the calculation is performed according to a hash algorithm.

And then, entering a step 410, and hanging the iteration interface on different conflict chains of the hash table according to the key value. So-called collision chains, i.e., chains in which key values are the same. Step 410 and step 420 are initialization steps of the iterative interface, which organize all iterative interfaces into a hash table to facilitate future queries. It will be understood by those skilled in the art that in actual implementation, there are many ways to organize the iterative interface other than the hash table.

Steps

400 and 410 are only executed when the system initializes and establishes the iteration interface linked list module, and do not participate in the large loop.

Then, go to step 420, determine whether to search for the iterative interface, if yes, go to step 430, otherwise go to step 480. In the implementation, this step determines whether a lookup is required based on incoming messages from the system.

In step 430, a key value is calculated from the incoming real outgoing interface information. In a preferred embodiment of the present invention, the key value is calculated using the remote next hop.

Then, step 440 is performed, and the direct next hop and the real outgoing interface are used for matching one by one on the corresponding conflict chain. In a preferred embodiment of the invention, this matching is performed using a hash algorithm.

Step 450 is then entered to determine if a match is found, if so step 460 is entered, otherwise step 470 is entered. Finding a match indicates that the searched iterative interface exists, and the iterative interface can be directly referred to; otherwise, the iteration interface does not exist and needs to be additionally constructed.

In step 460, the reference count is incremented by 1 and the lookup result is returned. This step increases the reference count of the referenced iterative interface by 1, indicating that the interface is referenced more frequently and is not deleted for a while. Step 480 is then entered.

In step 470, a new iteration interface is created and hung on the corresponding conflict chain. The step of creating a new iteration interface and hanging it on the corresponding conflict chain in this step is described in detail in the process of starting routing iteration and initializing and the process of routing iteration processing. Step 480 is then entered.

In step 480, it is determined whether the interface is being updated or the route is released, if so, step 490 is entered, otherwise, step 500 is entered. In this step, the operation of updating the interface is performed by the system periodically.

In step 490, the reference count for the corresponding iteration interface is decremented by 1. Step 500 is then entered. This step indicates that the reference frequency of the iterative interface is decreasing.

In step 500, it is determined whether the reference count of the iteration interface is 0, if so, step 510 is entered, otherwise, step 420 is entered.

In step 510, the iteration interface is removed from the hash table. This step is used to delete iterative interfaces that have not been referenced for a long time to save memory space. One skilled in the art will appreciate that if the iterative interface is organized in other forms without using a hash table, deletion occurs from other forms of linked lists.

These steps are repeated to implement iterative interface management.

The route issuing process of a preferred embodiment of the present invention is shown in fig. 5, and is executed when the system requests the routing core to send a route to another module.

Step 600 is entered first to check the interface type of the route to be issued. The interfaces of the to-be-issued routes have two types: a real outbound interface and a virtual iterative interface.

Then, step 610 is entered, whether an iterative interface exists is judged, if yes, step 620 is entered, otherwise, step 630 is directly entered by skipping step 620. In this step, no matter how many real outgoing interfaces exist in the issued route, the step 620 is entered as long as at least one iterative interface in the issued route is found in the check.

In step 620, the iterative interface is unrolled as the real outbound interface. In a preferred embodiment of the present invention, this step is implemented by adding a statement of iterative interface expansion to the route issuing program of the existing routing module.

Step 630 is then entered to populate the message structure with the real outbound interface index information. The processing of this step is already present in the existing routing module and can be used directly without modification.

Step 640 is then entered for sending the populated message structure to other modules. The processing of this step is also already present in the existing routing module and can be used directly without modification.

And ending the route issuing process.

While the invention has been shown and described with reference to certain preferred embodiments thereof, it will be understood by those skilled in the art that various changes in form and details may be made therein without departing from the spirit and scope of the invention as defined by the appended claims.

Claims

1. A routing iteration system, characterized in that, the system comprises a virtual iteration interface, the attribute of the iteration interface is a subset of the attribute of the physical interface, and for the module needing to use the physical interface and the iteration interface simultaneously, the attribute of the iteration interface and the attribute of the physical interface are identical in number and nature.

2. The route iteration system of claim 1, wherein the attributes of the iteration interface comprise a type, a state, a name, a reference count, a real next hop array, and an egress interface array; and a logic interface is established on the iteration interface, and the pointer of the logic interface is stored in an output interface array of the iteration interface.

3. The route iteration system of claim 2, wherein the system further comprises an iteration interface linked list module, an iteration interface operation module, an iteration interface refresh module, an iteration interface maintenance module and a route delivery module; wherein,

4. The iterative routing system of claim 3, wherein said iterative interface linked list module uses a hashing algorithm to generate a hash table organization index table.

5. The route iteration system of claim 4, wherein the iteration interface linked list module stores hash tables with real next hops and physical interfaces as key values for all iteration interfaces, and the iteration interface operation module takes each real next hop and physical interface encapsulated by an iteration interface as input, calculates key values according to a predefined hash value generation function, and performs one-by-one matching on collision chains of the hash tables.

6. The iterative routing system of claim 4, wherein the iterative interface linked list module stores hash tables with the far-end next hop of the iterative routing as key values for all iterative interfaces, and the iterative interface operation module uses the far-end next hop encapsulated by the iterative interface as input and calculates the key values to match one by one on the collision chains of the hash tables according to a predefined hash value generation function.

7. The route iteration system of claim 4, wherein the iterative interface linked list module manages two hash tables for all iterative interfaces: a first hash table taking a far-end next hop of the iterative route as a key value and a second hash table taking a real next hop and a physical interface as key values; the iteration interface operation module firstly uses the remote next hop as input, calculates key values to be matched one by one on a conflict chain of the first hash table according to a predefined hash value generation function, does not continue to search if the key values are matched, and calculates the key values to be matched one by one on a conflict chain of the second hash table according to the predefined hash value generation function by using the real next hop and the physical interface as input if the key values are not matched.

8. The route iteration system of claim 3, wherein the iteration interface refreshing module obtains the direct connection next hop and the real outgoing interface from the contributor route according to a certain rule regardless of whether the route changes during refreshing, and then replaces the original outgoing interface of the iteration route with all the information.

9. The route iteration system of claim 3, wherein the iteration interface refreshing module first determines whether the depended contributor route changes during refreshing, and if not, the depended contributor route is not updated; otherwise, according to a certain rule, obtaining the direct connection next hop and the real output interface from the contributor route, and then replacing the original output interface of the iterative route with the information.

10. The route iteration system of claim 3, wherein the iteration interface refreshing module first determines whether the depended contributor route changes during refreshing, and if not, the depended contributor route is not updated; otherwise, whether the real outbound interfaces originally selected by the iterative route are still valid in the new contributor route is checked, if the real outbound interfaces are still valid, the real outbound interfaces do not need to be replaced, and otherwise, only the real outbound interfaces which are not valid are replaced.

11. A method for starting and initializing routing iteration in routing iteration is characterized by comprising the following steps:

12. A method for route iteration processing in route iteration is characterized by comprising the following steps:

13. A method for iterative interface management in routing iteration is characterized by comprising the following steps:

14. A method for issuing a route in route iteration is characterized by comprising the following steps: