Low earth orbit satellite network communication and calculation integration method and simulation implementation system

Abstract

The invention discloses a low earth orbit satellite network communication calculation integration method based on hierarchical convergence and a simulation implementation system. The method comprises the following steps: designing a task model based on calculation task decomposition; by taking minimization of task completion time as an optimization target, a greedy-based source node task allocation method is designed according to the number of calculation layers, the relationship between the data volume allocated to the calculation nodes and the number of calculation layers and the task completion time corresponding to the number of calculation layers, task execution segmentation is realized, calculation source nodes of each sub-task are given, and the task completion time corresponding to each sub-task is obtained. Obtaining a subtask list; a random factor exploration method is introduced to determine a forwarding node, and the method comprises the following steps: selecting a selection range of a next hop computing node according to a computing condition of a subtask, then sending a request through a client of a controller, obtaining the idle queue length of a cached to-be-selected node, and determining the forwarding node by using uniformly distributed random variables after normalization. Compared with other existing methods, the method provided by the invention obtains better system performance and embodies the anti-congestion capability.

Description

Technical Field

[0001] The present invention belongs to the technical field of wireless communications, and in particular relates to a low-orbit satellite network communication and computing integration method based on hierarchical convergence and a simulation implementation system. Background Art

[0002] Distributed computing based on low-orbit satellite constellations has become a research hotspot. The communication and computing integration strategy achieves overall resource scheduling by analyzing the overall communication resources and computing resources. Existing distributed computing technology is mainly based on MapReduce, which divides the unit nodes into one master node and several computing nodes. The master node decomposes the task into subtasks and forwards them to the computing nodes for parallel computing. After exchanging intermediate results, each computing node performs convergence and returns the results to the master node. Integrated computing strategies such as Computing-Aware Routing (CAR) comprehensively consider the overall communication and computing latency. The results are no longer returned to the master node, but are transmitted to another destination node, thus eliminating the process of the master node transmitting to the destination node. Distributed computing technology has the following shortcomings:

[0003] 1. Mature distributed computing technologies such as MapReduce are mainly used for ground-based data center scenarios. Their topology, communication link characteristics, and mission characteristics are significantly different from those of low-orbit satellite networks, resulting in a relatively large overall communication and computing latency.

[0004] 2. CAR has made theoretical improvements to it. However, since it stipulates that each subtask is only calculated by a single node, it does not fully utilize the unit computing power.

[0005] Node-Expansion Computing-Aware Routing (NE-CAR) addresses the shortcomings of single-node computing by introducing serial cascade computing for subtasks. However, this algorithm does not consider task aggregation, which reduces performance when the overall computing task pressure is high. Summary of the Invention

[0006] In response to the above problems, the present invention provides a low-orbit satellite network communication and computing integration method and simulation implementation system based on hierarchical convergence. In view of the serious performance degradation of existing integrated computing scheduling technology under greater task pressure, the present invention designs and implements a hierarchical aggregation joint scheduling decision method, which takes hierarchical convergence combined with unidirectional transmission as the technical innovation point to improve the task acceptance rate under greater task pressure.

[0007] The technical solutions of the present invention are as follows:

[0008] A low-orbit satellite network communication and computing integration method based on hierarchical convergence includes the following steps:

[0009] Based on the Walker-configured low-orbit satellite constellation, a communication and computing unit is divided in the low-orbit satellite constellation according to the location of the source node and the destination node in the grid topology;

[0010] Design a task model based on the decomposition of computing tasks, and use latency and reception rate as performance evaluation based on the task model, where the reception rate is the ratio of the number of received tasks to the number of sent tasks;

[0011] Taking minimizing task completion time as the optimization goal, based on performance evaluation, and according to the number of computing layers, the relationship between the amount of data allocated to computing nodes and the number of computing layers, and the task completion time corresponding to the number of computing layers, a greedy source node task allocation method is designed to achieve task execution segmentation. Given the computing source node of each subtask, a subtask list is obtained.

[0012] An exploratory method that introduces random factors to determine the forwarding node includes: selecting the selection range of the next-hop computing node based on the calculation situation of the subtask, then sending a request through the controller's client to obtain the idle queue length of the cached candidate node, and then determining the forwarding node using a uniformly distributed random variable after normalization.

[0013] A further technical solution of the present invention is: a greedy source node task allocation method, which specifically includes the following steps:

[0014] Calculate the completion time of the nth task in the bth batch of tasks based on the number of computing layers, and take the number of computing layers corresponding to the minimum completion time as the optimal number of layers;

[0015] Based on the optimal number of layers, the data volume of each layer is obtained according to the relationship between the amount of data allocated to the computing nodes in layer i and the number of computing layers, thereby obtaining a list of subtasks.

[0016] A further technical solution of the present invention is to calculate the completion time T of the nth task in the bth batch of tasks. complete , the specific expression is:

[0017]

[0018] Among them, H represents the minimum number of hops from the source node to the destination node, represents the amount of data allocated to the first-layer computing nodes for the nth task in the bth batch of tasks, BW represents the bandwidth, and γ (b,n) Indicates the unit processing time of the nth task in the bth batch of tasks.

[0019] A further technical solution of the present invention is: the relationship between the amount of data allocated to the i-th layer computing node and the number of computing layers can be expressed as follows:

[0020]

[0021] in, Indicates the amount of data allocated to the first-layer computing nodes for the nth task in the bth batch of tasks. L represents the number of calculation layers, represents the amount of data allocated to the computing nodes in layer i for the nth task in batch b, and f represents the computing function.

[0022] A further technical solution of the present invention is that the method for determining the forwarding node is implemented on the node and the controller respectively, wherein the implementation steps on the node side include:

[0023] If the current node is not the source node or the destination node, then:

[0024] Determine whether the calculation can be performed at this layer based on the current number of attempts. If so, obtain the candidate node list based on the node sequence number list of this layer; if not, obtain the candidate node list based on the node sequence number list of the next layer;

[0025] Get the residual load of the candidate node and normalize the residual load;

[0026] A random variable that obeys the uniform distribution of [0,1) is designed as the judgment threshold, the normalized load weight of each candidate node is calculated, and the candidate node with the largest normalized load weight is selected as the forwarding node.

[0027] A further technical solution of the present invention is that the controller side is used to maintain the idle queue length of each node in the entire unit network and update the idle queue length after a request. In the simulation implementation, the controller is responsible for monitoring the network status to obtain simulation data.

[0028] Another embodiment of the present invention provides a low-orbit satellite network communication and computing integration simulation implementation system based on hierarchical convergence. The system is used to implement the above-mentioned low-orbit satellite network communication and computing integration method based on hierarchical convergence, including a receiver, a processor, and a forwarder, wherein the data output by the forwarder is forwarded through an SDN switch:

[0029] The receiver obtains data whose target node is the current node from the SDN switch and pushes the data into the calculation queue;

[0030] The processor extracts the first element of the calculation queue, performs the corresponding calculation based on its type field, and pushes the calculation result into the forwarding queue;

[0031] The forwarder extracts the head element from the forwarding queue, detects the forwarding queue, extracts subtasks from the same task and with the same number of calculations, aggregates the subtasks, obtains the aggregated result, and achieves the effect of compressing the transmission volume; the forwarder obtains the status information of other satellites from the SDN controller, decides the forwarding target of the aggregated result based on the status information of other satellites, and pushes the aggregated result into the SDN switch.

[0032] A further technical solution of the present invention is: each satellite maintains a calculation queue and a forwarding queue based on FIFO, wherein the forwarding queue supports aggregated dequeueing, that is, when the subtask at the head of the queue is dequeued, the aggregator extracts other tasks in the forwarding queue that are aggregated with the dequeued subtask, aggregates these tasks, and enters the forwarder, which selects the next calculation node and executes forwarding.

[0033] The present invention provides a low-orbit satellite network communication computing integration method and simulation implementation system based on hierarchical convergence, which adopts non-uniform subtask division, hierarchical convergence method and unidirectional transmission. Compared with other existing methods, it achieves better system performance in more congested scenarios, demonstrating the anti-congestion ability of the method of the present invention. BRIEF DESCRIPTION OF THE DRAWINGS

[0034] Figure 1 2. This is a schematic diagram of a low-orbit constellation calculation unit according to an embodiment of the present invention;

[0035] Figure 2 This is a schematic diagram of the layers of the general computing unit in an embodiment of the present invention;

[0036] Figure 3 This is a flowchart of node data processing in an embodiment of the present invention;

[0037] Figure 4 This is a diagram of the simulation platform architecture in an embodiment of the present invention;

[0038] Figure 5 1 is a comparison diagram of the effects of sending frequency and receiving rate in an embodiment of the present invention. DETAILED DESCRIPTION

[0039] The present invention will be further described in detail below with reference to the accompanying drawings and examples. It should be understood that the specific embodiments described herein are intended only to illustrate the present invention and are not intended to limit the present invention. It should also be noted that, for ease of description, the accompanying drawings only illustrate portions relevant to the present invention, rather than all structures.

[0040] Before discussing the exemplary embodiments in more detail, it should be mentioned that some exemplary embodiments are described as processes or methods depicted as flow charts. Although the flow charts describe the steps as sequential processes, many of the steps can be implemented in parallel, concurrently, or simultaneously. In addition, the order of the steps can be rearranged. The process can be terminated when its operation is completed, but can also have additional steps not included in the accompanying drawings. The process can correspond to a method, function, procedure, subroutine, subprogram, etc.

[0041] The present invention provides a method for integrating low-orbit satellite network communication and computing based on layered convergence. Tasks are divided into N subtasks according to strategy p, each requiring L layers of serial computation. Ideally, each computing node is responsible for one layer of computation, so N is equal to the number of computing nodes. After the computation is completed, the next computing node is selected according to strategy q to be responsible for the next layer of computation, until convergence. The goal of the method is to minimize the task completion time T while maintaining a certain acceptance rate R.

[0042] The overall scheduling problem can be divided into two parts based on the actual workflow: one is a centralized problem, which involves how the source node selects the compute node and how the task data volume is divided; the other is a distributed problem, which involves how each compute node selects the subsequent compute node.

[0043] The embodiment of the invention is based on a hierarchical convergence low-orbit satellite network communication and computing integration method, comprising the following steps:

[0044] Based on the Walker-configured low-orbit satellite constellation, a communication and computing unit is divided in the low-orbit satellite constellation according to the location of the source node and the destination node in the grid topology;

[0045] Design a task model based on the decomposition of computing tasks, and use latency and reception rate as performance evaluation based on the task model, where the reception rate is the ratio of the number of received tasks to the number of sent tasks;

[0046] Taking minimizing task completion time as the optimization goal, based on performance evaluation, and according to the number of computing layers, the relationship between the amount of data allocated to computing nodes and the number of computing layers, and the task completion time corresponding to the number of computing layers, a greedy source node task allocation method is designed to achieve task execution segmentation. Given the computing source node of each subtask, a subtask list is obtained.

[0047] An exploratory method that introduces random factors to determine the forwarding node includes: selecting the selection range of the next-hop computing node based on the calculation situation of the subtask, then sending a request through the controller's client to obtain the idle queue length of the cached candidate node, and then determining the forwarding node using a uniformly distributed random variable after normalization.

[0048] Specifically, if Figure 1 As shown, consider a Walker-configured low-orbit satellite constellation, in which each satellite establishes a laser link with four adjacent satellites, two of which are satellites in the same orbit and two are satellites in adjacent orbits, forming a grid-like satellite topology. The embodiment is based on SDN (Software-Defined Networking). Different from the traditional OSI network model, SDN separates the control plane from the data plane, and therefore models a single satellite as a combination of a host and a switch. The switch of each satellite is connected to the controller. In the actual system, the controller can be placed on the ground or in a synchronous orbit with a wide coverage. It can be considered that the controller has complete network information. Consider that the integrated computing task is generated at a certain node (source node) and the destination node is another satellite, that is, the destination node needs to receive the result after processing the task. According to the position of the source node and the destination node in the grid topology, a communication and computing unit can be divided in the entire low-orbit constellation.

[0049] Files received by the satellite from sensors or other satellites are parsed into computing tasks. Task processing has various forms, the most common of which are: (1) matrix multiplication; (2) convolution. For example, the typical task of filtering RGB images is essentially a two-dimensional convolution of the matrix. Since the second operand, the convolution kernel, can be pre-configured and saved, the binary calculation can be understood as a unary function, denoted as A=f(F), where A is the calculation result, F is the file to be processed, and f is the calculation function. |F| represents the data volume of task F, and the present invention believes that it is positively correlated with the calculation data volume. Inductively, it is found that matrix multiplication and convolution tasks often have the following properties:

[0050] 1. The task can be decomposed, denoted as F = ∑F j Task F can be decomposed into several subtasks F j , subtasks can be combined into the original task. For example, in matrix multiplication, the first matrix can be split into rows. It is worth noting that due to the redundancy introduced by distributed computing and the redundancy of the data machine representation itself, the amount of data in task F is less than the sum of the amount of data in the subtasks, that is, |F|<∑|F j |.

[0051] 2. f is linear. The result of the original task is equal to the combination of the results of the subtasks, which can be expressed as A = f(F) = f(∑F i )=∑f(F i). Combined with Property 1, the split tasks are processed, and the combination of the processing results is the same as the result of directly processing the original tasks. Depending on the actual system implementation, the original result and the combined result may be strictly the same or approximately the same. For example, if the image is split into rows and convolution is performed, the convolution cannot be performed at the split. By introducing redundancy in the subtask segmentation and using image algorithm completion, the original result and the combined result can be made equal, or the errors of several rows can be ignored. This is also feasible when the image is large, because the relative error is small and the overhead required to achieve exactly the same may be large. Here, it is assumed that they are directly ignored.

[0052] 3. The calculation can be decomposed into multiple levels of serial calculations, and the sub-calculations remain linear, that is, Still taking image processing as an example, the convolution kernel can be decomposed into several iterative small kernels, but the convolution kernel itself must have the property of being separable. This property forms the basis of hierarchical computing. Assume that the calculation is divided into L max Layer, each subtask needs to go through the complete L independently in turn max Layer calculation. Subtasks from the same task that undergo the same layer calculation can be aggregated, which can reduce the amount of transmitted data.

[0053] In summary, the process of computing f on received data F to obtain result A can be expressed as A = f(F), and both F and f can be decomposed. Decomposing task F into parallel computation introduces additional computing power by increasing the amount of redundant data; decomposing the computation of f into serial computation reduces the computing pressure on a single node by introducing communication time. The following examples are all based on tasks that meet these characteristics.

[0054] Further analysis of tasks that meet the above characteristics yields two computational representations: compression rate and unit processing time. The data computation process can be understood as a form of data compression, where computing time is consumed to reduce the data size, thereby reducing communication time. The compression rate ω and unit processing time γ are independent and are represented by two parameters. Denote the compression rate as Assume that for the subtasks decomposed from the same task, the computation time of the subtask is only related to the data volume and unit processing time of the subtask. The unit processing time γ is the time required to process each bit of data, which essentially depends on the processor cycles x required to process each bit of data and the processor frequency f. cpu ,have Statistically,

[0055] The main purpose of the present invention is to reduce the overall delay of the integrated computing task, which the inventor measures using the average task completion time T.

[0056]

[0057] Where T i ——The total time taken by the destination node for the i-th received task;

[0058] N recv ——The number of tasks received by the destination node.

[0059] The task is composed of subtasks. Without coding, the time T taken for the task is i It depends on the time taken by the last subtask to arrive, that is,

[0060]

[0061] Where T i j ——The time taken for the jth subtask of the i-th task.

[0062] Analyzing the task processing process, we know that T i j It consists of four parts: transmission time, propagation time, waiting time, and computation time. Waiting time refers to the time spent waiting in the node queue for computation and transmission, while computation time refers to the time it takes to process the task.

[0063] However, in congested scenarios, tasks may not be completed due to buffer overflow and other reasons. Therefore, it is necessary to set a threshold for the reception rate R to reduce the delay T while meeting the reception rate R. The reception rate R is defined as the ratio of the number of received tasks to the number of sent tasks, that is,

[0064]

[0065] Where N send ——The number of tasks sent by the source node.

[0066] Latency T and reception rate R both reflect the efficiency of the system in completing computational tasks, but there are certain differences. T measures the speed of task completion, while R measures the percentage of tasks completed. Reducing buffer overflows requires more efficient resource scheduling, and in this respect, the two optimization goals are consistent. However, when multiple tasks have different priorities, prioritizing some tasks to improve the reception rate R reduces the completion rate T of other tasks, thus creating a trade-off.

[0067] The greedy source node task allocation method specifically includes the following steps:

[0068] Calculate the completion time of the nth task in the bth batch of tasks based on the number of computing layers, and take the number of computing layers corresponding to the minimum completion time as the optimal number of layers;

[0069] Based on the optimal number of layers, the data volume of each layer is obtained according to the relationship between the amount of data allocated to the computing nodes in layer i and the number of computing layers, thereby obtaining a list of subtasks.

[0070] Calculate the completion time T of the nth task in the bth batch of tasks complete , the specific expression is:

[0071]

[0072] Among them, H represents the minimum number of hops from the source node to the destination node, represents the amount of data allocated to the first-layer computing nodes for the nth task in the bth batch of tasks, BW represents the bandwidth, and γ (b,n) Indicates the unit processing time of the nth task in the bth batch of tasks.

[0073] The relationship between the amount of data allocated to the computing node in layer i and the number of computing layers is expressed as follows:

[0074]

[0075] in, Indicates the amount of data allocated to the first-layer computing nodes for the nth task in the bth batch of tasks. L represents the number of calculation layers, represents the amount of data allocated to the computing nodes in layer i for the nth task in batch b, and f represents the computing function.

[0076] Specifically, since the computing nodes are also responsible for routing and forwarding, selecting computing nodes is equivalent to selecting several intermediate nodes between the source node and the destination node at the forwarding level, such as Figure 2 The selected node in . Considering that selecting routing nodes in dynamic scenarios is an NP-hard problem, in order to simplify, the concept of layering is first introduced. Nodes in the same layer have certain common characteristics. When selecting nodes, nodes in the same layer have the same (or similar) probability of being selected. Assuming that all computing nodes are isomorphic to the links, each subtask adopts the shortest path routing. Under the assumption of link isomorphism, the shortest path routing is equivalent to the minimum hop routing. The propagation time of inter-links is the same, and the propagation time of intra-links is also the same. In the subsequent derivation, only the transmission time, computation time and waiting time are considered.

[0077] The task allocation algorithm derives the number of computing nodes and the amount of data allocated to each computing node by the source node. Figure 2As shown, the embodiment divides the nodes in the network into layers based on the shortest number of hops to the sink node. The sink node is recorded as the first layer, and the nodes that only need one hop to reach the sink node are recorded as the second layer, and so on. The maximum number of layers in which the computing nodes are located is recorded as L. The embodiment assumes that all nodes in the selected layer will be used for calculation, so deriving the number of computing nodes is equivalent to deriving L. Each computing node is responsible for the initial calculation of one subtask, and each subtask requires L serial calculations. The i-th layer computing node is responsible for calculating the subtasks sent to it by the source node and the i+1 layer. The subtask forwarded from the i-th layer computing node after calculation has i-1 remaining computing layers, and the subtask is forwarded to the i-1 layer computing node. The specific selection of which i-1 layer computing node is implemented by the node selection algorithm, see the next section. The reason for calculation in the second half of the transmission is to provide convergence opportunities. If the calculation is performed in the first half, then an additional sink node needs to be specified.

[0078] The following qualitative analysis shows the relationship between the number of node layers and the size of the allocated data when initially allocating tasks at the source node. Due to the mesh topology of the intersatellite network of low-orbit satellites, to reach the i-th layer node, one must pass through the i+1-th layer node. The data size of the subtask calculated on the i-th layer node should be smaller than the subtask calculated on the i+1-th layer node. This can be proved by contradiction: when the initial calculation of the i-th layer subtask D i and the subtask D calculated at the i+1th layer i+1 When the sizes are equal, if the computing resources are fully utilized, then on the link between the two nodes, the former transmits more data than the latter, so the transmission time is longer. If the computing time remains unchanged, it is necessary to wait for D i+1 After computation is complete and converged, data is transmitted downward. This creates idle time for nodes in layer i+1, which conflicts with the assumption of full utilization of computing resources. Overall task latency can be further reduced by delegating some tasks to these nodes. In summary, the higher the number of layers, the larger the data size should be.

[0079] The following quantitative calculation of the optimal number of layers and the corresponding data size of each layer node is based on the greedy algorithm. It is also assumed that all computing nodes and links are isomorphic and each subtask uses the shortest route. The time it takes for the i+1 layer node to complete the first calculation and send it to the i layer node to complete the next level of calculation is

[0080]

[0081] Where H is the minimum number of hops from the source node to the destination node;

[0082] ——The amount of data allocated to the computing nodes in layer i for the nth task in batch b;

[0083] γ(b,n) ——Unit processing time of the nth task in the bth batch of tasks;

[0084] β (b,n) ——Compression ratio of the nth task in the bth batch of tasks

[0085] BW – bandwidth;

[0086] β——the time used to calculate 1 bit of data;

[0087] ——Waiting time, including the time waiting for calculation and forwarding at layer i+1, and the time waiting for calculation at layer i.

[0088] The time to complete the first calculation at the i-th layer node should be

[0089]

[0090] In the formula Includes the time spent waiting for computation at layer i.

[0091] The best case scenario is that the first computation of the subtask is performed at the i+1 layer node, and when the computation result is sent to the i-th layer node, the i-th layer node has just completed the computation. Otherwise, as mentioned above, the overall latency can always be further shortened by “load balancing”. Therefore, T i+1 =T i ,Right now

[0092]

[0093] To make the previous node take on more computing tasks, Therefore, sorting out the current conditions, we get the following equations

[0094]

[0095] Solve the system of equations to obtain The relationship with the number of calculation layers L is

[0096]

[0097] In the formula The completion time of the (b,n) task is

[0098]

[0099] On the other hand, for distributed computing, the more computing nodes, the better. Generally, studies believe that adding computing nodes increases communication latency and power consumption. From the perspective of overall computing power consumption, even if communication and energy loss are not considered, there is still a cost in using distributed computing. In system modeling, we mentioned that after splitting the task into subtasks, the amount of data in the subtask combination is greater than the amount of data in the original task, and the amount of computing is positively correlated with the amount of data. Therefore, for the same task, distributed computing uses more processor cycles than single-node computing and occupies more overall computing power, which is not conducive to the overall performance of the system when tasks arrive frequently. Therefore, the inventor stipulates that the upper bound of L is

[0100] L≤min(maxOrb,maxSat) (10)

[0101] Therefore, the following optimization problem is obtained, the goal is to reduce the overall task completion time.

[0102]

[0103] st(8),(9),(10)

[0104] In summary, based on the prediction of computing power and network quality, the task is divided into several subtasks at the source node, and the data volume and computing nodes are specified for each subtask. The algorithm table is shown in Table 1, where the input parameters are reflected in Formula (9).

[0105] Table 1 Greedy-based task allocation algorithm

[0106]

[0107] It's worth noting that the convergence process is not analyzed here. This is because the network performance after convergence introduces complex random variables. The size of the aggregated data is positively correlated with the number of subtasks participating in the convergence. The number of aggregated subtasks depends on the number of elements that can be aggregated in the queue when the head element performs the convergence. This, in turn, is related to waiting time and historical transmission data, making it difficult to quantitatively calculate. Furthermore, as hypothesized, the above source node task allocation algorithm does not consider the impact of node heterogeneity, link dynamics, and inter-task resource contention. The following proposes a scheduling algorithm to address this issue.

[0108] In addition, the greedy task allocation algorithm obtains the nodes of the first layer of calculation, that is, the source node. Each subtask requires several layers of calculation, and the subsequent layer calculations use a random node selection algorithm.

[0109] Furthermore, the number of layers of compute nodes matches the number of layers required for the subtask, but the relationship between them is not directly proportional. The first-layer node (destination node) is responsible for the final layer of computation, but the first-layer computation is not necessarily performed on the final-layer compute node (the Lth-layer compute node). The specific location of the first-layer computation of a subtask is determined by the greedy workload allocation algorithm.

[0110] The method for determining the forwarding node is implemented on the node and the controller respectively. The implementation steps on the node side include:

[0111] If the current node is not the source node or the destination node, then:

[0112] Determine whether the calculation can be performed at this layer based on the current number of attempts. If so, obtain the candidate node list based on the node sequence number list of this layer; if not, obtain the candidate node list based on the node sequence number list of the next layer;

[0113] Get the residual load of the candidate node and normalize the residual load;

[0114] A random variable that obeys the uniform distribution of [0,1) is designed as the judgment threshold, the normalized load weight of each candidate node is calculated, and the candidate node with the largest normalized load weight is selected as the forwarding node.

[0115] The controller side is used to maintain the idle queue length of each node in the entire cell network and update the idle queue length after request. In the simulation implementation, the controller is responsible for monitoring the network status to obtain simulation data.

[0116] Specifically, as described above, the random node selection algorithm is used to solve the problem of upper-layer compute nodes selecting lower-layer compute nodes. It primarily considers the impact of node heterogeneity, link dynamics, and inter-task resource competition. As a preliminary algorithm, it currently only considers reducing computing resource contention, that is, shortening the waiting time on each node.

[0117] From a communication forwarding perspective, the entire route from the source node to the destination node is divided into several segments, with the destination node of each segment being a computational node. A random node selection algorithm is used to select the next computational node, while routing within each segment is implemented using the dynamic Dijkstra algorithm. The rationale for separating node selection from the routing algorithm is that the dynamic Dijkstra algorithm can efficiently update the shortest path between any two nodes in the network, but it has difficulty quantifying the complexities within nodes. Specifically, it can only handle edges, not nodes, especially when there is a trade-off between node communication and distributed computing capabilities.

[0118] Based on the operation and simulation results of existing systems, computation time is the primary performance bottleneck in the scenarios addressed by the embodiments. Therefore, a node selection algorithm is designed based on the principle of minimizing computational latency. Due to a mismatch between task processing speed and task generation or arrival speed, node computation queues will accumulate. The heterogeneity and location differences between nodes result in different idle queue lengths for different nodes at the same time and on the same layer. Queues generally follow a FIFO (First-in-First-Out) principle, meaning that later-arriving tasks must wait for earlier-arriving tasks to complete. To minimize latency, tasks should be sent to the node with the longest idle queue. However, in practical systems, real-time updates of queue length information for all nodes require a high frequency, which places significant communication pressure between the SDN controller and nodes. Furthermore, since SDN controllers are typically provided by ground nodes or geostationary satellites, the communication latency is greater than that of inter-satellite links, inevitably leading to a lag in idle queue length updates. In this case, if tasks are always sent to the node with the longest idle queue, the previously idle node may become the busiest, while other nodes become idle.

[0119] Based on the above considerations and inspired by the e-exploration algorithm, a randomized exploration algorithm is employed to determine forwarding targets. The node selects a range of next-hop compute nodes based on the computational performance of the subtask. The node then sends a request through the controller's client to obtain the idle queue length of the cached candidate nodes. After normalization, the forwarding node is determined using a uniformly distributed random variable x~U(0,1). The node selection algorithm is implemented on both the node and the controller. See Algorithm Table 2 for details on the node-side algorithm.

[0120] Table 2 Node selection algorithm (node ​​side)

[0121]

[0122] It should be noted that the judgment threshold, denoted as threshold, is a random variable uniformly distributed in the range [0, 1]. When threshold is greater than or equal to 0, the loop is entered. The loop enumerates satellite numbers (in a certain range). Each iteration subtracts the normalized load weight of the currently enumerated satellite from threshold. This way, when the loop exits, the sum of the weights of all satellites preceding the current satellite (in terms of sequence number) exceeds the threshold. First, the range is determined, which is the sequence number list of the next layer of computing nodes. This information is fixed for the unit and synchronized to all nodes within the unit via SDN. The available load of these nodes is then obtained, normalized, and the sequence number of the next target node is determined by the judgment threshold. There is only one final target node, which is determined when the total task reaches the source node, the entire algorithm is initiated, and the unit division begins. The target node is reached through iteration.

[0123] This method aims to select the node with the highest weight with a higher probability, but it does not guarantee that it will be selected. In a specific embodiment, for example, the weights of the following nodes are 0.1 / 0.2 / 0.5 / 0.2, and the random threshold is th = 0.5. Then, at the end of the first loop, i = 1 and th = 0.4. The second loop ends at i = 2 and th = 0.2. The third loop ends at i = 3 and th = -0.3, and the loop exits. Therefore, the node selected is node = i - 1 = 3 - 1 = 2, which is the third node with the highest weight (node ​​= 2).

[0124] The controller-side algorithm is detailed in Algorithm Table 3. This algorithm is a supporting algorithm that maintains the idle queue length of each node in the entire cell network and updates the idle queue length upon request. Furthermore, in the simulation implementation, the controller is also responsible for monitoring the network status to obtain simulation data. The controller-side algorithm is detailed in Algorithm Table 3.

[0125] Table 3 Node selection algorithm (controller side)

[0126]

[0127] Another embodiment provides a low-orbit satellite network communication and computing integration simulation implementation system based on hierarchical convergence. The system is used to implement the above-mentioned low-orbit satellite network communication and computing integration method based on hierarchical convergence, including a receiver, a processor, and a forwarder, wherein the data output by the forwarder is forwarded through an SDN switch:

[0128] The receiver obtains data whose target node is the current node from the SDN switch and pushes the data into the calculation queue;

[0129] The processor extracts the first element of the calculation queue, performs the corresponding calculation based on its type field, and pushes the calculation result into the forwarding queue;

[0130] The forwarder extracts the head element from the forwarding queue, detects the forwarding queue, extracts subtasks from the same task and with the same number of calculations, aggregates the subtasks, obtains the aggregated result, and achieves the effect of compressing the transmission volume; the forwarder obtains the status information of other satellites from the SDN controller, decides the forwarding target of the aggregated result based on the status information of other satellites, and pushes the aggregated result into the SDN switch.

[0131] Each satellite maintains a separate computing queue and a forwarding queue based on FIFO. The forwarding queue supports aggregated dequeueing. That is, when the subtask at the head of the queue is dequeued, the aggregator extracts other tasks in the forwarding queue that are aggregated with the dequeued subtask, aggregates these tasks, and enters the forwarder, which selects the next computing node and performs forwarding.

[0132] Specifically, the satellite host implements a complete "receive-process-forward" process. This embodiment abstracts the host's functionality into three models: a receiver, a processor, and a forwarder. Based on these three models, computation queues and forwarding queues are maintained. Data output by the forwarder is forwarded via the SDN switch. The functional model and queue model are described below.

[0133] 1. Functional model. The receiver obtains data whose target node is the current node from the SDN switch and pushes the data into the calculation queue. The processor extracts the head element of the calculation queue, performs the corresponding calculation according to its type field, and pushes the calculation result into the forwarding queue. The forwarder extracts the head element from the forwarding queue and detects the entire forwarding queue, extracts all subtasks from the same task and with the same number of calculations, performs aggregation on these subtasks, obtains the aggregation result, and achieves the effect of compressing the transmission volume. The forwarder obtains the status information of other satellites from the SDN controller, decides the forwarding target of the aggregation result based on this, and pushes the aggregation result into the SDN switch. This completes the process of obtaining data from the SDN switch, processing it, and then handing it over to the SDN switch for forwarding. The SDN controller implements the shortest path routing based on Dijkstra at the network layer, implements the controller-server at the application layer, supports various simulation functions, and maintains the status information of each satellite, including the length of the idle forwarding queue. The node data processing flow and control process are as follows Figure 3 shown.

[0134] 2. Queue model. The satellite's receiving and processing capabilities are limited. It cannot process all received tasks simultaneously, nor can it forward all tasks to be forwarded simultaneously. Instead, it caches them and waits for the processor and forwarder to be idle before processing them in sequence. Inspired by the Delay Tolerant Network (DTN), each satellite maintains a computing queue and a forwarding queue. They basically follow the FIFO model, but the difference is that the forwarding queue supports "aggregate dequeueing". That is, when the subtask at the head of the queue is dequeued, the aggregator extracts other tasks in the forwarding queue that are aggregated with the task, aggregates these tasks, and then enters the forwarder. The forwarder selects the next computing node and performs forwarding.

[0135] Based on the above satellite modeling, a distributed satellite simulation platform is implemented. The simulation platform architecture is as follows: Figure 4 The following describes the implementation of the main modules.

[0136] (1) Application layer controller

[0137] The application layer controller consists of two parts: the application layer controller-server and the application layer controller-client. The former is implemented on the host machine, and the latter is implemented on each satellite node. The controller-server integrates all controller functions except network layer routing and consists primarily of two threads. Thread 1 maintains and responds to receive connections. It receives node requests from each satellite and returns the corresponding node's current status. Thread 2 maintains and responds to send connections.

[0138] As a server, it obtains and saves the idle queue length from each satellite node, and can obtain the program running status from each node. The satellite node host can obtain global information such as the idle queue length of other nodes from the server. The controller-server and controller-client are implemented through a long connection + connection pool. The long connection method is more stable and suitable for the current simulation scenario, while the connection pool records the correspondence between the host and the network interface for easy maintenance. The controller-client is implemented in each satellite node. It initiates and maintains a long connection with the server, and obtains the local idle queue length for the server to query. The controller-client of the source node additionally maintains a sending record, which is the actual sending log; the aggregation node additionally maintains a receiving record, which is used to record legal received data.

[0139] (2) Node function module

[0140] The remaining key functions of the node are handled by the controller, calculator, and forwarder, each of which is collaboratively implemented by a group of threads. The receiver is responsible for receiving computation tasks sent to it by each satellite and adding them to the computation queue. Each receiver corresponds to one receiving thread. The processor serves as the interface between the computation queue and the forwarding queue, extracting the first element in the computation queue for computation. The forwarder implements a node selection algorithm, initiating aggregate dequeues and selecting the appropriate next computation node for each element. Sending and receiving are implemented using serialization and deserialization, directly sending and receiving objects.

[0141] (3) Node Queue

[0142] Because a single satellite node contains multiple threads, the node queue must be thread-safe. The node queue can specify a queue length, and operations include enqueue, dequeue, aggregate dequeue, and queue length retrieval. Aggregate dequeue extracts the first element and iterates through all remaining elements to extract elements that can participate in aggregation. Therefore, the queue is not a pure FIFO and can only use object locks.

[0143] To better demonstrate the effectiveness of the present invention, simulation experiments were conducted in the examples. The proposed algorithm, AGGR, was compared with two other communication and computing integration methods: (1) Computing-Aware Routing (CAR), which evenly divides the task into several subtasks. Each subtask selects a computing node, maintaining unidirectional transmission throughout the entire computation process; and (2) Node-Expandision Computing-Aware Routing (NE-CAR), which introduces a hierarchical aggregation method based on computing-aware routing but does not optimize the number of subtasks and data volume distribution. The main comparisons between the methods are shown in the table below.

[0144] Table 4 Comparison of experimental methods

[0145]

[0146] The main simulation parameters are shown in Table 5.

[0147] Table 5 Main simulation parameters

[0148]

[0149] like Figure 5 As shown, when λ = 0.2, with an average of one task sent every 0.2 seconds, all algorithms performed poorly and were unable to accept tasks properly. This is because the computing pressure exceeded the system's available capacity. However, as the task pressure gradually decreased, the proposed algorithm achieved a better acceptance rate than the existing algorithm under higher pressure. As the task pressure decreased, the acceptance rate generally showed a gradual increase.

[0150] The present invention provides a low-orbit satellite network communication computing integration method and simulation implementation system based on hierarchical convergence, which adopts non-uniform subtask division, hierarchical convergence method and unidirectional transmission. Compared with other existing methods, it achieves better system performance in more congested scenarios, demonstrating the anti-congestion ability of the method of the present invention.

[0151] In this document, the terms "comprises," "comprising," or any other variations thereof are intended to cover non-exclusive inclusion, such that a step or method that comprises a series of elements includes not only those elements, but also includes other elements not expressly listed, or also includes elements inherent to such step or method.

[0152] The above is a further detailed description of the present invention in conjunction with specific preferred embodiments, and the specific implementation of the present invention should not be considered to be limited to these descriptions. For those skilled in the art to which the present invention belongs, several simple deductions or substitutions can be made without departing from the concept of the present invention, and all of these should be considered to fall within the scope of protection of the present invention.

Claims

1. A low-orbit satellite network communication and computing integration method based on hierarchical convergence, characterized in that: The following steps are involved: Based on the Walker-configured low-orbit satellite constellation, a communication and computing unit is divided in the low-orbit satellite constellation according to the location of the source node and the destination node in the grid topology; Design a task model based on computing task decomposition, with minimizing task completion time as the optimization goal. Based on the relationship between the number of computing layers, the amount of data allocated to computing nodes and the number of computing layers, and the task completion time corresponding to the number of computing layers, design a greedy source node task allocation method to achieve task execution segmentation. Given the computing source node of each subtask, a subtask list is obtained. An exploratory method that introduces random factors to determine the forwarding node includes: selecting the selection range of the next-hop computing node based on the calculation situation of the subtask, then sending a request through the controller's client to obtain the idle queue length of the cached candidate node, and then determining the forwarding node using a uniformly distributed random variable after normalization.

2. The method for integrating low-orbit satellite network communication and computing based on hierarchical convergence according to claim 1, characterized in that: The greedy source node task allocation method specifically includes the following steps: Calculate the completion time of the nth task in the bth batch of tasks based on the number of computing layers, and take the number of computing layers corresponding to the minimum completion time as the optimal number of layers; Based on the optimal number of layers, the data volume of each layer is obtained according to the relationship between the amount of data allocated to the computing nodes in layer i and the number of computing layers, thereby obtaining a list of subtasks.

3. The method for integrating low-orbit satellite network communication and computing based on hierarchical convergence according to claim 2, characterized in that: Calculate the completion time T of the nth task in the bth batch of tasks complete , the specific expression is: Among them, H represents the minimum number of hops from the source node to the destination node, represents the amount of data allocated to the first-layer computing nodes for the nth task in the bth batch of tasks, BW represents the bandwidth, and γ (b,n) Indicates the unit processing time of the nth task in the bth batch of tasks.

4. The method for integrating low-orbit satellite network communication and computing based on hierarchical convergence according to claim 2, characterized in that: The relationship between the amount of data allocated to the computing node in layer i and the number of computing layers is expressed as follows: in, Indicates the amount of data allocated to the first-layer computing nodes for the nth task in the bth batch of tasks. L represents the number of calculation layers, represents the amount of data allocated to the computing nodes in layer i for the nth task in batch b, and f represents the computing function.

5. The method for integrating low-orbit satellite network communication and computing based on hierarchical convergence according to claim 1, characterized in that: The method for determining the forwarding node is implemented on the node and the controller respectively. The implementation steps on the node side include: If the current node is not the source node or the destination node, then: Determine whether the calculation can be performed at this layer based on the current number of attempts. If so, obtain the candidate node list based on the node sequence number list of this layer; if not, obtain the candidate node list based on the node sequence number list of the next layer; Get the residual load of the candidate node and normalize the residual load; A random variable that obeys the uniform distribution of [0,1) is designed as the judgment threshold, the normalized load weight of each candidate node is calculated, and the candidate node with the largest normalized load weight is selected as the forwarding node.

6. The method for integrating low-orbit satellite network communication and computing based on hierarchical convergence according to claim 5, characterized in that: The controller side is used to maintain the idle queue length of each node in the entire cell network and update the idle queue length after request. In the simulation implementation, the controller is responsible for monitoring the network status to obtain simulation data.

7. A low-orbit satellite network communication computing integrated simulation implementation system based on hierarchical convergence, characterized in that: The system is used to implement the low-orbit satellite network communication and computing integration method based on hierarchical convergence as described in any one of claims 1 to 6, comprising a receiver, a processor, and a transponder, wherein data output by the transponder is forwarded through an SDN switch: The receiver obtains data whose target node is the current node from the SDN switch and pushes the data into the calculation queue; The processor extracts the first element of the calculation queue, performs the corresponding calculation based on its type field, and pushes the calculation result into the forwarding queue; The forwarder extracts the head element from the forwarding queue, detects the forwarding queue, extracts subtasks from the same task and with the same number of calculations, aggregates the subtasks, obtains the aggregated result, and achieves the effect of compressing the transmission volume; the forwarder obtains the status information of other satellites from the SDN controller, decides the forwarding target of the aggregated result based on the status information of other satellites, and pushes the aggregated result into the SDN switch.

8. The low-orbit satellite network communication and computing integrated simulation implementation system based on hierarchical convergence according to claim 7 is characterized in that: Each satellite maintains a separate computing queue and a forwarding queue based on FIFO. The forwarding queue supports aggregated dequeueing. That is, when the subtask at the head of the queue is dequeued, the aggregator extracts other tasks in the forwarding queue that are aggregated with the dequeued subtask, aggregates these tasks, and enters the forwarder, which selects the next computing node and performs forwarding.

Images