A script-based dynamic allocation method for satellite-borne distributed software tasks

Abstract

The application discloses a kind of based on script's satellite-borne distributed software task dynamic allocation method, it is characterized in that, include the following steps: S1. design based on script multi-task computing architecture, realize multi-task heterogeneous parallel computing;S2. based on script's software task is migrated between multiple computing nodes, and derive based on script's fine-grained backup strategy;S3. script dynamically binds C language computing library.In the application, by realizing script and script virtual machine technology, based on script, cross-node heterogeneous computing is realized under the basis that fixed script virtual machine and algorithm library are installed in each stage node;By script serialization technology, the transmission of script task between multiple virtual machines is realized, and heterogeneous node script dynamic deployment is realized;By modeling based on task directed acyclic graph of multi-task and multiple nodes, based on genetic algorithm, with the shortest completion time as objective function, the optimal strategy of multi-node task computing time is obtained.

Description

Technical Field

[0001] This invention relates to the field of spaceborne aerospace system technology, and in particular to a script-based method for dynamic allocation of spaceborne distributed software missions. Background Technology

[0002] With the development of spaceborne electronic technology, the traditional hardware configuration of a single machine or single board using a single computing core can no longer meet the ever-increasing demands of spaceborne computing. High-speed bus interconnected heterogeneous computing architectures for spaceborne computers are gradually emerging, significantly improving spaceborne computing power and data transmission rates. The traditional spaceborne software design pattern, where each computing core runs a single software configuration item, can no longer meet current hardware development needs. Distributed, heterogeneous, and intelligent software frameworks will be the future trend of spaceborne software architecture development. To achieve this next-generation software architecture design, we face the following challenges: 1. Solving the heterogeneous computing problem; 2. How to dynamically deploy tasks and transmit data among multiple settlement nodes; 3. How to use an algorithm to complete computing tasks as quickly as possible and achieve maximum computing performance, considering task dependencies, node computing capabilities, and inter-node transmission capabilities. Summary of the Invention

[0003] The purpose of this invention is to propose a script-based dynamic allocation method for spaceborne distributed software tasks in order to solve the above-mentioned problems.

[0004] To achieve the above objectives, the present invention adopts the following technical solution:

[0005] A script-based method for dynamic allocation of spaceborne distributed software missions includes the following steps:

[0006] S1. Design a script-based multi-task computing architecture to achieve heterogeneous parallel computing across multiple tasks;

[0007] S2. Migrate between multiple computing nodes for script-based software tasks, resulting in a script-based fine-grained backup strategy;

[0008] S3. Dynamically bind the script to the C language computing library, implement the virtual machine operation based on C language, and achieve stable operation of the script program;

[0009] S4. Perform mathematical modeling on multi-node computing tasks, obtain optimized resource allocation schemes based on genetic algorithms, complete the computing tasks, and achieve maximum optimized computing performance.

[0010] Preferably, the method for implementing multi-task heterogeneous parallel computing in step S1 specifically includes the following steps:

[0011] S11. Run the scripting language on a virtual machine. The script runs on multiple virtual machines with the same version, so that the script can be seamlessly migrated across multiple virtual machines.

[0012] S12. The virtual machine in step S11 is written based on standard C code. Different versions of the virtual machine are compiled and deployed according to different heterogeneous hardware platforms. The intermediate layer program after the script program is compiled can be dynamically migrated on different heterogeneous platforms, thus realizing multi-task heterogeneous parallel computing.

[0013] Preferably, the method for implementing step S2 specifically includes the following steps:

[0014] S21. The script program periodically sends virtual machine running status information to the master computing node, and the master computing node stores computing data and monitors the running status of the script program.

[0015] S22. When a compute node fails, the primary compute node cannot obtain compute node information and begins to restore the backup state information to the backup compute node. Since the restoration is based on the virtual machine state, the script execution stack can be restored, achieving instruction-level consistency in the restored state.

[0016] Preferably, the method for achieving stable operation of the script program in step S3 specifically includes the following steps:

[0017] S31. By parsing the script program, words are obtained to form a semantic expression tree. The semantic expression tree is then compiled to generate an intermediate language, thereby enabling the script program to run stably on a virtual machine.

[0018] Preferably, the method for optimizing computational performance in step S4 specifically includes the following steps:

[0019] S41. Considering factors such as multi-node computing power, task execution time, task execution data, node transmission rate, and task dependencies, establish a directed acyclic graph of multiple tasks, clarify the constraints of task computation and the objective function of minimizing the parallel computation time of multiple tasks.

[0020] S42. Based on a multi-task computational mathematical model, the correspondence of task arrangements is used as genes, and the inverse of the objective function is used as the fitness rate. Based on a genetic algorithm, each generation is sorted, and emperor nodes and duke nodes are selected. Emperor nodes can be directly retained to the next generation, and duke nodes and emperor nodes have the right to mate. After mating and mutation, individuals with high fitness rates replace individuals with low fitness rates in the previous generation until all replacements are completed. After 20 generations, the solution converges to the optimal solution.

[0021] In summary, due to the adoption of the above technical solution, the beneficial effects of the present invention are:

[0022] 1. In this application, by implementing script and script virtual machine technology, cross-node heterogeneous computing is achieved based on scripts, with fixed script virtual machines and algorithm libraries installed at each stage node.

[0023] 2. In this application, script serialization technology is used to realize the transmission of script tasks between multiple virtual machines and to realize the dynamic deployment of scripts on heterogeneous nodes.

[0024] 3. In this application, by modeling a multi-task and multi-node task-based directed acyclic graph, and using a genetic algorithm with the shortest completion time as the objective function, the optimal strategy for multi-node task computation time is calculated. Attached Figure Description

[0025] Figure 1 A diagram of a script-based multi-node heterogeneous computing architecture provided according to an embodiment of the present invention is shown.

[0026] Figure 2 A schematic diagram of task fault recovery logic provided according to an embodiment of the present invention is shown;

[0027] Figure 3 An example diagram of the script compilation process provided according to an embodiment of the present invention is shown;

[0028] Figure 4 An example diagram of a virtual machine execution process provided according to an embodiment of the present invention is shown;

[0029] Figure 5 An example diagram of a task DSG provided according to an embodiment of the present invention is shown;

[0030] Figure 6 A schematic diagram of the objective function optimization results provided according to an embodiment of the present invention is shown;

[0031] Figure 7 A schematic diagram of the optimized task configuration provided according to an embodiment of the present invention is shown. Detailed Implementation

[0032] 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.

[0033] Please see Figures 1-7 The present invention provides a technical solution:

[0034] A script-based method for dynamic allocation of spaceborne distributed software missions includes the following steps:

[0035] S1. Design a script-based multi-task computing architecture to achieve heterogeneous parallel computing across multiple tasks;

[0036] S2. Migrate between multiple computing nodes for script-based software tasks, resulting in a script-based fine-grained backup strategy;

[0037] S3. Dynamically bind the script to the C language computing library, implement the virtual machine operation based on C language, and achieve stable operation of the script program;

[0038] S4. Perform mathematical modeling on multi-node computing tasks, obtain optimized resource allocation schemes based on genetic algorithms, complete computing tasks, and achieve maximum optimized computing performance;

[0039] Specifically, such as Figure 1 As shown, S11. The scripting language is run on a virtual machine. The script runs on multiple virtual machines with the same version, so that the script can be seamlessly migrated across multiple virtual machines.

[0040] S12. The virtual machine in step S11 is written based on standard C code. Different versions of the virtual machine are compiled and deployed according to different heterogeneous hardware platforms. The intermediate layer program after the script program is compiled can be dynamically migrated on different heterogeneous platforms, thus realizing multi-task heterogeneous parallel computing.

[0041] The script-based multi-task computing architecture consists of two parts: a master computing node and slave computing nodes. The master computing node is responsible for scheduling algorithm execution, storing script programs, monitoring the running status of slave computing nodes, and implementing backup strategies. The slave computing nodes include script virtual machines and C language computing libraries.

[0042] The script program is compiled on the ground, and the data stored in the hardware is the intermediate layer program. Based on the compilation strategy in point 3, the intermediate layer language is not bound to the virtual machine. After the master computing node completes the calculation of the allocation algorithm, it transmits the compiled script program to the slave computing node according to the evaluation of each computing task. After the slave computing node receives the script program, it waits for the input data. After the input data is received, the calculation begins.

[0043] Specifically, such as Figure 2 As shown in S21, the script program periodically sends virtual machine running status information to the master computing node, and the master computing node stores computing data and monitors the running status of the script program;

[0044] S22. When a compute node fails, the primary compute node cannot obtain compute node information and begins to restore the backup state information to the backup compute node. Since the restoration is based on the virtual machine state, the script execution stack can be restored, achieving instruction-level consistency in the restored state.

[0045] The slave compute node periodically sends virtual machine status information to the master compute node every second. This status information mainly includes runtime information such as the runtime stack, program counter (PC), function pointer (FP), function call level (FC), and function context backup, identifying the current running state. It also includes a global variable array, enabling the recovery of global data at the time of the computation task. Upon receiving the status information, the master compute node saves it. If the master compute node does not receive backup information within 3 seconds, it considers the slave compute node to have encountered an error, alerts the ground, and takes pre-defined actions according to a preset strategy, such as sending a hardware shutdown command to the faulty node. When a slave compute node fails, the master compute node initiates a backup slave compute node. First, it sends a compiled script to the slave compute node. Then, it sends the latest running status to the slave compute node to restore the task's running state. Upon receiving the status information, the slave compute node assigns the original program's status information to the current virtual machine and then starts running the virtual machine. The virtual machine will begin computation from the latest backup time point.

[0046] Specifically, S31. By parsing the script program, words are obtained to form a semantic expression tree. The semantic expression tree is then compiled to generate an intermediate layer language, thereby enabling the script program to run stably on a virtual machine.

[0047] The onboard script program consists of two modules: compilation and virtual machine. The script compilation includes three processes: word parsing, syntax analysis, and intermediate language compilation. Lexical parsing and syntax analysis are performed in parallel. Lexical parsing parses the current words from the script content, classifies the words, and generates semantic expressions based on the current word type or combinations of current and subsequent words. Each semantic expression has a different type. Based on the generation method of each semantic expression, a semantic expression tree is formed to complete the semantic analysis process. The specific processing process is shown in Table 2.

[0048] For example, in the script a = b + c + 1, first, the word 'a' is obtained, and its type is determined to be 'ID'. Then, semantic analysis is performed. Based on the expression expr_id, the next word '=' is obtained. Since it is not parentheses, it is determined that it is not an expr_call expression, and the current expression is an expr_binary expression. 'a' is converted to expr_id and becomes the left child node of the expression. The next word 'b' is obtained and converted to an expr_id expression. The next word '+' is obtained, and its priority is determined. The priority of the previous symbol and '+' is compared. The previous symbol has no priority, so the current operation symbol is '+'. The next word 'c' is obtained and converted to an expr_id expression. It forms a left node with the previous 'b' and '+'. Then, the next word '+' is obtained, and its priority is equal to the previous symbol '+'. The process continues. The next word '1' is obtained and converted to an expr_id expression. The next word is empty, so its priority is the lowest. Therefore, 'b + c' is the left child node, '+' is the operation, and '1' is the right child node, forming a semantic expression tree.

[0049] Table 1. Script Word Types

[0050]

[0051]

[0052]

[0053] Table 2 Script Semantic Expression Information Table

[0054]

[0055]

[0056]

[0057]

[0058]

[0059] The intermediate code compilation process involves traversing the semantic expression tree and escaping different expression nodes into different intermediate codes. The detailed compilation process for different types of expressions is shown in Table 3.

[0060] For example, see Figure 3The expression a = b + c + 1 is transformed into a semantic expression tree. After traversal, the right node expression b + c + 1 is processed first. It is found that the right node expression b + c + 1 is of type expr_binary and the operation is +. Then, its left node expression b + c is processed. It is found that the operation for processing the expression b + c is +. The left node b of expression b + c is processed, and GETLOCAL is written, and the index of the variable b is written. Then, the right node c of expression b + c is processed, and GETLOCAL is written, and the index of the variable c is written. The operation for processing the expression b + c is +, and PLUS is written. Then, the right node 1 of expression b + c + 1 is processed, and PUSH1 is written. The operation for processing the expression b + c + 1 is +, and PLUS is written. Finally, the left node a of expression a = b + c + 1 is processed, and SETLOCAL is written, and the index of the variable a is written.

[0061] Table 3. Information on the Expression Compilation Process

[0062]

[0063]

[0064] The intermediate code instruction information of the script is shown in Table 4. In order to execute the scripting language, the virtual machine includes a runtime stack, a global variable array, a global function array, an external function array, and a function call context array. The stack is an array structure used to store the execution state; most intermediate code instructions are executed on the stack. Global variables, functions, and external functions are stored uniformly, while local variables are stored on the stack. The intermediate code only stores the indices of global variables, functions, and external functions.

[0065] The function call context includes data records such as pc, fp, nargs, and fc. pc is the current execution address of the program, used to indicate the current execution location of the program; fp is the value of pc when the function is called; nargs is the number of function parameters; and fc is the nesting level of the called function.

[0066] When a function is called, the CALL instruction performs context protection, and the context protection logic is as follows:

[0067] a. The operation procedure for saving the scene is as follows: obtain the scene coefficient frame of fc, assign the current pc to frame.pc, the current fp to frame.fp, and the current nargs to frame.nargs; increment fc by 1; the current fp is equal to the current sp;

[0068] b. The operation procedure for restoring the scene is as follows: the current sp equals the current fp; fc is decremented by 1; the scene coefficient frame of fc (previously backed up) is obtained, the current sp is subtracted from frame.nargs, the current fp is subtracted from frame.fp, and the current pc equals frame.pc;

[0069] After entering the function to execute the code, N NULL values ​​will be pushed onto the stack according to the number N of local variables in the function, which will be used to store the local variables;

[0070] Table 4 Intermediate Code Instruction Information Table

[0071]

[0072]

[0073] For example, assuming b is initialized to 1, c is initialized to 2, and a is initialized to 0, the execution process of the expression a = b + c + 1 in the virtual machine is as follows: Figure 4 GETLOCAL, 1 means to retrieve the value 1 of b from the local variable memory; GETLOCAL, 2 means to retrieve the value 2 of c from the local variable memory; PLUS pops two numbers from the stack, adds them, and pushes them onto the stack; PUSH1 means to push 1 onto the stack; PLUS pops two numbers from the stack, adds them, and pushes them onto the stack; SETLOCAL, 0 pops data from the stack and assigns it to the 0th element of the local variable expression, i.e., variable a, completing the calculation.

[0074] Specifically, S41. Considering factors such as multi-node computing power, task execution time, task execution data, node transmission rate, and task dependencies, establish a directed acyclic graph of multiple tasks, clarify the constraints of task computation and the objective function of minimizing the parallel computing time of multiple tasks.

[0075] S42. Based on a multi-task computational mathematical model, the correspondence of task arrangement is used as the gene, and the inverse of the objective function is used as the fitness rate. Based on the genetic algorithm, each generation is sorted to select the emperor node and the duke node. The emperor node can be directly retained to the next generation. The duke node and the emperor node have the right to mate. After mating and mutation, individuals with high fitness rate replace individuals with low fitness rate in the previous generation until all replacements are completed. After 20 generations, the solution converges to the optimal solution.

[0076] Parallel computation on heterogeneous nodes across multiple tasks is represented by a DSG (Directed Acyclic Graph), where each node represents a computation task and edges represent data transmission. This acyclic graph has a start node and an end node, such as... Figure 5Node 0 is the start node (virtual node), nodes 1-6 are specific tasks, and node 7 is the end node (virtual node). Each task node can run on a different kernel. Due to heterogeneous computing, the running speed on each kernel is different, and the data transfer rate between nodes is also different. This design involves n computation nodes, m computation tasks, and l computational transfers. Task T... i At computing node C j The calculation time on CT ij The data size output by each edge is DATA k The data transfer rate between each pair of cores is different; let's set it to SPEED. j1-j2 Where j1 is the core code of the source node and j2 is the core code of the destination node. Each task has two time values, T_START. i and T_END i These represent the actual start and end times of the task, respectively. Each computational component has a variable called the earliest idle time, indicating that the kernel is already idle; this value is T_FREE. j ;

[0077] T_START i =MAX{T_END p +DATA k / SPEED cp-ci ...,T_FREE j} (0)

[0078] T_END i =T_START i +CT ij (1)

[0079] This method allows us to obtain the T_START of each node. i And through T_START i Able to determine T_END i However, in the current algorithm, each node's task has the same priority. If there is already a task on the current computing core, the start time of that node's task will be postponed, which introduces a certain degree of uncertainty. Therefore, an algorithm is needed to calculate the overall running time of the entire DSG. To address this problem, an algorithm is designed to calculate the running time of the entire DSG task graph based on the chronological order. The objective function is obtained as follows:

[0080] 1) Initialize the data for each node;

[0081] 2) Obtain the start node, set both T_START0 and T_END0 of the start node to 0, and insert it into the linked list according to the start time (ensuring that the start node is the earliest executed node);

[0082] 3) Obtain the node with the earliest start time from the linked list, compare the T_START of the node with the T_FREE of the computation kernel, if it is greater than or equal to T_FREE, keep T_START unchanged, calculate T_END, and then assign T_FREE to T_END.

[0083] 4) Traverse all child nodes of the node and check if all parent nodes of the child nodes have been calculated. If they have been calculated, calculate the T_END of each parent node. p +DATA k / SPEED cp-ci The maximum value is used to calculate T_START and T_END, and they are inserted into the linked list according to the start time (ensuring that the start is the earliest executed node). If the node has already been inserted, no insertion is performed.

[0084] 5) Repeat steps 3-4 until the linked list is empty, completing the calculation of all nodes;

[0085] By traversing all nodes T_FREE, the maximum value is obtained, which is the final time for the algorithm to complete, i.e., the solution to the objective function;

[0086] The computation time for each node in each task is as follows (unit: 10 milliseconds): Based on the optimization of multi-task computation using a genetic algorithm, the computation time for each node in each task is as follows:

[0087] Table 5 Calculation schedule for each task and node

[0088]

[0089]

[0090] Table 6. Data transfer rates for each computing core (unit: 10 milliseconds / KB)

[0091] Computing core Computing core 1 Computing core 2 Computing core 3 Computing core 1 0 1 3 Computing core 2 1 0 12 Computing core 3 3 12 0

[0092] Table 7. Data transfer volume between tasks (unit: KB)

[0093] Task Task 0 Task 1 Task 2 Task 3 Task 4 Task 5 Task 6 Task 7 Task 0 0 5 2 3 0 0 0 0 Task 1 0 0 0 0 5 0 0 0 Task 2 0 0 0 0 0 3 0 0 Task 3 0 0 0 0 0 4 6 0 Task 4 0 0 0 0 0 0 0 3 Task 5 0 0 0 0 5 0 0 2 Task 6 0 0 0 0 5 0 0 3.5 Task 7 0 0 0 0 0 0 0 0

[0094] Using these data as input, the computational relationship diagram of each node is as follows: Figure 5 The solution process of the genetic algorithm is as follows:

[0095] (1) Randomly generate generation_num individuals, and calculate the fitness value of each individual based on the fitness function of the individual (current algorithm fitness value = 1 / objective function value);

[0096] (2) Sort the individuals of generation_num according to their fitness values ​​and obtain the one with the highest fitness value (minimum objective function);

[0097] (3) Select king_num individuals (emperor nodes) with the highest fitness from generation_num individuals to survive to the next generation; randomly select nobel_num individuals (duke nodes) for mating. If the fitness function of the next generation is greater than that of the worst individual in the previous generation, the next generation replaces the individual with the worst fitness in the previous generation, until all individuals are replaced.

[0098] Determine if the current generation is greater than generation_time. If it is, exit the program. If it is less than, jump to step (3) to continue population reproduction.

[0099] Table 8 Algorithm Configuration Data

[0100] Serial number Data name Value Explanation 1. gene_num 12 Number of chromosomes. 2. king_num 3 How many individuals will directly live to the next generation 3. nobel_num 10 How many individuals can mate 4. generation_num 30 How many individuals in a generation 5. generation_time 20 How many generations in total

[0101] Chromosome composition

[0102] The data that needs to be optimized is which specific computing core each task should be assigned to. Each gene ranges from 0 to 2, and there are 12 genes in total, representing each task.

[0103] Individual initialization

[0104] For each task running on a specific core, the random number is controlled between 0 and 2.

[0105] Mating process

[0106] During the gene exchange process, each chromosome is traversed, generating a random number between 0 and 2. If the random number is 0, the average number of the parents' chromosomes is taken; if it is 1, the mother's value is taken; and if it is 2, the father's value is taken.

[0107] The mutation process involves randomly selecting six chromosomes for mutation, resulting in random variables within the range of (0-2).

[0108] ·Optimization results

[0109] The objective function converges to 10.08 milliseconds, yielding the optimal allocation solution. The algorithm optimization results are shown below. Figure 6 and Figure 7 .

[0110] In summary, the script-based dynamic allocation method for spaceborne distributed software tasks provided in this embodiment achieves cross-node heterogeneous computing by implementing script and script virtual machine technology, with fixed script virtual machines and algorithm libraries installed at each stage node; it realizes the transmission of script tasks between multiple virtual machines through script serialization technology, enabling dynamic deployment of scripts on heterogeneous nodes; and it obtains the optimal strategy for multi-node task computation time by modeling a multi-task and multi-node task-based directed acyclic graph and using a genetic algorithm with the shortest completion time as the objective function.

[0111] The above description of the embodiments enables those skilled in the art to make or use the invention. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the invention. Therefore, the invention is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A script-based method for dynamic allocation of spaceborne distributed software tasks, characterized in that, Includes the following steps: S1. Design a script-based multi-task computing architecture to achieve heterogeneous parallel computing across multiple tasks; S2. Migrate between multiple computing nodes for script-based software tasks, resulting in a script-based fine-grained backup strategy; S3. Dynamically bind the script to the C language computing library, implement the virtual machine operation based on C language, and achieve stable operation of the script program; S4. Perform mathematical modeling on multi-node computing tasks, obtain optimized resource allocation schemes based on genetic algorithms, complete computing tasks, and achieve maximum optimized computing performance; The method for implementing multi-task heterogeneous parallel computing in step S1 specifically includes the following steps: S11. Run the scripting language on a virtual machine. The script runs on multiple virtual machines with the same version, so that the script can be seamlessly migrated across multiple virtual machines. S12. The virtual machine in step S11 is written based on standard C code. Different versions of the virtual machine are compiled and deployed according to different heterogeneous hardware platforms. The intermediate layer program after the script program is compiled can be dynamically migrated on different heterogeneous platforms, thus realizing multi-task heterogeneous parallel computing. The method for optimizing computational performance in step S4 specifically includes the following steps: S41. Considering factors such as multi-node computing power, task execution time, task execution data, node transmission rate, and task dependencies, establish a directed acyclic graph of multiple tasks, clarify the constraints of task computation and the objective function of minimizing the parallel computation time of multiple tasks. S42. Based on a multi-task computational mathematical model, the correspondence of task arrangements is used as genes, and the inverse of the objective function is used as the fitness rate. Based on a genetic algorithm, each generation is sorted, and emperor nodes and duke nodes are selected. Emperor nodes can be directly retained to the next generation, and duke nodes and emperor nodes have the right to mate. After mating and mutation, individuals with high fitness rates replace individuals with low fitness rates in the previous generation until all replacements are completed. After 20 generations, the solution converges to the optimal solution.

2. The script-based dynamic allocation method for spaceborne distributed software tasks according to claim 1, characterized in that, The method for implementing step S2 specifically includes the following steps: S21. The script program periodically sends virtual machine running status information to the master computing node, and the master computing node stores computing data and monitors the running status of the script program. S22. When a compute node fails, the primary compute node cannot obtain compute node information and begins to restore the backup state information to the backup compute node. Since the restoration is based on the virtual machine state, the script execution stack can be restored, achieving instruction-level consistency in the restored state.

3. The script-based dynamic allocation method for spaceborne distributed software tasks according to claim 1, characterized in that, The method for achieving stable operation of the script program in step S3 specifically includes the following steps: S31. By parsing the script program, words are obtained to form a semantic expression tree. The semantic expression tree is then compiled to generate an intermediate language, thereby enabling the script program to run stably on a virtual machine.

Images