Incremental update method of satellite-borne software based on embedded GPU and on-board processing platform

Abstract

The invention discloses an incremental update method for satellite-borne software based on embedded GPU and a satellite-borne processing platform, wherein the method comprises: a main control module of the satellite-borne processing platform receives a patch package and an update instruction sent by a ground processing platform, and sends the patch package and the update instruction to any GPU unit, wherein the differential code in the patch package is an incremental executable program or an incremental source code, and the update instruction includes the old version number and the new version number of the specified software; the GPU unit receiving the update instruction generates an executable program corresponding to the new version number of the specified software according to the patch package and the code corresponding to the old version number of the specified software, and compresses the executable program corresponding to the new version number and transmits it to the main control module; the main control module sends the compressed executable program and the software deployment instruction to the remaining GPU units; and the remaining GPU units decompress the compressed executable program to complete the update. The invention can reduce the requirement for uplink bandwidth and improve the reliability and flexibility of satellite-borne software updates.

Description

Technical Field

[0001] The present invention relates to the technical field of satellite software management, and in particular to a satellite-borne software incremental update method based on an embedded GPU and an on-board processing platform. Background Art

[0002] In recent years, with the increasing timeliness requirements of space-based information services, the realization of data processing and information services by remote sensing satellites on orbit has gradually become a research hotspot. Embedded GPU processors are very suitable for real-time processing of high-density remote sensing data on orbit due to their strong computing power, low power consumption, and easy programming. Since it is impossible to fully verify the effectiveness of the processing algorithm using the real raw data generated by the remote sensing payload before the satellite is launched, and the user's needs are changing, and the data processing and target recognition methods are constantly improving, the use of unchanging data processing processes and methods cannot meet the needs of real-time processing of remote sensing data on orbit. To this end, the on-orbit data processing system must be able to support software updates and system upgrades, so as to achieve the unification of the satellite-ground technical system and maintain the vitality of the on-orbit data processing system.

[0003] The existing on-orbit software update algorithm is mainly aimed at FPGA and DSP chips. It uses the method of injecting the complete on-board software into the satellite, overwriting the original program, and restarting the system to complete the software update. This type of method has no specific requirements for on-board software, but each update requires uploading the entire software program. The update data packet is large, which wastes a lot of uplink bandwidth. In order to avoid the transmission of software update packages occupying the uplink for a long time, some researchers have proposed a strategy to decompose the software into multiple modules, and use the loading technology of the operating system to replace the module-level patch to complete the software update. This type of method can reduce the amount of uploaded data, does not need to upload the complete software program, and reduces the occupancy time of the uplink channel, but requires the operating system to have a module loading function, and needs to determine in advance whether the module can be updated, which affects the flexibility of the update operation.

[0004] Therefore, how to provide a satellite-borne software incremental update method and an on-board processing platform suitable for embedded GPUs to reduce update data packets, lower the requirements for uplink bandwidth, and at the same time improve the reliability and flexibility of satellite-borne software updates has become a technical problem that needs to be urgently solved in this field. Summary of the invention

[0005] The purpose of the present invention is to provide a satellite-borne software incremental update method based on embedded GPU and an on-board processing platform to reduce update data packets, lower the requirements for uplink bandwidth, and improve the reliability and flexibility of satellite-borne software updates.

[0006] To achieve the above object, an embodiment of the present invention provides a satellite-borne software incremental update method based on an embedded GPU, the method comprising:

[0007] The main control module of the on-board processing platform receives the patch package and update instruction sent by the ground processing platform, and sends the patch package and update instruction to a randomly selected GPU unit in the on-board processing platform, wherein the differential code in the patch package is an incremental executable program or an incremental source code, and the update instruction includes an old version number and a new version number of the specified software;

[0008] The GPU unit that receives the update instruction generates an executable program corresponding to the new version number of the specified software according to the patch package and the code corresponding to the old version number of the specified software, and compresses the executable program corresponding to the new version number and transmits it to the main control module;

[0009] The main control module sends the compressed executable program and software deployment instructions to the remaining GPU units in the onboard processing platform;

[0010] The remaining GPU units decompress the compressed executable program to complete the update of the specified software in all GPU units in the on-board processing platform.

[0011] In one embodiment of the present invention, the patch package containing the incremental executable program is generated by a BSDiff algorithm, and the patch package containing the incremental source code is generated by a differential code generator.

[0012] In one embodiment of the present invention, the patch package is transmitted based on the CFDP transmission protocol.

[0013] In one embodiment of the present invention, after receiving the patch package, the main control module of the on-board processing platform further includes:

[0014] Assembling and verifying the patch package;

[0015] If the verification fails, a data retransmission instruction is sent to the ground processing platform. If the verification is correct, a correct reception instruction is sent to the ground processing platform, so that the ground processing platform sends the update instruction to the main control module of the onboard processing platform.

[0016] In one embodiment of the present invention, generating an executable program corresponding to a new version number of the specified software according to the patch package and the code corresponding to the old version number of the specified software includes:

[0017] Determine whether the patch package is complete. If it is complete, copy the code corresponding to the old version number to the path corresponding to the new version number;

[0018] Extracting differential code from the patch package;

[0019] When the differential code is an incremental executable program, an executable program corresponding to the new version number is generated based on the executable program corresponding to the old version number and the incremental executable program; when the differential code is an incremental source code, a source code corresponding to the new version number is generated based on the source code corresponding to the old version number and the incremental source code, and the source code corresponding to the new version number is compiled online to generate an executable program corresponding to the new version number.

[0020] In one embodiment of the present invention, after the GPU unit generates the executable program corresponding to the new version number, or after decompressing the executable program corresponding to the new version number, the GPU unit further includes:

[0021] The executable program corresponding to the new version number is copied to a backup file, wherein the backup file includes a backup of each software and a public dependent library; wherein,

[0022] The backup directory of each software includes: executable programs, source codes, private dependency libraries of each version of the software, and patch packages used for each software update;

[0023] The backup directory of the public dependency library includes: each currently used public dependency library, all versions of each public dependency library, and the patch package used for each update of the public dependency library.

[0024] In one embodiment of the present invention, after the remaining GPU units complete the software update, the method further includes:

[0025] The remaining GPU units send a deployment completion instruction to the main control module of the on-board processing platform, so that the main control module sends a software online instruction to the on-board processing platform;

[0026] After the main control module receives the software online instruction, it checks the software version status and deployment status of each GPU unit, and executes the software online instruction if the check is correct;

[0027] The executing the software online instruction comprises:

[0028] Traversing the saved software process template library, and modifying the running version information of the process template that needs to use the specified software in the data processing process, so as to modify the old version number of the specified software in the process template to the new version number;

[0029] Sending online success information to the ground processing platform.

[0030] In one embodiment of the present invention, the method further includes:

[0031] When a running error occurs after the software is launched, or a predetermined result cannot be output, the main control module receives a software rollback instruction from the ground processing platform, wherein the software rollback instruction includes the software version number to be rolled back to;

[0032] The main control module modifies the version number of the specified software in the process template to the software version number that needs to be rolled back.

[0033] The embodiment of the present invention further provides an on-board processing platform, comprising: a main control module, and a plurality of GPU units capable of performing data transmission with the main control module;

[0034] The main control module is used to receive the patch package and update instruction sent by the ground processing platform, and send the patch package and update instruction to a GPU unit randomly selected from the multiple GPU units; the differential code in the patch package is an incremental executable program or an incremental source code, and the update instruction includes an old version number and a new version number of the specified software;

[0035] The GPU unit that receives the update instruction is used to generate an executable program corresponding to the new version number of the specified software according to the patch package and the code corresponding to the old version number of the specified software, and compress the executable program corresponding to the new version number and transmit it to the main control module;

[0036] The main control module is also used to send the compressed executable program and software deployment instructions to the remaining GPU units in the onboard processing platform;

[0037] The remaining GPU units are used to decompress the compressed executable program to complete the update of the specified software in all GPU units in the on-board processing platform.

[0038] It can be seen from the technical solution provided by the present invention that the present invention can adopt two update strategies, namely incremental source code update and incremental executable program update, to meet the software update requirements in different situations, thereby effectively compressing the size of the update patch package, reducing the requirement for uplink bandwidth, and having strong flexibility. At the same time, the method provided by the present invention also supports software rollback, thereby ensuring the reliability of onboard software updates. BRIEF DESCRIPTION OF THE DRAWINGS

[0039] In order to more clearly illustrate the technical solutions in the present invention or the prior art, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments recorded in the present invention. For ordinary technicians in this field, the remaining drawings can be obtained based on these drawings without paying any creative work.

[0040] Figure 1Schematic diagram of differential code annotation provided by an embodiment of the present invention;

[0041] Figure 2 is a hardware system architecture diagram of an on-board processing platform provided by an embodiment of the present invention;

[0042] Figure 3 It is a flow chart of an on-orbit incremental update method of satellite-borne software based on an embedded GPU provided by an embodiment of the present invention;

[0043] Figure 4 is a flow chart of the interaction between the main control module and each GPU unit provided by an embodiment of the present invention;

[0044] Figure 5 It is a backup directory in the GPU unit provided by an embodiment of the present invention. DETAILED DESCRIPTION

[0045] The technical solution of the present invention will be described in detail below in conjunction with the accompanying drawings and specific implementation methods. It should be understood that these implementation methods are only used to illustrate the present invention and are not used to limit the scope of the present invention. After reading the present invention, various equivalent forms of modifications to the present invention by those skilled in the art all fall within the scope defined by the claims attached to the present invention.

[0046] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as those commonly understood by those skilled in the art of the present invention. The terms used in the specification of the present invention are only for the purpose of describing specific embodiments and are not intended to limit the present invention.

[0047] Since various problems may occur during the actual operation of the processing software and application requirements may change, developers need to modify the original software version, obtain the new version of the software and test and verify it. Figure 1 FIG. 1 is a schematic diagram of differential code annotation provided by an embodiment of the present invention. A differential patch package is generated on a ground processing platform and transmitted to an onboard processing platform, thereby incrementally updating the old version of the software.

[0048] Specifically, the patch package can be made in two ways: incremental executable program patch package and incremental source code patch package. The basis for selection is the size of the software update and the complexity of software compilation. Usually, remote sensing data processing software is more complex, with more dependent libraries used in the development process and longer software compilation time. Therefore, the incremental executable program patch method can generally be used. However, if the patch package is still large after generating the incremental executable program patch, the incremental source code patch method can be used to minimize the size of the patch package.

[0049] When making an incremental executable program patch package, the ground processing platform obtains the old and new versions of the software executable program and generates a patch file by comparing the program differences. In traditional difference update algorithms, it is usually required that the binary comparison results of the new and old files remain completely consistent, but this will result in a larger update package. The update of the processing algorithm software usually involves local modification of the source code, and the updated code will produce regular movement of the entire block. After the source code file is compiled, most of the target code generated by the same code is the same, and the small part of the target code address displacement data that needs to be updated also has the same displacement. Taking this feature into account, the incremental update algorithm BSDiff algorithm can be used to generate a patch package. The BSDiff algorithm mainly uses suffix sorting or hashing algorithms to form a string index of the old version of the code, and then uses the index to compare the new version of the code to generate difference files and new files, and finally combines the necessary index control information to compress them into a patch package.

[0050] When making an incremental source code patch package, the ground processing platform obtains the new and old versions of the software source code, calls the differential code generator to compare the two versions of the code, and obtains the incremental differential code. The incremental differential code is a direct comparison of the old and new codes, showing the differences in the code line by line, including the addition, deletion, and modification of the code. The differential code generator can also directly compare two folders, list the addition and deletion of files, as well as the content changes of the same files, and finally generate the differential code. The software parameter template files and running resource requirement files are also compared using the differential code generator to generate differential auxiliary files, and the above files are packaged to generate a patch package.

[0051] Specifically, after the patch package is generated, the patch package is uploaded through the measurement and control uplink. The reliable transmission of the patch package can adopt the CFDP (CCSDS File Delivery Protocol) protocol developed by the Consultative Committee for Space Data System (CCSDS), which requires that the transmitted data is in the form of files and uses a unified standard transmission protocol. When the patch package is large, the CFDP protocol supports uploading by breakpoint resumption, uploading part of the data each time the satellite passes by until all the data is uploaded.

[0052] refer to Figure 2As shown, it is a hardware system architecture diagram of the on-board processing platform provided by an embodiment of the present invention. The hardware system can adopt the VPX architecture, which is mainly composed of a main control module, multiple co-processing boards (GPU units), and a storage board, and has the characteristics of high performance, low power consumption, and scalability. The main control module adopts a SOC chip, which runs a LINUX operating system on an embedded ARM hard core, and runs an on-orbit processing software platform on it to achieve task management, data scheduling, upstream updates, communication interaction, and other tasks. Each GPU unit can initiate data processing under the scheduling of the main control module, and the source code types supported by the embedded GPU unit environment include C / C++ and CUDA.

[0053] refer to Figure 3 As shown, a satellite-borne software incremental update method based on an embedded GPU provided by an embodiment of the present invention may include the following steps:

[0054] S1: The main control module of the on-board processing platform receives the patch package and update instruction sent by the ground processing platform, and sends the patch package and update instruction to a randomly selected GPU unit in the on-board processing platform, where the differential code in the patch package is an incremental executable program or incremental source code, and the update instruction contains the old version number and the new version number of the specified software.

[0055] S2: The GPU unit that receives the update instruction generates an executable program corresponding to the new version number of the specified software according to the patch package and the code corresponding to the old version number of the specified software, and compresses the executable program corresponding to the new version number and transmits it to the main control module.

[0056] S3: The main control module sends the compressed executable program and software deployment instructions to the remaining GPU units in the onboard processing platform.

[0057] S4: The remaining GPU units decompress the compressed executable program to complete the update of the specified software in all GPU units in the onboard processing platform.

[0058] Specifically, after receiving the patch package, the main control module of the on-board processing platform further includes:

[0059] Assembling and verifying the patch package;

[0060] If the verification fails, a data retransmission instruction is sent to the ground processing platform. If the verification is correct, a correct reception instruction is sent to the ground processing platform, so that the ground processing platform sends the update instruction to the main control module of the onboard processing platform.

[0061] refer to Figure 4FIG. 1 is a flowchart of the interaction between the main control module and each GPU unit provided by an embodiment of the present invention. Figure 4 It can be seen that the executable program corresponding to the new version number of the specified software is generated through the following steps:

[0062] Determine whether the patch package is complete. If it is complete, copy the code corresponding to the old version number to the path corresponding to the new version number;

[0063] Extracting differential code from the patch package;

[0064] When the differential code is an incremental executable program, an executable program corresponding to the new version number is generated according to the executable program corresponding to the old version number and the incremental executable program; when the differential code is an incremental source code, a source code corresponding to the new version number is generated according to the source code corresponding to the old version number and the incremental source code, and the source code corresponding to the new version number is compiled online to generate an executable program corresponding to the new version number. For example, online compilation can be performed according to a makefile file contained in the source code.

[0065] Specifically, after the GPU unit generates the executable program corresponding to the new version number, or after decompressing the executable program corresponding to the new version number, the GPU unit further includes:

[0066] The executable program corresponding to the new version number is copied to a backup file, wherein the backup file includes a backup of each software and a public dependent library; wherein, reference Figure 4 As shown, it is the backup directory in the GPU unit provided by the embodiment of the present invention. It can be seen that the backup directory of each software includes: the executable program, source code, private dependency library of each version of the software and the patch package used for each software update; the backup directory of the public dependency library includes: each public dependency library currently in use, all versions of each public dependency library and the patch package used for each public dependency library update.

[0067] Specifically, after the remaining GPU units complete the software update, the method further includes:

[0068] The remaining GPU units send a deployment completion instruction to the main control module of the on-board processing platform, so that the main control module sends a software online instruction to the on-board processing platform;

[0069] After the main control module receives the software online instruction, it checks the software version status and deployment status of each GPU unit, and executes the software online instruction if the check is correct;

[0070] The executing the software online instruction comprises:

[0071] Traversing the saved software process template library, and modifying the running version information of the process template that needs to use the specified software in the data processing process, so as to modify the old version number of the specified software in the process template to the new version number;

[0072] Sending online success information to the ground processing platform.

[0073] Specifically, the method further includes:

[0074] When a running error occurs after the software is launched, or a predetermined result cannot be output, the main control module receives a software rollback instruction from the ground processing platform, wherein the software rollback instruction includes the software version number to be rolled back to;

[0075] The main control module modifies the version number of the specified software in the process template to the software version number that needs to be rolled back.

[0076] The embodiment of the present invention further provides an on-board processing platform, comprising: a main control module, and a plurality of GPU units capable of performing data transmission with the main control module;

[0077] The main control module is used to receive the patch package and update instruction sent by the ground processing platform, and send the patch package and update instruction to a GPU unit randomly selected from the multiple GPU units; the differential code in the patch package is an incremental executable program or an incremental source code, and the update instruction includes an old version number and a new version number of the specified software;

[0078] The GPU unit that receives the update instruction is used to generate an executable program corresponding to the new version number of the specified software according to the patch package and the code corresponding to the old version number of the specified software, and compress the executable program corresponding to the new version number and transmit it to the main control module;

[0079] The main control module is also used to send the compressed executable program and software deployment instructions to the remaining GPU units in the onboard processing platform;

[0080] The remaining GPU units are used to decompress the compressed executable program to complete the update of the specified software in all GPU units in the on-board processing platform.

[0081] The above-mentioned various embodiments in this specification are described in a progressive manner, and the same or similar parts between the various embodiments can be referenced to each other. Each embodiment focuses on the differences from the other embodiments.

[0082] The above are only several embodiments of the present invention. Although the embodiments disclosed by the present invention are as above, the above contents are only embodiments adopted for facilitating understanding of the technical solution of the present invention, and are not used to limit the present invention. Any technician in the technical field to which the present invention belongs can make any modification and change in the form and details of the embodiments without departing from the spirit and scope disclosed by the present invention, but the patent protection scope of the present invention shall still be subject to the scope defined by the attached claims.

Claims

1. A method for incremental updating of onboard software based on embedded GPU, characterized in that: include: The main control module of the on-board processing platform receives the patch package and update instruction sent by the ground processing platform, and sends the patch package and update instruction to a randomly selected GPU unit in the on-board processing platform, wherein the differential code in the patch package is an incremental executable program or an incremental source code, and the update instruction includes an old version number and a new version number of the specified software; The GPU unit that receives the update instruction generates an executable program corresponding to the new version number of the specified software according to the patch package and the code corresponding to the old version number of the specified software, and compresses the executable program corresponding to the new version number and transmits it to the main control module, wherein the generating the executable program corresponding to the new version number of the specified software according to the patch package and the code corresponding to the old version number of the specified software includes: judging whether the patch package is complete, and if complete, copying the code corresponding to the old version number to the path corresponding to the new version number; extracting the differential code from the patch package; when the differential code is an incremental executable program, generating the executable program corresponding to the new version number according to the executable program corresponding to the old version number and the incremental executable program; when the differential code is an incremental source code, generating the source code corresponding to the new version number according to the source code corresponding to the old version number and the incremental source code, and compiling the source code corresponding to the new version number online to generate the executable program corresponding to the new version number; The main control module sends the compressed executable program and software deployment instructions to the remaining GPU units in the onboard processing platform; The remaining GPU units decompress the compressed executable program to complete the update of the specified software in all GPU units in the onboard processing platform; The remaining GPU units send a deployment completion instruction to the main control module of the on-board processing platform, so that the main control module sends a software online instruction to the on-board processing platform; After the main control module receives the software online instruction, it checks the software version status and deployment status of each GPU unit, and executes the software online instruction if the check is correct; The executing the software online instruction comprises: Traversing the saved software process template library, and modifying the running version information of the process template that needs to use the specified software in the data processing process, so as to modify the old version number of the specified software in the process template to the new version number; Sending online success information to the ground processing platform; When a running error occurs after the software is launched, or a predetermined result cannot be output, the main control module receives a software rollback instruction from the ground processing platform, wherein the software rollback instruction includes the software version number to be rolled back to; The main control module modifies the version number of the specified software in the process template to the software version number that needs to be rolled back.

2. The method according to claim 1, characterized in that The patch package containing the incremental executable program is generated by the BSDiff algorithm, and the patch package containing the incremental source code is generated by the differential code generator.

3. The method according to claim 1, characterized in that The patch package is transmitted based on the CFDP transmission protocol.

4. The method according to claim 1, characterized in that: After receiving the patch package, the main control module of the on-board processing platform further includes: Assembling and verifying the patch package; If the verification fails, a data retransmission instruction is sent to the ground processing platform. If the verification is correct, a correct reception instruction is sent to the ground processing platform, so that the ground processing platform sends the update instruction to the main control module of the onboard processing platform.

5. The method according to claim 1, characterized in that After the GPU unit generates the executable program corresponding to the new version number, or after decompressing the executable program corresponding to the new version number, the GPU unit further includes: The executable program corresponding to the new version number is copied to a backup file, wherein the backup file includes a backup of each software and a public dependent library; wherein, The backup directory of each software includes: executable programs, source codes, private dependency libraries of each version of the software, and patch packages used for each software update; The backup directory of the public dependency library includes: each currently used public dependency library, all versions of each public dependency library, and the patch package used for each update of the public dependency library.

6. An on-board processing platform, used to implement the on-board software incremental update method based on embedded GPU according to any one of claims 1 to 5, characterized in that: include: A main control module, and a plurality of GPU units capable of performing data transmission with the main control module; The main control module is used to receive the patch package and update instruction sent by the ground processing platform, and send the patch package and update instruction to a GPU unit randomly selected from the multiple GPU units; the differential code in the patch package is an incremental executable program or an incremental source code, and the update instruction includes an old version number and a new version number of the specified software; The GPU unit that receives the update instruction is used to generate an executable program corresponding to the new version number of the specified software according to the patch package and the code corresponding to the old version number of the specified software, and compress the executable program corresponding to the new version number and transmit it to the main control module; The main control module is also used to send the compressed executable program and software deployment instructions to the remaining GPU units in the onboard processing platform; The remaining GPU units are used to decompress the compressed executable program to complete the update of the specified software in all GPU units in the on-board processing platform.

Images