Lightweight segmented routing optimization method applied to satellite-borne router

Abstract

The invention discloses a lightweight segmented routing optimization method applied to a spaceborne router. The method comprises the following steps: a source node is a transmitting end, a neighbor segment identifier is defined based on an improved SRv6 protocol, a bit path coding mechanism is constructed, a bitmap is obtained after coding, a neighbor forwarding table is constructed, and a data packet is sent according to the neighbor forwarding table; the intermediate node is a receiving end, a neighbor forwarding table of the intermediate node is constructed, a data packet is received, a bit sequence analysis method is executed to decode and update a bitmap in a neighbor segment identifier, the bitmap is compared with the neighbor forwarding table, and a forwarding interface and a forwarding data packet are obtained. The total length of the neighbor segment identifier is 128 bits, and the neighbor segment identifier structurally comprises an LOC field, an FUNCT field and an ARGS field; the LOC field occupies 64 bits and comprises a 4-bit CI (Consumption Identifier) and a 60-bit bitmap. According to the method, the segmented routing lightweight of satellite communication can be realized, the computing power consumption is reduced, the overhead is reduced, and the bandwidth utilization rate of inter-satellite links is improved.

Description

Technical Field

[0001] This invention relates to the field of satellite communication and routing technology, specifically to a lightweight segmented routing optimization method for use in satellite routers. Background Technology

[0002] In today's digital age, modern society and life are increasingly reliant on the driving force of network communication technology development. Satellite networking plays a significant role in the wave of information globalization. The Space-Air-Ground Integrated Network (SAGIN) is a core architecture of 6G communication. By integrating space-based (satellite), air-based (drone / high-altitude platform), and ground-based (5G / 6G / fiber) networks, it constructs a new generation of information infrastructure with seamless global coverage and three-dimensional collaboration, achieving global coverage and all-time access. It is one of the core architectures of future communication networks. Segment routing (SR), as a key technology supporting the space-air-ground integrated network, effectively meets the routing needs of complex heterogeneous network environments due to its advantages such as controllable source routing, low control traffic, and strong scalability. SRv6 segment routing (SRv6 over IPv6) is the preferred technology for SAGIN and satellite routers, enabling unified network protocols across space, air, and ground layers without protocol conversion overhead.

[0003] However, the current mainstream SRv6 protocol faces two major drawbacks in spaceborne router applications. First, it suffers from insufficient adaptability to spaceborne hardware. Satellites operate in extreme environments with high vacuum and strong cosmic radiation, and are constrained by the physical size and power consumption of their cooling systems. Therefore, spaceborne chip design must prioritize system robustness and reliability. For example, low-Earth orbit satellite constellations typically use low-power ARM architecture embedded processors, with single-core processing power only about 1 / 100th that of general-purpose terrestrial servers. In this context, the complex routing processes in the SRv6 protocol, such as hop-by-hop parsing of long sequence segment identifiers (SIDs), require frequent memory addressing and logical operations, leading to excessively high chip resource utilization and severely impacting routing efficiency. Furthermore, hardware upgrades are difficult to perform during satellite operation, requiring routing schemes with extremely low computational complexity and resource consumption. The second major drawback of the SRv6 protocol in satellite router applications is its excessive bandwidth overhead. SRv6 uses IPv6 address sequences as segment identifiers (SIDs), each requiring 128 bits. Its standard structure is a three-segment format: SRv6 SID = Locator + Function + Argument. When data is transmitted via multi-hop inter-satellite links, the routing path information incurs a header overhead of 16 times several bytes. This means a significant amount of bandwidth is wasted.

[0004] Therefore, there is an urgent need for a lightweight segment routing optimization method that adapts to the hardware characteristics of spaceborne routers and has low overhead, in order to support the space-ground collaborative routing requirements of integrated space-ground networks. Summary of the Invention

[0005] This invention aims to solve the technical problems of poor computing power adaptability and high bandwidth overhead of the traditional SRv6 protocol in the spaceborne environment, and provides a lightweight segmented routing optimization method for spaceborne routers.

[0006] In the SAGIN integrated space-air-ground network, satellites or other spacecraft are mapped as nodes, and onboard routers are installed on the satellites or other spacecraft. The lightweight segmented routing optimization method applied to the onboard routers includes:

[0007] The source node is the transmitter. Based on the improved SRv6 protocol, it defines the neighbor segment identifier NB-SID, constructs a bit path encoding mechanism, obtains a bit map after encoding, constructs the neighbor forwarding table NBFT, and sends data packets according to the neighbor forwarding table NBFT.

[0008] The intermediate node is the receiving end. It constructs the Neighbor Forwarding Table (NBFT) of the intermediate node, receives data packets, performs bit sequence parsing to decode them, updates the bitmap and IPv6 destination address in the Neighbor Segment Identifier (NB-SID), compares the bitmap with the Neighbor Forwarding Table (NBFT) to obtain the forwarding interface, and forwards the data packets.

[0009] Furthermore, the source node is the transmitter, and its signal encoding and transmission processing includes:

[0010] S1: Improve the SRv6 protocol, define the neighbor segment identifier NB-SID, construct a satellite bit path encoding mechanism, obtain the bitmap in the neighbor segment identifier NB-SID, encapsulate the neighbor segment identifier NB-SID into the SRv6 header and replace the SID list;

[0011] S2: Obtain satellite network topology information, construct and store the Neighbor Forwarding Table (NBFT), and send data packets based on the NBFT.

[0012] The intermediate node is the receiving end, and its specific process of receiving, decoding, and forwarding signals includes:

[0013] S3: Construct the neighbor forwarding table of the intermediate node, receive data packets, parse the route order, verify the route integrity, and obtain the complete bitmap;

[0014] S4: Perform a bitwise AND operation between the complete bitmap and the bitmap of this node to determine whether the local node is a node in the routing path;

[0015] S5: If the local node is a node in the routing path, then perform an XOR operation between the complete bitmap and the bitmap of the local node to generate the remaining bitmap and update the bitmap in the neighbor segment identifier NB-SID.

[0016] S6: Compare the bitmap in the updated neighbor segment identifier NB-SID with the neighbor forwarding table NBFT to obtain the forwarding interface and forward the data packet.

[0017] Furthermore, the total length of the Neighbor Segment Identifier (NB-SID) is 128 bits, and the field allocation strictly follows the SRv6 protocol. The structure of the Neighbor Segment Identifier (NB-SID) includes a Locator Field (LOC), a Function Command Field (FUNCT), and a Parameter Field (ARGS). The Locator Field (LOC) occupies 64 bits, which includes a 4-bit continuation identifier (CI) and a 56-bit variable-length bitmap.

[0018] Furthermore, based on the continuation identifier (CI) in the neighbor segment identifier (NB-SID), the carrying capacity of the neighbor segment identifier (NB-SID) is extended, specifically including:

[0019] The continuation identifier CI field is a 4-bit binary number with two states. When CI=0001, it indicates that the bitmap of the current neighbor segment identifier NB-SID needs to be concatenated with the bitmap of the subsequent neighbor segment identifier NB-SID. The specific method for concatenating the neighbor segment identifier NB-SID across segments is as follows: the previous neighbor segment identifier NB-SID is split into three segments. The first segment of the neighbor segment identifier carries the first 60 bits, CI=0001. The second segment of the neighbor segment identifier carries the middle 60 bits, CI=0001. The third segment of the neighbor segment identifier carries the last 30 bits, CI=0000.

[0020] When CI=0000, it means that the bitmap of the current neighbor segment identifier NB-SID is the terminating segment of the complete path;

[0021] When the satellite router receives the NB-SID sequence of neighbor segments, it stitches the bitmaps of each segment into a complete bitmap in the order of reception.

[0022] Furthermore, a satellite bit path encoding mechanism is constructed to obtain a bitmap, which specifically includes:

[0023] To identify a single node, a binary sequence of the same length as the bitmap is used, with the position representing the local node represented as 1 and the rest represented as 0, forming a bitmap for each node.

[0024] The routing path is encoded as follows:

[0025] The source node calculates the initial route path, and SAPP uses a route mapping algorithm based on the shortest path principle to modify the corresponding route path and obtain the final route path;

[0026] Based on the final routing path, extract the bitmap corresponding to each node on the path, and perform a bitwise OR operation to generate a bitmap.

[0027] Furthermore, the Neighbor Forwarding Table (NBFT) is stored in the cache of the satellite router and includes local bitmap entries and neighbor bitmap entries. The local bitmap entries use the current node's bitmap as the key for local node identification. The neighbor bitmap entries use the adjacent node's bitmap as the key to associate with the inter-satellite link physical port. Each node can learn the mapping relationship between the neighbor node's bitmap and the forwarding port by querying the Neighbor Forwarding Table (NBFT).

[0028] The beneficial effects of this invention are:

[0029] 1. Traditional SRv6 uses a 128-bit IPv6 address as the segment identifier (SID), with a path header overhead of 128 bits multiplied by the hop count. This invention uses satellite bit path encoding to transform path information into a bitmap matching the satellite network scale, reducing header overhead to only the number of bits required for the satellite network. Given the scarcity of computing resources on satellite chips, this invention combines bit sequence encoding with a simplified parsing process, transforming the IPv6 address sequence parsing of traditional SRv6 into bitmap bit operations (AND / XOR), significantly reducing computational complexity. In a topology with 2000 satellites, the routing header overhead of this invention is reduced by 43.51% compared to SRv6; in a small-scale network with 100 satellites, the header overhead of a 3-hop path is reduced from 48 bytes to 12.5 bytes, a reduction of 78.12%, thus reducing the bandwidth consumption of routing control information.

[0030] 2. Traditional SRv6 long sequence SID resolution requires traversing the IPv6 address list hop by hop, and the resolution latency increases linearly with the number of hops. This invention uses a bit sequence resolution method, which is a fixed 4-step bit operation, and the resolution latency is independent of the number of path hops. Compared with traditional SRv6, this invention significantly reduces the resolution latency, which can support the transmission requirements of low-latency services in satellite networks such as satellite IoT and emergency communications, and expands the service adaptability range of satellite routers.

[0031] In summary, this invention addresses the hardware constraints of spaceborne routers and the routing requirements of integrated air-space-ground networks. By designing a neighbor segment identifier (NB-SID), constructing satellite bit path encoding, and executing a bit sequence parsing method, it achieves lightweight optimization of the traditional SRv6 protocol, reducing computational power consumption and storage overhead; improving inter-satellite link bandwidth utilization and saving scarce inter-satellite bandwidth; and enhancing the real-time performance of spaceborne routing to support low-latency service requirements. Attached Figure Description

[0032] Figure 1 A schematic diagram illustrating the application scenarios of an integrated air-space-ground network;

[0033] Figure 2 This is a flowchart illustrating the steps of an embodiment of the present invention;

[0034] Figure 3 This is a schematic diagram of the neighbor segment identifier NB-SID in an embodiment of the present invention;

[0035] Figure 4 This is a schematic diagram of the satellite network topology with 9 nodes in an embodiment of the present invention;

[0036] Figure 5 This is a diagram showing the parameter configuration of the routing mapping algorithm in this embodiment of the invention;

[0037] Figure 6This is an example of the NBFT neighbor forwarding table of node S5 in this embodiment of the invention;

[0038] Figure 7 This is a schematic diagram of the process of parsing data packets at the receiving end in an embodiment of the present invention. Detailed Implementation

[0039] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0040] Reference Figure 1 As shown, the Space-Air-Ground Integrated Network (SAGIN) comprises three layers: a space-based network (satellites or other aircraft), an air-based network (drones, high-altitude platforms, etc.), and a ground-based network (5G / 6G / fiber optics). The space-based network includes low-Earth orbit (LEO) satellites, medium-Earth orbit (MEO) satellites, geostationary orbit (GEO) satellites, other spacecraft, and inter-satellite links. On-Board Routers (OBRs) are high-performance network devices deployed on satellites or other spacecraft within the space-based network. They are the core hubs of the SAGIN network, responsible for interconnecting intra-satellite devices, facilitating inter-satellite link communication, and exchanging data between space and ground. Through dynamic routing and intelligent scheduling, they achieve autonomous networking and efficient transmission of the space network. SRv6 segment routing (SRv6) is the preferred technology for SAGIN and on-board routers. This invention improves upon the SRv6 segment routing protocol to achieve lightweight segment routing optimization.

[0041] SRv6 is a next-generation IP transport protocol that integrates segment routing (SR) and IPv6. SRv6 uses a native IPv6 forwarding plane and enables network programmability through IPv6 extension headers. Its core is a source routing mechanism, where the complete forwarding path is specified by the starting or source node, and intermediate nodes forward data only according to the path information, without needing to maintain complex state. In traditional SRv6 protocols, IPv6 lists are used to represent paths, with each node in the path occupying 128 bits. The core components of SRv6 include: Segment Identifier (SID), Segment Routing Header (SRH), Locator, Function, and Argument. SID is a 128-bit IPv6 address representing a "segment" in the network, which can identify a node, interface, or specific operation; SRH is the IPv6 extension header (Type 4), carrying an ordered list of SIDs, an activity index, and metadata to guide packet forwarding; Locator is the prefix part of the SID, used for routing to the target node, similar to the network prefix of an IP address; Function is the middle part of the SID, defining the operation that the node performs after receiving a packet, such as forwarding, encapsulation, and decapsulation; Argument is the suffix part of the SID, providing specific parameters for the function and enhancing programmability.

[0042] This invention proposes a lightweight segmented routing optimization method for spaceborne routers, such as... Figure 2 As shown, the method includes:

[0043] The source node (or initial node) is the transmitter. Based on the improved SRv6 protocol, it defines the neighbor segment identifier NB-SID, constructs a bit path encoding mechanism, obtains a bit map after encoding, constructs the neighbor forwarding table NBFT, and sends data packets according to the neighbor forwarding table NBFT.

[0044] The intermediate node is the receiving end. It constructs the Neighbor Forwarding Table (NBFT) of the intermediate node, receives data packets, performs bit sequence parsing to decode them, updates the bitmap and IPv6 destination address in the Neighbor Segment Identifier (NB-SID), compares the bitmap with the Neighbor Forwarding Table (NBFT) to obtain the forwarding interface, and forwards the data packets.

[0045] The source node (or initial node) is the transmitter, and its signal encoding and transmission processing includes:

[0046] S1: Improve the SRv6 protocol, define the Neighbor Segment Identifier (NB-SID), construct a satellite bit path encoding mechanism, obtain the bitmap in the Neighbor Segment Identifier (NB-SID), encapsulate the Neighbor Segment Identifier (NB-SID) into the SRv6 header and replace the SID list.

[0047] Step S1 specifically includes:

[0048] S101: Improved SRv6 protocol, defining neighbor segment identifier NB-SID.

[0049] In the traditional SRv6 protocol, each node in the path is represented by a complete SID. Each node has a corresponding function instruction field (or FUNCT field) and parameter field (or ARGS field). FUNCT:ARGS is a unique instruction for a single node. The functions of different nodes need to be encoded separately into their respective SIDs, which is highly redundant and will cause field waste.

[0050] The embodiments of the present invention improve the original SRv6 protocol. The core of the improvement is to replace the SID list (or Segment list) part in the traditional SRv6 extension header with the bitmap-type neighbor segment identifier NB-SID.

[0051] Reference Figure 3 As shown, the total length of the Neighbor Segment Identifier (NB-SID) is 128 bits, and the field allocation strictly follows the SRv6 protocol specification. The structure of the NB-SID includes: a LOC field, a FUNCT field (functional instruction), and an ARGS field (auxiliary parameters). The LOC field corresponds to the locator of the core SRv6 component, the FUNCT field corresponds to the function of the core SRv6 component, and the ARGS field corresponds to the argument of the core SRv6 component. The LOC field occupies 64 bits, divided into a 4-bit continuation identifier (CI) and a 60-bit bitmap. The length of the bitmap can be dynamically adjusted according to the satellite network topology, and each bit uniquely maps to a satellite node in the network. The FUNCT field occupies 32 bits, uses SRv6 standard function instruction encoding, supports core functions such as multicast forwarding, traffic slicing, and priority scheduling, and the instruction encoding is fully compatible with the SRv6 ecosystem, allowing direct reuse of existing function definitions. The ARGS field occupies 32 bits and is used to carry auxiliary parameters corresponding to the FUNCT field, such as multicast group identifier, forwarding priority, etc. When there are no auxiliary parameters, it is filled with 0, that is, ARGS=0.

[0052] In the neighbor segment identifier (NB-SID) of this invention embodiment, one or more concatenated neighbor segment identifiers (NB-SID) correspond to the entire routing path. Here, FUNCT:ARGS is a general instruction for the routing path. It eliminates the need to assign a dedicated SID to each individual node. Instead, through a mechanism of "path-level FUNCT:ARGS unified instruction + node-local NBFT + bit sequence parsing method," each node identifies its role in the path and executes the corresponding function.

[0053] S102: Based on the improved SRv6 protocol, a satellite bit path encoding mechanism is constructed to obtain the bitmap in the neighbor segment identifier NB-SID.

[0054] Specifically, in the traditional SRv6 protocol, an IPv6 list is used to represent the path, with each node in the path occupying 128 bits. However, this embodiment of the invention uses a binary sequence whose length matches the number of satellites (or other spacecraft) in the space-based network. Each bit uniquely identifies a satellite (or other spacecraft) and serves as its index, called a bitmap. Using a binary sequence of the same length as the bitmap, positions representing local nodes (satellites or other spacecraft) are represented as 1, and the remaining positions as 0; this binary sequence is called a bitmap.

[0055] Node encoding is achieved through bitmaps, specifically including:

[0056] Identifying a single node (satellite or other spacecraft): Using a binary sequence of the same length as the bitmap, the position representing the local node is represented as 1, and the rest are represented as 0, forming a bitmap for each node.

[0057] Routing path encoding is implemented using bitmaps, specifically including:

[0058] (1) The source node calculates the initial route path. Based on the shortest path principle, SAPP uses the route mapping algorithm to modify the corresponding route path and obtain the final route path.

[0059] Reference Figure 4 As shown in the diagram, in a satellite network topology with 9 nodes, S1-S9 represent nodes (satellites or other spacecraft). Assume the initial routing path is calculated by the Inter-Satellite Interior Gateway Protocol (IGP) based on the network topology and metrics (such as bandwidth and latency) from the source node. (i.e., S5) to the finish line The initial path of (i.e., S1) is S5→S8→S7→S4→S1, and the corresponding bitmap is 100110110.

[0060] According to the bit sequence parsing method, when forwarding data packets, node S5 compares the bitmap with its local neighbor forwarding table NBFT to determine the two outgoing interfaces, corresponding to... Figure 4The P4 and P2 interfaces of S5 can cause ambiguity in packet forwarding by S5. S5 cannot determine a unique outgoing interface. If S5 forwards from both P4 and P2 simultaneously, it will cause packet duplication, wasting inter-satellite link bandwidth. If S5 randomly selects an interface, it may deviate from the preset route, resulting in mistransmission of packets or delays or excessive packet loss rates upon arrival at the destination. If S5 discards packets due to ambiguity, it will directly cause communication interruption. The root cause is that the initial path in this scenario violates the shortest path principle (SAPP principle). In S5's RNFT, P4 corresponds to neighbor S8 and P2 corresponds to neighbor S4. The fact that two outgoing interfaces can be matched indicates that there is a "direct link between non-adjacent nodes" in the path, such as S5 and S4 being directly connected. However, the initial path detours through S8 and S7, causing the modified bitmap to still be able to match two forwarding entries simultaneously. The initial path S5→S8→S7→S4→S1 needs to be corrected to S5→S4→S1 using a routing mapping algorithm, so that the corrected bitmap matches only one forwarding entry (only interface P2 corresponds to S4). Only after eliminating ambiguity can forwarding proceed normally.

[0061] It should be noted that the shortest path principle (i.e., the SAPP principle) is an idempotent semiring algebraic path problem (SAPP). It is an important special case of the algebraic path problem (APP), and the shortest path problem is a typical application scenario of SAPP in routing calculation in communication networks.

[0062] The routing mapping algorithm traverses path segments, detects direct links between non-adjacent nodes, replaces detour segments in the path with direct links, and generates a path that satisfies the SAPP constraint while keeping the starting and ending points unchanged.

[0063] The core routing path constraint of the Shortest Adjacent Path (SAPP) principle is:

[0064] For any routing path Any non-adjacent node and There is no direct link between them (i.e., link cost). This ensures that only one legitimate neighbor node matches when the satellite router forwards data.

[0065] The route mapping algorithm, based on the Shortest Path Approach (SAPP), is used to modify the route path. The specific process includes:

[0066] Step a: Construct the topology graph G=(V,E) of the space-based network, where V is the set of satellite nodes and E is the set of direct links between nodes;

[0067] Step b: Based on the space-based network topology G=(V,E), calculate the original routing path. , ,in, Indicates the starting point. Indicates the source node, , Indicates the destination. Indicates the destination node or the end point. , This represents the k-th intermediate node. ( ), where n represents the number of nodes (i.e., satellites or other spacecraft) in the space-based network. This represents the first intermediate node.

[0068] Step c: Calculate the cost matrix T of the inter-satellite communication link between any two nodes. ,use Indicates the first Nodes With the Nodes Inter-communication link cost, , Represents any non-adjacent node With nodes There is no direct link between them;

[0069] Step d: Calculate the first Nodes Next hop identifier In the original path ( ).

[0070] Step e: Traverse all node pairs from the source node to the destination node in the order of the path nodes. Detect the presence of "nodes" The next hop is not a node But the cost matrix "Detour segment"; if a detour segment is detected, the node will be... The next hop is directly corrected to the node. Delete intermediate detour nodes and generate a valid path that conforms to SAPP constraints.

[0071] SAPP core constraint: the routing path from the source node to the destination node. ,satisfy:

[0072] ;

[0073] The characteristics of the output path are:

[0074] Keep the starting and ending points unchanged: , ;

[0075] Satisfying SAPP constraints: ;

[0076] in, Indicates the output path. Indicates the starting point of the output path. Indicates the endpoint of the output path.

[0077] The relevant parameter configurations of the routing mapping algorithm in this embodiment of the invention are as follows: Figure 5 As shown.

[0078] (2) Based on the final route path, extract the bit map corresponding to each node on the path and perform a bit OR operation to generate a bit map.

[0079] Reference Figure 4 As shown, the bit allocation method is specified. In the satellite network topology diagram with 9 nodes, a 9-bit bitmap is fixedly allocated to the satellite (or other spacecraft). Counting from the left, we can assume that S1 is allocated as the first bit, resulting in bitmap 100000000. Similarly, S2 is allocated as the second bit as 010000000, S5 as 000010000, and so on.

[0080] The encoding is stored in binary form in the onboard router.

[0081] For any path P=(S1→S2→S5), first extract the single-node bit map of S1 (100000000), S2 (010000000), and S5 (000010000), then perform a bitwise OR operation to obtain bit map 110010000.

[0082] The length of the bitmap is only related to the size of the satellite network. If the network has 200 satellites, the bitmap only needs 200 bits, regardless of whether the path hop count is 3 or 10. In contrast, the traditional SRv6 requires 128 bits multiplied by the number of hops, and the overhead of a 10-hop path is 6.4 times that of this invention.

[0083] The bit path encoding mechanism assigns a unique bit to each node in the network to represent the node in the bitmap. It uses bitmap indexes to express routing paths. Compared with the traditional SRv6 protocol, which uses IPv6 lists to represent paths, using bitmaps can reduce the header space of data packets, achieve lightweight routing information encapsulation, reduce inter-satellite link bandwidth usage, and improve transmission efficiency.

[0084] When the size of the satellite network exceeds the bitmap carrying capacity of a single neighbor segment identifier NB-SID, such as more than 4,000 satellites, it is necessary to expand the bitmap across segments.

[0085] Furthermore, the carrying capacity of the NB-SID is expanded based on the continuation identifier (CI) in the neighbor segment identifier NB-SID.

[0086] Reference Figure 3 As shown, the continuation identifier CI field has 4 bits. When CI is defined as 0000, it indicates that the bitmap is terminated, that is, the bitmap of the current neighbor segment identifier NB-SID is the last segment of the complete routing path; when CI is defined as 0001, it indicates that the bitmap is continued, that is, the bitmap of the current neighbor segment identifier NB-SID is only a part of the routing path and needs to be spliced ​​with the bitmap of the subsequent neighbor segment identifier NB-SID.

[0087] The process of splicing neighboring segment identifiers (NB-SIDs) across segments is as follows:

[0088] When the bitmap length is 150 bits, the 60-bit bitmap of a single neighbor segment identifier NB-SID cannot carry it and needs to be split into 3 NB-SID segments: segment 1 CI=0001 (carrying the first 60 bits), segment 2 CI=0001 (carrying the middle 60 bits), and segment 3 CI=0000 (carrying the last 30 bits). When the satellite router receives the neighbor segment identifier NB-SID sequence, it splices the bitmaps of each segment into a complete 150-bit bitmap according to the receiving order. The splicing process only needs to cache the bitmap segments in order and does not require additional parsing logic.

[0089] For example, a 150-bit bitmap requires 3 neighbor segment identifiers (NB-SIDs), totaling 3 × 128 = 384 bits; while the traditional SRv6 requires 150 segment identifiers (SIDs), totaling 150 × 128 = 19200 bits; the overhead is significantly reduced by using the embodiments of the present invention.

[0090] S103: Encapsulate the neighbor segment identifier NB-SID into the SRv6 header and replace the SID list.

[0091] This step encapsulates the NB-SID (Neighbor Segment ID) into the original SID list (Segment list) portion of the SRv6 header, replacing the SID list to convey routing path information. The NB-SID is significantly shorter than the SID list, effectively compressing the space occupied by the SRv6 extension header.

[0092] S2: Obtain satellite network topology information, construct and store the Neighbor Forwarding Table (NBFT), and send data packets based on the NBFT.

[0093] It should be noted that the Neighbor Forwarding Table (NBFT) is the core support for the satellite router to realize the resolution of the neighbor segment identifier NB-SID. Each node in the satellite network needs to build its own Neighbor Forwarding Table (NBFT). The specific method for each node to build its own Neighbor Forwarding Table (NBFT) is the same, only the results of the constructed Neighbor Forwarding Table (NBFT) are different.

[0094] The Neighbor Forwarding Table (NBFT) is stored in the cache of the onboard router and includes local bitmap entries and neighbor bitmap entries. The local bitmap entries use the current node bitmap as the key for local node identification. The neighbor bitmap entries use the adjacent node bitmap as the key to associate with the physical port of the inter-satellite link. The NBFT is automatically updated through topology update packets issued by the centralized control node along with the establishment, disconnection or switching of the inter-satellite communication link.

[0095] Each node learns the mapping relationship between the neighbor node's bitmap and the forwarding port by querying the Neighbor Forwarding Table (NBFT). The NBFT is the bridge connecting the NB-SID bitmap resolution of the neighbor segment identifier with route forwarding.

[0096] Based on the satellite network topology information obtained from the Interior Gateway Protocol (IGP), a Neighbor Forwarding Table (NBFT) is constructed. The specific process is as follows:

[0097] S201: Satellite network topology information obtained according to the inter-satellite internal gateway protocol.

[0098] Specifically, the onboard router uses a dedicated inter-satellite IGP protocol, such as an inter-satellite OSPF variant adapted to the dynamic satellite topology, to exchange routing information with other satellite nodes in the entire network, synchronously obtain the direct adjacency topology table of satellite nodes, that is, the list of all directly connected nodes of a certain satellite node, and synchronize the inter-satellite IGP topology.

[0099] S202: Based on the satellite network topology information, extract the segment identifier (SID) and bit map of each local node and neighbor node in the satellite network, and generate the corresponding neighbor forwarding table (NBFT).

[0100] Based on the topology information synchronized by IGP, the node bit map corresponding to the current satellite router is extracted to generate the local node type of NBFT; the bit map of all directly adjacent satellite nodes of the current node is extracted from the topology information, and the inter-satellite link physical ports corresponding to these neighboring nodes are associated to generate the neighboring node type of NBFT.

[0101] The generated local node type and neighbor node type are stored in the routing table storage area of ​​the satellite router; when the IGP synchronizes to the topology change (such as the disconnection / addition of inter-satellite links), the neighbor node type of NBFT is automatically updated to ensure that it is consistent with the actual network topology.

[0102] The Neighbor Forwarding Table (NBFT) uses a core key-value pair structure of "bit map (key), function command / forwarding information (value)". It contains only two types strongly associated with path coding: local node type and neighbor node type. The key for the local node type is the local node's bit map, such as 000010000 for satellite S5. The value for the local node type is the local identification and verification command, used to trigger the verification process of "whether the data packet has arrived at the current node". The key for the neighbor node type is the bit map corresponding to the local node's directly adjacent satellite node.

[0103] Reference Figure 4 As shown in the satellite network topology diagram with 9 nodes, the bitmap corresponding to the neighbor node S2 of node S5 is 010000000, which represents the inter-satellite link forwarding port number corresponding to the neighbor node, used to specify the next-hop transmission port of the data packet. Figure 6 The neighbor forwarding table NBFT representation is given using node S5 as an example.

[0104] S203: Each node parses the complete bitmap from the data packet, calls the bitmap (key) of the neighbor forwarding table NBFT, performs a bitwise AND operation, determines the forwarding port, and sends the data packet.

[0105] The Neighbor Forwarding Table (NBFT) functions as follows: After parsing the complete bitmap from the data packet, the onboard router calls the local node bitmap in the NBFT and performs a bitwise AND operation between the complete bitmap and the local node bitmap. If the result is non-zero, the data packet is considered to have reached the current node; if the result is zero, the non-local data packet is discarded to avoid invalid processing. After successful local identification, the bitmap is modified to generate the remaining bitmap. The onboard router then performs a bitwise AND operation between the remaining bitmap and the bitmaps of all neighbor nodes in the NBFT, matching the neighbor node with a non-zero result (i.e., the next-hop node in the remaining path), and forwards the data packet to the next-hop node through the forwarding port corresponding to that node.

[0106] Reference Figure 7 As shown, the intermediate node is the receiving end, and its specific process of receiving, decoding, and forwarding data packets includes:

[0107] Although the bit path encoding mechanism provides lightweight encoding for the path, it primarily presents the composition information of the nodes in the path. The specific order of the nodes is determined by the bit sequence resolution method. Through the collaboration of the Neighbor Forwarding Table (NBFT) and the bit sequence resolution method, accurate retrieval of the routing order and packet forwarding are achieved.

[0108] Reference Figure 7 As shown, the bit sequence parsing method follows four steps: stitching the bitmap, local identification, modifying the bitmap, and issuing a forwarding instruction.

[0109] S3 bitmap stitching: Construct the neighbor forwarding table of intermediate nodes, receive data packets, parse the routing order, verify the integrity of the routes, and obtain the complete bitmap.

[0110] Step S3 specifically includes:

[0111] The specific method for constructing the neighbor forwarding table by intermediate nodes is the same as that for constructing the neighbor forwarding table by source nodes, only the results are different, so it will not be repeated here.

[0112] After receiving data packets, the interface of the intermediate node in the satellite network extracts the Neighbor Segment Identifier (NB-SID) from the header of the received data packets and focuses on the LOC field.

[0113] The LOC field is split as follows: the first 4 bits are the continuation identifier (CI), and the remaining part is a segmented bitmap of the current neighbor segment identifier NB-SID.

[0114] Check the current CI value. If CI = 0001, the next neighbor segment identifier (NB-SID) needs to be concatenated. Extract the next neighbor segment identifier (NB-SID) from the data packet, split its LOC field segment bitmap, and append it to the end of the previous segment bitmap. Repeat this step until a neighbor segment identifier (NB-SID) with CI = 0000 is encountered. If CI = 0000, stop the concatenation process.

[0115] Integrity verification: Verify whether the length of the spliced ​​bitmap is consistent with the satellite network topology. If the length does not match (e.g., CI=0001 but no subsequent neighbor segment identifier NB-SID), it is determined that the bitmap is missing, triggering packet dropping and reporting an error.

[0116] The core objective and function of step S3 is to parse the LOC field of the neighbor segment identifier NB-SID in the data packet, determine whether it is necessary to concatenate across multiple neighbor segment identifiers NB-SID based on the continuation identifier (CI), and finally generate a complete bitmap.

[0117] S4 Local Identification: Perform an AND operation between the complete bitmap and the local node's bitmap to determine whether the local node is a node in the routing path.

[0118] Step S4 is as follows:

[0119] S401 Obtain Local Matching Baseline: Read the Neighbor Forwarding Table (NBFT) of this node (e.g., S5) and extract the bit map (key) of the local node type.

[0120] S402 Bitwise Operation Matching Judgment: Perform a bitwise AND operation between the complete bitmap and the bitmap (key) of the local node type. If the result is the same as the bitmap (key) of the local node, it means that this node is a node in the routing path, and proceed to the next step; if the result is different from the bitmap (key) of the local node, it means that this node is not in the routing path, and it is determined to be a routing error, and the data packet is discarded.

[0121] The core objective and function of step S4 is to match the local entries of the NBFT forwarding table of the current node through bitwise operations to confirm whether the current node (satellite or other spacecraft) is a necessary node in the path, thus providing a basis for subsequent forwarding.

[0122] S5 Bitmap Modification: If the local node is a node in the routing path, the complete bitmap is XORed with the bitmap of the local node to generate the remaining bitmap, and the bitmap in the neighbor segment identifier NB-SID is updated.

[0123] Step S5 is as follows:

[0124] S501 performs bitwise operation update: Based on the successful matching result of step S4, that is, the local node is a node in the routing path, a bitwise XOR operation is performed on the complete bitmap and the bitmap (key) of the local node type. The XOR operation only sets the bit corresponding to the local node from 1 to 0, while the other bits remain unchanged.

[0125] S502 updates the neighbor segment identifier NB-SID and determines the destination: The XOR operation result is written back to the segment bitmap part of the LOC field of the neighbor segment identifier NB-SID, replacing the original segment bitmap. The updated bitmap is checked to see if all bits are 0. If all bits are 0, it means that all nodes in the path have been processed, the data packet has reached the final destination, and the subsequent process is terminated (no forwarding is required); if there are non-zero bits, the forwarding decision step is entered.

[0126] The core objective and function of step S5 is to remove the bit identifier of this node through bit operations, generate the remaining bitmap, avoid subsequent nodes from repeatedly processing this node, and update the bitmap information in the neighbor segment identifier NB-SID.

[0127] S6 generates forwarding decisions: It compares the bitmap in the updated neighbor segment identifier NB-SID with the neighbor forwarding table NBFT to obtain the forwarding interface and forward the data packet.

[0128] Step S6 is as follows:

[0129] S601 Traversal Forwarding Entry Matching: Read all neighbor node entries in the local node's neighbor forwarding table NBFT, and perform a bitwise AND operation on the bitmap in the updated neighbor segment identifier NB-SID and the bitmap (key) of each neighbor node one by one. The result is recorded as B1.

[0130] S602 Matching Result Processing: Since the source node follows the shortest path principle (SAPP) and is constrained by the routing mapping algorithm when planning the path, if a neighbor node is matched successfully, there is one and only one neighbor node that is matched successfully. That is, there exists one and only one forwarding entry that satisfies that B1 is the same as the bit map (key) of the neighbor node. The neighbor node corresponding to the entry is determined as the next hop. The SID corresponding to the entry is queried, the IPv6 destination address is modified to this SID, and the data packet is submitted to the outgoing port corresponding to the entry for forwarding.

[0131] If no entry meets the matching criteria, the packet is determined to be "next hop unreachable", the packet is discarded and a routing error is reported.

[0132] The core objective and function of step S6 is to match the bitmap in the updated neighbor segment identifier NB-SID with the forwarding entry in the neighbor forwarding table NBFT to uniquely determine the next-hop node and the corresponding outgoing port, thereby achieving unambiguous forwarding of data packets.

[0133] Those skilled in the art will understand that all or part of the steps in the various methods of the above embodiments can be implemented by a program instructing related hardware. The program can be stored in a computer-readable storage medium, which may include ROM, RAM, disk, or optical disk, etc.

[0134] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. A lightweight segmented routing optimization method applied to spaceborne routers, wherein in the SAGIN integrated space-air-ground network, satellites or other spacecraft are mapped as nodes, and the spaceborne router is installed on the satellite or other spacecraft, characterized in that, The method includes: The source node is the transmitter. Based on the improved SRv6 protocol, it defines the neighbor segment identifier NB-SID, constructs a bit path encoding mechanism, obtains a bit map after encoding, constructs the neighbor forwarding table NBFT, and sends data packets according to the neighbor forwarding table NBFT. The intermediate node is the receiving end. It constructs the Neighbor Forwarding Table (NBFT) of the intermediate node, receives data packets, performs bit sequence parsing to decode them, updates the bitmap and IPv6 destination address in the Neighbor Segment Identifier (NB-SID), compares the bitmap with the Neighbor Forwarding Table (NBFT) to obtain the forwarding interface, and forwards the data packets.

2. The lightweight segmented routing optimization method for spaceborne routers according to claim 1, characterized in that, The source node is the transmitter, and its signal encoding and transmission processing includes: S1: Improve the SRv6 protocol, define the neighbor segment identifier NB-SID, construct a satellite bit path encoding mechanism, obtain the bitmap in the neighbor segment identifier NB-SID, encapsulate the neighbor segment identifier NB-SID into the SRv6 header and replace the SID list; S2: Obtain satellite network topology information, construct and store the Neighbor Forwarding Table (NBFT), and send data packets based on the NBFT.

3. The lightweight segmented routing optimization method for spaceborne routers according to claim 1, characterized in that, The intermediate node is the receiving end, and its specific process of receiving, decoding, and forwarding signals includes: S3: Construct the neighbor forwarding table of the intermediate node, receive data packets, parse the route order, verify the route integrity, and obtain the complete bitmap; S4: Perform a bitwise AND operation between the complete bitmap and the bitmap of this node to determine whether the local node is a node in the routing path; S5: If the local node is a node in the routing path, then perform an XOR operation between the complete bitmap and the bitmap of the local node to generate the remaining bitmap and update the bitmap in the neighbor segment identifier NB-SID. S6: Compare the bitmap in the updated neighbor segment identifier NB-SID with the neighbor forwarding table NBFT to obtain the forwarding interface and forward the data packet.

4. The lightweight segmented routing optimization method for spaceborne routers according to any one of claims 1-3, characterized in that, The total length of the Neighbor Segment Identifier (NB-SID) is 128 bits, and the field allocation strictly follows the SRv6 protocol. The structure of the Neighbor Segment Identifier (NB-SID) includes the Locator Field (LOC), the Function Command Field (FUNCT), and the Parameter Field (ARGS). The Locator Field (LOC) occupies 64 bits, which includes a 4-bit continuation identifier (CI) and a 60-bit bitmap.

5. The lightweight segmented routing optimization method for spaceborne routers according to claim 1 or 4, characterized in that, Based on the continuation identifier CI in the neighbor segment identifier NB-SID, the carrying capacity of the neighbor segment identifier NB-SID is extended, specifically including: The continuation identifier CI field is a 4-bit binary number, which includes two states. When CI=0001, it means that the bitmap of the current neighbor segment identifier NB-SID needs to be concatenated with the bitmap of the subsequent neighbor segment identifier NB-SID. The specific method of concatenating the neighbor segment identifier NB-SID across segments is as follows: split the previous neighbor segment identifier NB-SID into three segments, define the first segment neighbor segment identifier to carry the first 60 bits, CI=0001, define the second segment neighbor segment identifier to carry the middle 60 bits, CI=0001, and define the third segment neighbor segment identifier to carry the last 30 bits, CI=0000. When CI=0000, it means that the bitmap of the current neighbor segment identifier NB-SID is the terminating segment of the complete path; When the satellite router receives the NB-SID sequence of neighbor segments, it stitches the bitmaps of each segment into a complete bitmap in the order of reception.

6. The lightweight segmented routing optimization method for spaceborne routers according to claim 1, characterized in that, A satellite bit path encoding mechanism is constructed to obtain a bitmap, which specifically includes: To identify a single node, a binary sequence of the same length as the bitmap is used, with the position representing the local node represented as 1 and the rest represented as 0, forming a bitmap for each node. The routing path is encoded as follows: The source node calculates the initial route path, and SAPP uses a route mapping algorithm based on the shortest path principle to modify the corresponding route path and obtain the final route path; Based on the final routing path, extract the bitmap corresponding to each node on the path, and perform a bitwise OR operation to generate a bitmap.

7. The lightweight segmented routing optimization method for spaceborne routers according to claim 6, characterized in that, Based on the shortest path principle, SAPP uses a route mapping algorithm to modify the corresponding route paths. The specific process includes: Construct a topology graph G for the space-based network, G=(V,E), where V is the set of satellite or other spacecraft nodes and E is the set of direct links between nodes; Based on the aforementioned topology graph G, calculate the original routing path. , Indicates the source node, Indicates the destination node or the end point; Calculate the cost matrix T of the inter-satellite communication link between two arbitrary nodes using... Represents any two non-adjacent nodes With nodes The cost of communication links between them, when When, it represents any non-adjacent node. With nodes There is no direct link between them; compute nodes Next hop identifier ; Traverse all node pairs from the source node to the destination node in the order of the path nodes. Detect whether a detour segment exists, and the detour segment meets the following condition: node The next hop is not a node But the cost matrix If a detour is detected, the node will be... The next hop is directly corrected to the node. Delete intermediate detour nodes and generate a valid path that meets the SAPP shortest path principle.

8. The lightweight segmented routing optimization method for spaceborne routers according to claim 1, characterized in that, The Neighbor Forwarding Table (NBFT) is stored in the cache of the satellite router and includes local bitmap entries and neighbor bitmap entries. The local bitmap entries use the current node's bitmap as the key for local node identification. The neighbor bitmap entries use the adjacent node's bitmap as the key to associate the inter-satellite link physical port. Each node can find out the mapping relationship between the neighbor node's bitmap and the forwarding port by querying the Neighbor Forwarding Table (NBFT).

9. The lightweight segmented routing optimization method for spaceborne routers according to claim 1, characterized in that, Step S2 specifically includes: Satellite network topology information obtained from inter-satellite intra-gateway protocols; Based on the satellite network topology information, the segment identifier (SID) and bit map of each local node and neighbor node in the satellite network are extracted, and the corresponding neighbor forwarding table (NBFT) is generated. Each node parses the complete bitmap from the data packet, calls the local node bitmap of the neighbor forwarding table NBFT, performs a bitwise AND operation, determines the forwarding port, and sends the data packet.

Images