Container mirror image construction method, container mirror image operation method, equipment and medium

Abstract

The invention provides a container mirror image construction method, a container mirror image operation method, equipment and a medium. The container mirror image construction method comprises the following steps: acquiring an original container mirror image of a target software development kit under a first instruction set architecture; determining a target component set from an original container mirror image of the target software development kit, wherein a target component in the target component set supports running under a second instruction set architecture; and based on the target component set, constructing a target container mirror image of the target software development kit under the first instruction set architecture and a target container mirror image of the target software development kit under the second instruction set architecture. Based on the scheme of the invention, the compatibility of the software development kit to different instruction set architectures can be improved.

Description

Technical Field

[0001] This application relates to the field of computer technology, and in particular, to a method for constructing a container image, a method for running a container image, a device, and a medium. Background Art

[0002] A Software Development Kit (SDK) refers to a software package provided for software development activities. For example, some software development kits include various tools, library files, documents, sample codes, etc. required for software development. In the related art, software development kits are usually designed for a specific instruction set architecture, thus restricting their operation to computing platforms with a specific instruction set architecture. With the increasing demand for cross-computing platform development, it is urgent to improve the compatibility of software development kits with different instruction set architectures. Summary of the Invention

[0003] Embodiments of this application provide a method for constructing a container image, a method for running a container image, a device, and a medium.

[0004] In a first aspect of the embodiments of this application, a method for constructing a container image is provided. The method for constructing a container image includes:

[0005] Obtain an original container image of a target software development kit under a first instruction set architecture;

[0006] Determine a target component set from the original container image of the target software development kit, where the target components in the target component set support running under a second instruction set architecture;

[0007] Based on the target component set, construct a target container image of the target software development kit under the first instruction set architecture and a target container image of the target software development kit under the second instruction set architecture.

[0008] In an optional embodiment of the first aspect of this application, determining a target component set from the original container image of the target software development kit includes: creating a test container based on the second instruction set architecture; determining a set of components to be tested in the original container image of the target software development kit; for any component to be tested in the set of components to be tested, perform a running test on the component to be tested in the test container to obtain a running test result corresponding to the component to be tested; if the running test result corresponding to the component to be tested indicates that the component to be tested supports running under the second instruction set architecture, then determine the component to be tested as a first target component in the target component set, and the first target component is one of the target components in the target component set.

[0009] In an alternative embodiment of the first aspect of the present application, determining a set of components to be tested in the original container image of the target software development kit includes: determining the image hierarchy of the original container image of the target software development kit based on a container image history viewing instruction; and determining the set of components to be tested in the original container image of the target software development kit based on the image hierarchy.

[0010] In an alternative embodiment of the first aspect of the present application, determining a set of target components from the original container image of the target software development kit includes: determining a first acceleration component that supports running under a first instruction set architecture from the original container image of the target software development kit, where the acceleration type of the first acceleration component is hardware acceleration; based on the first acceleration component, determining a second acceleration component that supports running under a second instruction set architecture, where the acceleration type of the second acceleration component is hardware acceleration or software acceleration; and determining the second acceleration component as the second target component in the set of target components, where the second target component is one of the target components in the set of target components.

[0011] In an alternative embodiment of the first aspect of the present application, constructing a target container image of the target software development kit under a first instruction set architecture and a target container image of the target software development kit under a second instruction set architecture based on the set of target components includes: generating a container image construction script based on the set of target components and the set of general components in the target software development kit that are decoupled from physical hardware and instruction set architectures; and constructing a target container image of the target software development kit under a first instruction set architecture and a target container image of the target software development kit under a second instruction set architecture based on the container image construction script.

[0012] A second aspect of the embodiments of the present application provides a method for running a container image, and the method for running a container image includes:

[0013] In response to a running instruction of the container image, determining a target instruction set architecture of the current computing platform, where the target instruction set architecture is a first instruction set architecture or a second instruction set architecture;

[0014] Obtaining a target container image of the target software development kit under the target instruction set architecture, where the target container image of the target software development kit under the target instruction set architecture is constructed based on any one of the embodiments of the container image construction method of the present application;

[0015] On the current computing platform, running the target container image of the target software development kit under the target instruction set architecture.

[0016] In an optional embodiment of the second aspect of the present application, the container image running method further includes: obtaining a dependency file corresponding to a target software development kit; configuring the dependency file corresponding to the target software development kit on the current computing platform.

[0017] In an optional embodiment of the second aspect of the present application, the container image running method further includes: if a third acceleration component of the current computing platform does not exist in the target container image of the target software development kit under the target instruction set architecture, determining an acceleration object corresponding to the third acceleration component; obtaining a fourth acceleration component, where the acceleration object corresponding to the fourth acceleration component is the same as the acceleration object corresponding to the third acceleration component; running the fourth acceleration component on the current computing platform.

[0018] The third aspect of the embodiments of the present application provides a computer device, including: a memory and a processor, where the memory stores a computer program, and when the processor executes the computer program, the steps of any of the above methods are implemented.

[0019] The fourth aspect of the embodiments of the present application provides a computer-readable storage medium, on which a computer program is stored, and when the computer program is executed by a processor, the steps of any of the above methods are implemented. Description of the Drawings

[0020] The drawings described herein are used to provide a further understanding of the present application, and constitute a part of the present application. The illustrative embodiments of the present application and their descriptions are used to explain the present application and do not constitute an improper limitation of the present application. In the drawings:

[0021] Figure 1 It is a flowchart of a container image building method provided by an embodiment of the present application;

[0022] Figure 2 It is a flowchart of determining a target component set provided by an embodiment of the present application;

[0023] Figure 3 It is a flowchart of determining a target component set provided by an embodiment of the present application;

[0024] Figure 4 It is a flowchart of building a target container image provided by an embodiment of the present application;

[0025] Figure 5 It is a flowchart of a container image running method provided by an embodiment of the present application;

[0026] Figure 6 It is a flowchart of configuring a dependency file provided by an embodiment of the present application;

[0027] Figure 7Flowchart of the operation acceleration component provided by an embodiment of the present application;

[0028] Figure 8 Schematic structural diagram of a computer device provided by an embodiment of the present application. Detailed implementation manners

[0029] Next, the technical solutions in the present application will be clearly and elaborately described in conjunction with the accompanying drawings. Among them, in the description of the embodiments of the present application, unless otherwise specified, " / " means "or". For example, A / B may represent A or B. The "and / or" in the text is only a description of the association relationship of the associated objects, indicating that there can be three relationships. For example, A and / or B can represent: A exists alone, A and B exist simultaneously, and B exists alone. In addition, in the description of the embodiments of the present application, "a plurality" means two or more than two.

[0030] Hereinafter, the terms "first" and "second" are only used for descriptive purposes and cannot be understood as implying or suggesting relative importance or implicitly indicating the quantity of the indicated technical features. Thus, the features defined with "first" and "second" may explicitly or implicitly include one or more of such features.

[0031] A software development kit refers to a software package provided for software development activities. For example, some software development kits contain various tools, library files, documents, sample codes, etc. required for developing software. In the related art, software development kits are usually designed for specific instruction set architectures, thus restricting their operation to computing platforms with specific instruction set architectures only. Among them, an instruction set architecture refers to a set of instructions that a computer processor can understand and execute, and these instructions define the basic operations and data processing methods that the processor can execute. For example, the types of instruction set architectures may be x86 architecture, ARM architecture, RISC-V architecture, etc. Each instruction set architecture has its corresponding instruction set and characteristics.

[0032] Exemplarily, a software development kit based on the x86 architecture cannot run directly on a computing platform with the ARM architecture because the instruction sets of the x86 architecture and the ARM architecture are incompatible, resulting in software under the x86 architecture being unable to recognize and execute instructions of the ARM architecture. Similarly, a software development kit based on the ARM architecture cannot run directly on a computing platform with the x86 architecture for the same reason of instruction set incompatibility. This difference in instruction set architectures is one of the main reasons for the cross-platform compatibility problem of software development kits. Therefore, with the increasing demand for cross-computing platform development, it is urgent to improve the compatibility of software development kits with different instruction set architectures.

[0033] Next, in conjunction with Figure 1 - Figure 7, a detailed introduction to the container image building method provided by the embodiments of this application is given.

[0034] Please refer to Figure 1 , Figure 1 which is a schematic flowchart of a container image building method provided by an embodiment of this application. As Figure 1 shown, the method of the embodiments of this application may include the following steps S101 - S103.

[0035] S101, obtain the original container image of the target software development kit under the first instruction set architecture.

[0036] Specifically, the target software development kit involved in this embodiment refers to a type of software development kit that includes various tools, library files, documents, sample codes, etc. required for software development. The first instruction set architecture is a type of instruction set architecture that defines a set of instructions that a computer processor can understand and execute, and these instructions specify the basic operations and data processing methods that the processor can perform. The original container image of the target software development kit under the first instruction set architecture refers to the initial container image built for the target software development kit under the first instruction set architecture (such as x86 or ARM), and this original container image contains all the dependencies and configurations required to run under the first instruction set architecture.

[0037] Regarding the process of obtaining the original container image of the target software development kit under the first instruction set architecture, in some possible implementation manners, the specific types of the target software development kit and the first instruction set architecture can be determined first. Then, access the repository or storage of the target software development kit to find the original container image corresponding to the first instruction set architecture. Finally, download and save this original container image to the local environment for subsequent mirror analysis and component extraction. In some possible implementation manners, the original container image of the target software development kit under the first instruction set architecture can be generated through a container image building tool. For example, generate a Dockerfile file (a container image building script) as the container image building tool, and this Dockerfile file defines the building process of the original container image. Then, use the Docker Build command (a container image building command) to execute the Dockerfile file, thereby building the original container image of the target software development kit under the first instruction set architecture.

[0038] Exemplarily, the target software development kit may be the NVIDIA JetPack SDK. The NVIDIA JetPack SDK is a comprehensive set of software development kits provided by NVIDIA. It integrates deep learning acceleration libraries such as CUDA, cuDNN, and TensorRT, as well as NVIDIA drivers and other development tools. Exemplarily, the first instruction set architecture may be the ARM architecture. For example, the obtained original container image of the NVIDIA JetPack SDK under the ARM architecture contains all the dependencies and configurations required to run the NVIDIA JetPack SDK on a computing platform based on the ARM architecture.

[0039] S102. Determine a target component set from the original container image of the target software development kit. The target components in the target component set support running under the second instruction set architecture.

[0040] Specifically, the target component set involved in this embodiment includes at least one target component in the original container image of the target software development kit. That the target components in the target component set support running under the second instruction set architecture means that the target components can be normally executed on a processor with the second instruction set architecture and do not require major modifications or rewrites to the target components themselves. The types corresponding to the target components may include, but are not limited to, library files at the operating system level, the running environment required for application execution, implementation libraries for specific functions (such as mathematical model libraries, graphics libraries, etc.), development tools, and other necessary dependencies.

[0041] Regarding the process of determining the target component set from the original container image of the target software development kit, in some possible implementation manners, it is possible to layer-by-layer analyze the original container image of the target software development kit under the first instruction set architecture, identify some target components therein that support running under the second instruction set architecture, and further form a target component set based on the identified part of the target components. In some possible implementation manners, it is possible to determine the part of the components in the original container image of the target software development kit under the first instruction set architecture that do not support running under the second instruction set architecture, perform rewriting, replacement, or other processing on this part of the components to obtain the corresponding part of the target components that support running under the second instruction set architecture, and further form a target component set based on this part of the target components.

[0042] Exemplarily, the target software development kit may be the NVIDIA JetPack SDK, the first instruction set architecture may be the ARM architecture, and the second instruction set architecture may be the x86 architecture. Through the method provided in this embodiment, a target component set that supports running on the x86 architecture can be determined from the original container image of the NVIDIA JetPack SDK under the ARM architecture.

[0043] S103. Based on the target component set, construct a target container image of the target software development kit under the first instruction set architecture and a target container image of the target software development kit under the second instruction set architecture.

[0044] Specifically, the target component set includes target components identified in the original container image of the target software development kit under the first instruction set architecture (such as the ARM architecture) that can run properly under the second instruction set architecture (such as the x86 architecture). The types corresponding to the target components include, but are not limited to, library files at the operating system level, runtime environments, implementation libraries for specific functions (such as mathematical model libraries, graphics libraries), development tools, and other dependencies.

[0045] On the one hand, based on the target component set, a target container image of the target software development kit under the first instruction set architecture can be constructed. Specifically, by using the Docker Buildx tool or a similar cross-platform build tool, combined with a Dockerfile script optimized for the first instruction set architecture, the target components in the target component set are repackaged into a container image suitable for the first instruction set architecture, that is, the target container image of the target software development kit under the first instruction set architecture. This target container image will contain the dependencies and configurations required to run under the first instruction set architecture, ensuring the complete functionality and performance of the target software development kit under the first instruction set architecture.

[0046] On the one hand, based on the target component set, a target container image of the target software development kit under the second instruction set architecture can be constructed. Specifically, the Docker Buildx tool or a cross-platform build tool is also used, but this time a Dockerfile script optimized for the second instruction set architecture is used. This script will consider the characteristics and requirements of the second instruction set architecture, make necessary adjustments and optimizations to the target components in the target component set, and then package them into a target container image suitable for the second instruction set architecture, that is, the target container image of the target software development kit under the second instruction set architecture. This target container image will contain the dependencies and configurations required to run under the second instruction set architecture, ensuring the compatibility and performance of the target software development kit under the second instruction set architecture.

[0047] Exemplarily, assume that the target software development kit is the NVIDIA JetPack SDK, the first instruction set architecture is the ARM architecture, and the second instruction set architecture is the x86 architecture. In this case, the target component set will include components in the NVIDIA JetPack SDK that are independent of the instruction set architecture or have been adapted to run on the x86 architecture. Based on this target component set, two target container images can be built: one is the container image of the NVIDIA JetPack SDK suitable for the ARM architecture, which contains the dependencies and configurations required to run on the ARM architecture; the other is the container image of the NVIDIA JetPack SDK suitable for the x86 architecture, which also contains the dependencies and configurations required to run on the x86 architecture. In this way, it is possible to develop and test using the same container image of the NVIDIA JetPack SDK under different instruction set architectures, greatly improving the development efficiency and cross-platform compatibility.

[0048] In this embodiment, first, obtain the original container image of the target software development kit under the first instruction set architecture; then, determine the target component set from the original container image of the target software development kit. The target components in the target component set support running under the second instruction set architecture, which means that the target components are compatible with the first instruction set architecture and the second instruction set architecture. Further, based on the target component set, a target container image of the target software development kit under the first instruction set architecture and a target container image of the target software development kit under the second instruction set architecture can be built. These target container images can subsequently run on a computing platform with the first instruction set architecture or a computing platform with the second instruction set architecture. In this way, the compatibility of the software development kit with different instruction set architectures is effectively improved, which helps the cross-platform porting and reuse of the software development kit.

[0049] Please refer to Figure 2 , Figure 2 which is a schematic flowchart of a process for determining a target component set provided by an embodiment of the present application. As Figure 2 shown, the method of the embodiment of the present application may include the following steps S201 - S204, and steps S201 - S204 may be used as refined steps for Figure 1 step S102 shown in the embodiment.

[0050] S201, create a test container based on the second instruction set architecture;

[0051] S202, determine the set of components to be tested in the original container image of the target software development kit;

[0052] S203. For any component to be tested in the set of components to be tested, perform a running test on the component to be tested in a test container to obtain the running test result corresponding to the component to be tested.

[0053] S204. If the running test result corresponding to the component to be tested indicates that the component to be tested supports running under the second instruction set architecture, determine the component to be tested as the first target component in the target component set. The first target component is a type of target component in the target component set.

[0054] Specifically, this embodiment aims to identify the first target component that supports running under the second instruction set architecture from the original container image of the target software development kit.

[0055] Specifically, this embodiment aims to identify the first target component that supports running under the second instruction set architecture from the original container image of the target software development kit.

[0056] First, it is necessary to create a test container based on the second instruction set architecture. The test container refers to a virtual container that simulates the environment of the second instruction set architecture and is used to test whether the components in the target software development kit can run properly under this architecture.

[0057] Next, determine the set of components to be tested in the original container image of the target software development kit. The set of components to be tested refers to the set of all components that may need to be tested in the original container image. The types corresponding to the components to be tested include, but are not limited to, library files at the operating system level, runtime environments, implementation libraries for specific functions (such as mathematical model libraries, graphics libraries), development tools, and other dependencies. In some possible implementation manners, the components to be tested can be identified by analyzing the layer structure and content of the original container image.

[0058] Then, for any component to be tested in the set of components to be tested, perform a running test on the component to be tested in the test container to obtain the running test result corresponding to the component to be tested. Among them, the running test performed on the component to be tested in the test container can include attempting to load the component, executing the functions or interfaces provided by the component, monitoring the running status and output of the component, etc., to verify the compatibility and stability of the component to be tested under the second instruction set architecture. The running test result can be a Boolean value (such as "yes" or "no") indicating whether the component to be tested supports running under the second instruction set architecture, or it can be a report or log containing more detailed test information based on this.

[0059] Finally, if the running test result corresponding to the component to be tested indicates that the component to be tested supports running under the second instruction set architecture, the component to be tested is determined as the first target component in the target component set, and the first target component is a type of target component in the target component set. In this way, the target component set can be gradually constructed, and the first target components in the target component set are all components that have been tested and verified to be able to run properly under the second instruction set architecture.

[0060] Exemplarily, assume that the target software development kit is NVIDIA JetPack SDK, the first instruction set architecture is the ARM architecture, and the second instruction set architecture is the x86 architecture. First, a test container based on the Ubuntu operating system is created based on the x86 architecture. This test container simulates the running environment of the x86 architecture and includes the basic libraries and runtime environment required for running under the x86 architecture.

[0061] Furthermore, determine the set of components to be tested in the original container image of NVIDIA JetPack SDK under the ARM architecture. The types of components to be tested may include library files at the operating system level, CUDA runtime environment, TensorRT library, cuDNN library, and other development tools, etc. By analyzing the layer structure and content of the original container image, these components to be tested can be identified and listed in the set of components to be tested.

[0062] Furthermore, for any component to be tested in the set of components to be tested, perform a running test on it in the test container of the x86 architecture. The test process may include attempting to load the component, execute the functions or interfaces provided by the component, monitor the running status and output of the component, etc. For example, for the CUDA runtime environment, attempt to load the CUDA library and execute some basic CUDA programs to verify the compatibility and stability of the CUDA runtime environment under the x86 architecture. For other components to be tested, similar test methods can also be adopted.

[0063] Furthermore, according to the running test result, determine the component to be tested that supports running under the x86 architecture as the first target component in the target component set. For example, if the CUDA runtime environment can be normally loaded and run in the test container of the x86 architecture, then it is determined as the first target component in the target component set. In this way, the target component set can be gradually constructed, and the first target components in this set are all components that have been tested and verified to be able to run properly under the x86 architecture. These first target components will be used later to construct the target container image of NVIDIA JetPack SDK under the x86 architecture, thereby realizing the cross-platform migration of NVIDIA JetPack SDK from the ARM architecture to the x86 architecture.

[0064] In this embodiment, by creating a test container based on the second instruction set architecture, the target running environment can be simulated, providing a real test scenario for the component to be tested. After determining the set of components to be tested, each component is subjected to a running test, effectively verifying its compatibility and stability under the second instruction set architecture. The running test results are used as the key basis to accurately screen out the first target components that support running under the second instruction set architecture, thereby constructing a high-quality set of target components. This process not only improves the efficiency and accuracy of component screening but also avoids including incompatible components in the target container image, reducing compatibility issues after migration. Finally, the target container image constructed based on the accurate set of target components can run stably under different instruction set architectures, significantly enhancing the cross-platform compatibility and migration efficiency of the software development kit.

[0065] In one embodiment, for Figure 2 the steps of the embodiment shown in

[0066] Based on the container image history viewing instruction, determine the mirror hierarchy of the original container image of the target software development kit;

[0067] Based on the mirror hierarchy, determine the set of components to be tested in the original container image of the target software development kit.

[0068] Specifically, the container image history viewing instruction involved in this embodiment refers to a command or tool for viewing the build history of a container image. For example, the container image history viewing instruction can be the DockerHistory instruction in Docker container technology, whose function is to display the build history of each layer of the container image, including the creation method, creation time, author information, and specific commands executed in each layer. Through the Docker History instruction, the build process of a container image can be determined, thereby determining the composition and structure of the container image.

[0069] Regarding the process of determining the mirror hierarchy of the original container image of the target software development kit based on the container image history viewing instruction, it specifically involves executing the container image history viewing instruction (such as Docker History) on the original container image of the target software development kit to obtain the build history information of each layer of the original container image. Then, based on the obtained historical information, analyze and determine the hierarchy of the original container image, including the dependency relationship, component composition, and logical relationship between layers, so as to determine the build process and composition structure of the original container image. [[ID=B]]

[0070] Regarding the process of determining the set of components to be tested in the original container image of the target software development kit based on the mirror hierarchy, specifically, after determining the mirror hierarchy of the original container image, the components to be tested that may need to be tested are filtered out from the mirror hierarchy of the original container image. It can be understood that the components to be tested can be specific layers, specific files, or specific libraries in the mirror, and their selection should be based on considerations of compatibility and stability with the target instruction set architecture. By filtering and determining the set of components to be tested, the components to be tested can be specifically tested for operation, thereby verifying their compatibility and stability under the target instruction set architecture.

[0071] In this embodiment, by introducing a container image history viewing instruction, in-depth analysis and precise component identification of the original container image of the target software development kit are achieved. The application of this instruction enables a clear understanding of the mirror hierarchy and the dependency relationships between layers, providing a basis for determining the set of components to be tested. By filtering the components to be tested based on the mirror hierarchy, blind testing and resource waste are effectively avoided, improving the testing efficiency and accuracy. In addition, this embodiment can also ensure that the determined set of components to be tested comprehensively covers the key components of the target software development kit, providing comprehensive support for subsequent cross-platform compatibility verification.

[0072] Please refer to Figure 3 , Figure 3 which is a schematic flowchart of a process for determining a target component set provided by an embodiment of the present application. As Figure 3 shown, the method of the embodiment of the present application may include the following steps S301 - S303, and steps S301 - S303 may be used as refinement steps of step S102 in the embodiment Figure 1 shown.

[0073] S301, determine, from the original container image of the target software development kit, a first acceleration component that supports running under a first instruction set architecture, and the acceleration type of the first acceleration component is hardware acceleration;

[0074] S302, based on the first acceleration component, determine a second acceleration component that supports running under a second instruction set architecture, and the acceleration type of the second acceleration component is hardware acceleration or software acceleration;

[0075] S303, determine the second acceleration component as the second target component in the target component set, and the second target component is one of the target components in the target component set.

[0076] Specifically, the acceleration components involved in this embodiment refer to specific components that can improve the running efficiency or processing speed of software during the software development process. These components usually utilize hardware acceleration (such as GPUs, dedicated accelerators, etc.) or software acceleration (such as optimization algorithms, parallel processing, etc.) technologies to achieve the acceleration effect.

[0077] First, from the original container image of the target software development kit, determine the first acceleration component that supports running under the first instruction set architecture. Here, the first acceleration component refers to a hardware acceleration component specifically optimized or designed for the first instruction set architecture in the original container image, such as a GPU driver for the ARM architecture, a dedicated accelerator library, etc. This process can be manifested as identifying, by analyzing the component list and configuration information in the original container image, components that are closely related to the first instruction set architecture and can provide hardware acceleration functions as the first acceleration component.

[0078] Furthermore, based on the first acceleration component, determine the second acceleration component that supports running under the second instruction set architecture. The acceleration type of the second acceleration component is hardware acceleration or software acceleration. The second acceleration component can be regarded as an alternative acceleration component to the first acceleration component, that is, under the second instruction set architecture, an acceleration component used to replace or supplement the functions of the first acceleration component. The second acceleration component refers to a hardware acceleration component or software acceleration component that can provide similar or equivalent acceleration effects to the first acceleration component under the second instruction set architecture, such as the CUDA library, OpenCL library for the x86 architecture, or optimized software algorithms, etc. This process can be manifested as searching for or developing acceleration components with the same or similar functions under the second instruction set architecture according to the functions and characteristics of the first acceleration component as the second acceleration component.

[0079] Furthermore, determine the second target component in the target component set. The second target component is one of the target components in the target component set. This process can be manifested as adding the second acceleration component to the target component set as one of the target components. It can be understood that the second acceleration component has passed the running test under the second instruction set architecture, can normally provide the acceleration function, and is compatible with other components of the target software development kit.

[0080] Exemplarily, assume that the target software development kit is the NVIDIA JetPack SDK, the first instruction set architecture is the ARM architecture, and the second instruction set architecture is the x86 architecture.

[0081] First, determine the first acceleration components that support running on the ARM architecture from the original container image of the NVIDIA JetPack SDK under the ARM architecture. The types corresponding to these first acceleration components may include GPU drivers optimized for the ARM architecture, dedicated accelerator libraries (such as NVIDIA's DLA accelerator library), etc. By analyzing the component list and configuration information in the original container image, these components that are closely related to the ARM architecture and can provide hardware acceleration functions can be identified as the first acceleration components.

[0082] Next, based on these first acceleration components, determine the second acceleration components that support running on the x86 architecture. Since there are differences in hardware acceleration between the x86 architecture and the ARM architecture, it is necessary to find or develop acceleration components that can provide similar or equivalent acceleration effects on the x86 architecture. For example, for the GPU driver under the ARM architecture, different versions of the CUDA library or other optimized libraries can be loaded on the x86 architecture; for the dedicated accelerator library under the ARM architecture, the corresponding alternative library under the x86 architecture can be determined or the corresponding software acceleration algorithm can be implemented. In a similar way, the second acceleration components that support running on the x86 architecture can be determined.

[0083] Finally, add these second acceleration components to the target component set as one of the target components, that is, the second target components. These second target components have passed the running test on the x86 architecture, can normally provide acceleration functions, and are compatible with other components of the NVIDIA JetPack SDK. In this way, a target component set containing the second target components is constructed. The second target components in this target component set are all acceleration components that have been tested and verified to be able to run normally on the x86 architecture, and will be used later to build the target container image of the NVIDIA JetPack SDK under the x86 architecture, so as to achieve the cross-platform migration of the NVIDIA JetPack SDK from the ARM architecture to the x86 architecture and maintain efficient hardware acceleration capabilities or software acceleration capabilities on the migrated computing platform.

[0084] In this embodiment, by accurately identifying the first acceleration components that support running under the first instruction set architecture from the original container image, and further determining the second acceleration components that can be substituted or equivalent under the second instruction set architecture based on these components, this method ensures the performance consistency of the software development kit across different platforms. In this process, not only the migration of hardware acceleration components is considered, but also software acceleration is flexibly introduced as an alternative to adapt to the hardware differences between different platforms. This refined acceleration component adaptation strategy effectively avoids performance bottlenecks caused by platform differences and improves the overall operating efficiency of the software development kit. At the same time, incorporating the adapted second acceleration components into the target component set provides a basis for subsequent construction of cross-platform container images, significantly enhancing the cross-platform compatibility and portability of the software development kit.

[0085] Please refer to Figure 4 , Figure 4 which is a schematic flowchart of a process for constructing a target container image provided by an embodiment of this application. As Figure 4 shown, the method of the embodiment of this application may include the following steps S401 - S402, and steps S401 - S402 may be used as refined steps for Figure 1 the steps S103 shown in the embodiment.

[0086] S401, generating a container image construction script based on the target component set and the general component set in the target software development kit that is decoupled from the physical hardware and the instruction set architecture;

[0087] S402, constructing a target container image of the target software development kit under the first instruction set architecture and a target container image of the target software development kit under the second instruction set architecture based on the container image construction script.

[0088] Specifically, to build the target container image, first, based on the target component set and the set of general components decoupled from physical hardware and instruction set architecture in the target software development kit, a container image build script is generated. Among them, the container image build script refers to a script file used to define the container image build process. In some cases, the container image build script can be written based on the Dockerfile format, that is, the container image build script can be a Dockerfile file. The Dockerfile file contains a series of instructions required for building the container image, such as the selection of the base image, the setting of environment variables, the copying of files, the installation of software packages, and the specification of the startup command, etc. By writing the Dockerfile file, the build process of each layer of the container image can be precisely controlled to ensure that the image only contains necessary components and configurations, thereby optimizing the volume and security of the image. This process can be expressed as: First, according to the content of the target component set, determine the instructions and configurations that need to be included in the Dockerfile file. Then, according to the syntax rules of the Dockerfile format, write these instructions and configurations into the Dockerfile file.

[0089] Among them, the set of general components decoupled from physical hardware and instruction set architecture in the target software development kit refers to the general components in the target software development kit that do not depend on specific physical hardware or instruction set architecture. Exemplarily, the general components can be operating systems, development tools, general software libraries, etc. Among them, "decoupled" means that the dependency relationship between these general components and the underlying physical hardware and instruction set architecture is minimized or eliminated, enabling them to run on different hardware platforms and instruction set architectures without major modifications or adaptations. For example, the operating system provides a hardware-independent abstraction layer, and development tools and general software libraries achieve compatibility with different instruction set architectures through standardized interfaces and cross-platform designs. By combining the set of general components with the target component set, the integrity and functionality of the target container image on different platforms can be ensured.

[0090] Furthermore, based on the container image building script, build the target container image of the target software development kit under the first instruction set architecture and the target container image of the target software development kit under the second instruction set architecture. This process can be represented as using the Docker Build command or other container image building tools to execute the instructions in the Dockerfile to build the target container image. During the building process, Docker builds the image layer by layer according to the instructions in the Dockerfile and performs corresponding operations in each layer. Finally, the built target container image will contain all the target components in the target component set and has been optimized and adapted for the corresponding instruction set architecture. These target container images can run on different computing platforms, thus achieving the cross-platform compatibility of the software development kit.

[0091] In this embodiment, by generating a container image building script and building the target container image across instruction set architectures based on this script, the cross-platform compatibility and deployment efficiency of the software development kit are greatly improved. Through the precise target component set, it is possible to write the container image building script specifically. This script details the steps and configurations required to build the container image under different instruction set architectures. This building method ensures the accuracy and integrity of the image content, avoiding unnecessary component redundancy and dependency conflicts. Based on this script, target container images suitable for different instruction set architectures can be built, and these images can run seamlessly on the target platform without additional adaptation work. This automated building process not only simplifies the process but also significantly improves the efficiency and accuracy of software deployment, providing strong support for cross-platform software development and deployment.

[0092] Please refer to Figure 5 , Figure 5 which is a schematic flowchart of a method for running a container image provided by an embodiment of the present application. As Figure 5 shown, the method of the embodiment of the present application may include the following steps S501 - S503.

[0093] S501, in response to the running instruction of the container image, determine the target instruction set architecture of the current computing platform, where the target instruction set architecture is the first instruction set architecture or the second instruction set architecture;

[0094] S502, obtain the target container image of the target software development kit under the target instruction set architecture;

[0095] S503, on the current computing platform, run the target container image of the target software development kit under the target instruction set architecture.

[0096] Specifically, the running instruction of the container image involved in this embodiment refers to a command or operation for starting or running a container image. In some cases, the running instruction of the container image is executed by a container runtime (such as the Docker runtime), which is used to pull a specified container image from a repository and start one or more container instances on the current computing platform. These container instances are created based on the specified image and contain all the dependencies and configurations required to run the target software development kit.

[0097] The running instruction of the container image can contain multiple parameters, which are used to specify information such as the name and tag of the image, the environment variables of the runtime, the network configuration, and the storage volume mounts. When the running instruction is executed, the container runtime will start the container instance according to these parameters and run the target software development kit in it.

[0098] It can be understood that the running instruction of the container image can be automatically generated by the current computing platform. For example, in an automated deployment or continuous integration / continuous deployment (CI / CD) process, the system will automatically trigger the running of the container image according to predefined configurations and policies. In addition, the running instruction of the container image can also be triggered by the user corresponding to the current computing platform through relevant operations to generate the current computing platform. For example, the user inputs the running instruction through a command-line interface (CLI) or a graphical user interface (GUI) to manually start the container instance. Whether it is automatically generated or manually triggered, the running instruction of the container image is a key step in realizing the deployment and running of containerized applications.

[0099] Furthermore, obtain the target container image of the target software development kit under the target instruction set architecture. This process is specifically manifested as follows: First, according to the target instruction set architecture (the first instruction set architecture or the second instruction set architecture), retrieve the corresponding target container image from a preset image repository or remote repository. These target container images were built based on the target component set using tools such as Docker Buildx or similar cross-platform build tools in the previous steps and are suitable for different instruction set architectures respectively. Then, use the pull command (such as docker pull) of the container runtime (such as the Docker runtime) to download the target container image from the repository or remote repository to the local image repository of the current computing platform.

[0100] Further, on the current computing platform, run the target container image of the target software development kit under the target instruction set architecture. This process is specifically manifested as follows: First, use the running command of the container runtime (such as docker run) to specify the name or tag of the target container image to be run. Then, the container runtime will start a new container instance on the current computing platform according to the specified image. This container instance will load all the dependencies and configurations in the target container image, including the operating system, drivers, tools, library files, etc., thus providing a complete running environment for the target software development kit. After the container instance is started, developers can run the target software development kit in it for development, testing, deployment, etc. operations. In this way, the target software development kit can be seamlessly migrated and run under different instruction set architectures.

[0101] In this embodiment, by responding to the running instruction of the container image, the target instruction set architecture of the current computing platform is automatically identified, and the target container image constructed based on the foregoing container image construction method is obtained. In this process, no manual intervention is required, which greatly improves the deployment efficiency and reduces the operation complexity. More importantly, this method ensures the matching of the target container image with the target instruction set architecture, thus ensuring the compatibility and stability of the software development kit on different platforms. When running the target container image, the hardware resources of the current computing platform can be fully utilized to achieve optimal performance. In addition, this embodiment also simplifies the cross-platform development and testing processes, which helps the cross-platform application of the software development kit.

[0102] Please refer to Figure 6 , Figure 6 which is a schematic flowchart of a process for configuring a dependency file provided by an embodiment of the present application. As Figure 6 shown, based on Figure 5 the embodiment shown, the method of the embodiment of the present application may include the following steps S601 - S602.

[0103] S601, obtain the dependency file corresponding to the target software development kit;

[0104] S602, configure the dependency file corresponding to the target software development kit on the current computing platform.

[0105] Specifically, the dependency file corresponding to the target software development kit refers to various external files or resources that the target software development kit depends on during the development process. These files or resources are necessary for the normal operation of the target software development kit, including but not limited to library files, configuration files, data files, etc. It should be noted that the dependency files may come from the target software development kit itself or from other external software packages or system components.

[0106] The process of obtaining the dependent files corresponding to the target software development kit can be manifested as follows: First, according to the configuration information and requirements of the target software development kit, determine the list of required dependent files. These dependent files may have been pre-installed in the target container image, or may need to be downloaded from external sources (such as the network, local storage, etc.). Then, by writing scripts or using automated tools, obtain these dependent files from the specified source and save them locally or to a specified storage location for subsequent configuration and use.

[0107] The process of configuring the dependent files corresponding to the target software development kit on the current computing platform can be manifested as follows: First, according to the characteristics and requirements of the target computing platform, appropriately configure and modify the obtained dependent files. This may include adjusting the parameters of the configuration files, setting environment variables, specifying the paths of the dependent files, etc. Then, deploy the configured dependent files to the target computing platform to ensure that they can be correctly loaded and used by the target software development kit. It should be noted that during the configuration process, it may also be necessary to solve the compatibility issues between the dependent files to ensure that they can work together to support the normal operation of the target software development kit.

[0108] Exemplarily, assume that the target software development kit is the NVIDIA JetPack SDK, and the target computing platform is a computer with an x86 architecture. When configuring the dependent files of the NVIDIA JetPack SDK, some configuration requirements specific to the x86 architecture may be encountered.

[0109] First, for the CUDA library in the NVIDIA JetPack SDK, it is necessary to ensure that the downloaded CUDA version is compatible with the x86 architecture computer. Since the CUDA library is the basis for NVIDIA GPU programming, its version must match the GPU driver and hardware architecture. Therefore, when obtaining the dependent files, the CUDA library files will be selected and downloaded according to the GPU model and driver version of the x86 architecture computer.

[0110] Next, for the TensorRT library, which is a high-performance deep learning inference engine provided by NVIDIA, it also needs to be configured according to the x86 architecture. It may be necessary to adjust the configuration file of TensorRT to ensure that it can correctly identify and utilize the GPU resources on the x86 architecture computer. In addition, if TensorRT depends on specific runtime environments or library files, it is also necessary to ensure that these dependencies have been correctly installed and configured.

[0111] During the configuration process, some compatibility issues may also be encountered. For example, some library files that run on the ARM architecture may not be directly usable on the x86 architecture. In such cases, it is necessary to find the corresponding x86 architecture version or develop alternative solutions. At the same time, it is also necessary to ensure the version compatibility between all dependent files to avoid running errors caused by version conflicts.

[0112] Finally, deploy the configured dependent files to a computer with the x86 architecture and start the container image of the NVIDIA JetPackSDK. After the container starts, some test programs can be run to verify whether the dependent files have been correctly configured and used. If any abnormalities are found, diagnosis and repair can be carried out based on the migration logs and reports. In this way, it can be ensured that the NVIDIA JetPack SDK runs properly on a computer with the x86 architecture and makes full use of the hardware acceleration function it provides.

[0113] In this embodiment, by obtaining the dependent files corresponding to the software development kit, it is ensured that all external resources required for the software to run can be completely retained when migrating to a new platform. This process not only avoids running errors caused by missing dependencies but also improves the stability and compatibility of the software on the new platform. Further, configuring the dependent files on the current computing platform can flexibly adjust the dependencies according to the actual environmental requirements to adapt to the differences between different platforms.

[0114] Please refer to Figure 7 , Figure 7 which is a schematic flowchart of a running acceleration component provided by an embodiment of the present application. As Figure 7 shown, based on Figure 5 the embodiment shown, the method of the embodiment of the present application may include the following steps S701 - S703.

[0115] S701, if the third acceleration component of the current computing platform does not exist in the target container image of the target software development kit under the target instruction set architecture, determine the acceleration object corresponding to the third acceleration component;

[0116] S702, obtain a fourth acceleration component, and the acceleration object corresponding to the fourth acceleration component is the same as the acceleration object corresponding to the third acceleration component;

[0117] S703, run the fourth acceleration component on the current computing platform.

[0118] Specifically, the third acceleration component involved in this embodiment refers to a component in the target software development kit that is used to accelerate specific acceleration objects. The corresponding types of the third acceleration component may include hardware acceleration libraries (such as GPU drivers, dedicated accelerator libraries, etc.) or software acceleration algorithms (such as optimized mathematical model libraries, parallel processing libraries, etc.).

[0119] If the third acceleration component of the current computing platform does not exist in the target container image of the target software development kit under the target instruction set architecture, then determine the acceleration object corresponding to the third acceleration component. Among them, the acceleration object corresponding to the third acceleration component refers to the specific computing task or data type that the third acceleration component is designed to accelerate, such as image processing, video encoding, deep learning inference, etc. By determining the acceleration object of the third acceleration component, a clear direction can be provided for subsequent searching or developing alternative acceleration components.

[0120] Furthermore, obtain a fourth acceleration component, and the acceleration object corresponding to the fourth acceleration component is the same as the acceleration object corresponding to the third acceleration component. It can be understood that the fourth acceleration component can perform the same computing tasks or accelerate the same data types as the third acceleration component. Among them, the fourth acceleration component refers to an acceleration component that is available on the current computing platform and can replace the third acceleration component. The fourth acceleration component may be optimized for the hardware and instruction set architecture of the current computing platform, or implemented through software acceleration technology.

[0121] Finally, on the current computing platform, run the fourth acceleration component. This process can be manifested as deploying the fourth acceleration component to the current computing platform and ensuring that it can be correctly loaded and run. Then, in the target software development kit, configure to use the fourth acceleration component to replace the missing third acceleration component. Finally, start the target software development kit and utilize the fourth acceleration component for acceleration when performing relevant computing tasks. In this way, a similar acceleration effect can be achieved on the current computing platform as that under the target instruction set architecture, ensuring the performance consistency of the target software development kit on different platforms.

[0122] Exemplarily, assume that the target software development kit is NVIDIA JetPack SDK, and the target instruction set architecture is the x86 architecture, and the current computing platform is also a computer with the x86 architecture. During the process of migrating NVIDIA JetPack SDK to the x86 platform, it is found that the GPU acceleration library optimized for the x86 architecture, that is, the third acceleration component, is missing in the target container image. This GPU acceleration library was originally designed for the ARM architecture and cannot be directly used on the x86 platform.

[0123] At this time, it is determined that the acceleration object corresponding to the third acceleration component is a deep learning inference task. To solve this problem, a fourth acceleration component, namely a CUDA library optimized for the x86 architecture, is searched for and obtained. This CUDA library can execute the same deep learning inference tasks as the original GPU acceleration library, so its acceleration object is the same as that of the third acceleration component.

[0124] Furthermore, this CUDA library optimized for the x86 architecture (i.e., the fourth acceleration component) is deployed to the current x86 architecture computing platform and ensured that it can be correctly loaded and run. Then, in the NVIDIA JetPack SDK, it is configured to use this CUDA library to replace the missing GPU acceleration library (i.e., the third acceleration component). Finally, the NVIDIA JetPack SDK is started, and this CUDA library is utilized for acceleration when performing deep learning inference tasks. In this way, a similar acceleration effect as on the original ARM platform is successfully achieved on the x86 platform, ensuring the performance consistency of the NVIDIA JetPack SDK across different platforms.

[0125] In this embodiment, when a specific acceleration component is missing in the target container image, the acceleration object corresponding to the component can be identified, and a replacement acceleration component with the same function can be obtained. This mechanism ensures that the performance of the target software development kit on the current computing platform is not affected, and it can maintain high operating efficiency even in the face of different hardware architectures and instruction sets. By dynamically replacing the acceleration component, not only the performance bottleneck caused by hardware differences is avoided, but also the cross-platform compatibility and portability of the software development kit are significantly improved.

[0126] It should be understood that although the various steps in the flowchart are shown sequentially according to the arrows, these steps do not necessarily have to be executed in the order indicated by the arrows. Unless otherwise clearly stated in this article, there is no strict order limit for the execution of these steps, and these steps can be executed in other orders. Moreover, at least some of the steps in the figure may include multiple sub-steps or multiple stages. These sub-steps or stages do not necessarily have to be completed at the same moment, but can be executed at different moments. The execution order of these sub-steps or stages does not necessarily have to be sequential either, but can be executed alternately or in turn with at least a part of other steps or sub-steps or stages of other steps.

[0127] In one embodiment, a computer device is provided, and the internal structure diagram of this computer device can be as Figure 8As shown in the figure. The computer device includes a processor, a memory, a network interface, and a database connected by a system bus. Among them, the processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system, a computer program, and a database. The internal memory provides an environment for the operation of the operating system and the computer program in the non-volatile storage medium. The database of the computer device is used to store data. The network interface of the computer device is used to communicate with an external terminal through a network connection. When the computer program is executed by the processor, it can implement a container image building method or a container image running method as described above. It includes: including a memory and a processor, the memory stores a computer program, and when the processor executes the computer program, it implements any step in the above container image building method or container image running method.

[0128] In one embodiment, a computer-readable storage medium is provided, on which a computer program is stored. When the computer program is executed by a processor, it can implement any step in the above container image building method or container image running method.

[0129] Those skilled in the art should understand that the embodiments of the present application can be provided as a method, a system, or a computer program product. Therefore, the present application can take the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware aspects. Moreover, the present application can take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0130] The present application is described with reference to the flowcharts and / or block diagrams of methods, devices (systems), and computer program products according to the embodiments of the present application. It should be understood that each flow and / or block in the flowchart and / or block diagram can be implemented by computer program instructions, and the combination of the flows and / or blocks in the flowchart and / or block diagram can also be implemented. These computer program instructions can be provided to the processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing devices to generate a machine, so that the instructions executed by the processor of the computer or other programmable data processing devices generate a device for realizing the functions specified in Figure 1 one process or multiple processes and / or blocks Figure 1 one block or multiple blocks.

[0131] These computer program instructions can also be stored in a computer-readable memory that can direct a computer or other programmable data processing device to work in a specific manner, so that the instructions stored in the computer-readable memory generate a manufactured article including an instruction device, and the instruction device realizes the functions in the process Figure 1One process or multiple processes and / or boxes Figure 1 The functions specified in one box or multiple boxes.

[0132] These computer program instructions can also be loaded onto a computer or other programmable data processing device, so that a series of operation steps are executed on the computer or other programmable device to generate a computer-implemented process. Thus, the instructions executed on the computer or other programmable device provide steps for implementing the functions specified in Figure 1 One process or multiple processes and / or boxes Figure 1 The steps of the functions specified in one box or multiple boxes.

[0133] Although the preferred embodiments of the present application have been described, those skilled in the art can make additional changes and modifications to these embodiments once they learn the basic creative concepts. Therefore, the appended claims are intended to be construed to include the preferred embodiments as well as all changes and modifications falling within the scope of the present application.

[0134] Obviously, those skilled in the art can make various changes and modifications to the present application without departing from the spirit and scope of the present application. Thus, if these modifications and variations of the present application fall within the scope of the claims of the present application and their equivalent technologies, the present application also intends to include these changes and modifications.

Claims

1. A method for constructing a container image, characterized in that, Including: Obtain the original container image of the target software development kit under the first instruction set architecture; Determine a target component set from the original container image of the target software development kit, where the target components in the target component set support running under the second instruction set architecture; Based on the target component set, build the target container image of the target software development kit under the first instruction set architecture and the target container image of the target software development kit under the second instruction set architecture.

2. The method according to claim 1, characterized in that The determining the target component set from the original container image of the target software development kit includes: Create a test container based on the second instruction set architecture; Determine the set of components to be tested in the original container image of the target software development kit; For any component to be tested in the set of components to be tested, perform a running test on the component to be tested in the test container to obtain the running test result corresponding to the component to be tested; If the running test result corresponding to the component to be tested indicates that the component to be tested supports running under the second instruction set architecture, determine the component to be tested as the first target component in the target component set, and the first target component is one of the target components in the target component set.

3. The method according to claim 2, wherein The determining the set of components to be tested in the original container image of the target software development kit includes: Based on the container image history viewing instruction, determine the mirror hierarchy of the original container image of the target software development kit; Based on the mirror hierarchy, determine the set of components to be tested in the original container image of the target software development kit.

4. The method according to claim 1, characterized in that, The determining the target component set from the original container image of the target software development kit includes: From the original container image of the target software development kit, determine a first acceleration component that supports running under the first instruction set architecture, and the acceleration type of the first acceleration component is hardware acceleration; Based on the first acceleration component, determine a second acceleration component that supports running under the second instruction set architecture, and the acceleration type of the second acceleration component is hardware acceleration or software acceleration; Determine the second acceleration component as the second target component in the target component set, and the second target component is one of the target components in the target component set.

5. The method according to claim 1, wherein The building the target container image of the target software development kit under the first instruction set architecture and the target container image of the target software development kit under the second instruction set architecture based on the target component set includes: Based on the target component set and the general component set in the target software development kit that is decoupled from physical hardware and instruction set architecture, generate a container image building script; Based on the container image building script, build the target container image of the target software development kit under the first instruction set architecture and the target container image of the target software development kit under the second instruction set architecture.

6. A method for running a container image, characterized in that Including: In response to a running instruction of a container image, determine a target instruction set architecture of the current computing platform, where the target instruction set architecture is a first instruction set architecture or a second instruction set architecture; Obtain a target container image of a target software development kit under the target instruction set architecture, where the target container image of the target software development kit under the target instruction set architecture is built based on the container image building method according to any one of claims 1 to 5; On the current computing platform, run the target container image of the target software development kit under the target instruction set architecture.

7. The method according to claim 6, characterized in that, The method further includes: Obtain a dependency file corresponding to the target software development kit; On the current computing platform, configure the dependency file corresponding to the target software development kit.

8. The method according to claim 6, characterized in that, The method further includes: If a third acceleration component of the current computing platform does not exist in the target container image of the target software development kit under the target instruction set architecture, determine an acceleration object corresponding to the third acceleration component; Obtain a fourth acceleration component, where an acceleration object corresponding to the fourth acceleration component is the same as an acceleration object corresponding to the third acceleration component; On the current computing platform, run the fourth acceleration component.

9. A computer device, comprising: It includes a memory and a processor, where the memory stores a computer program, and is characterized in that when the processor executes the computer program, the steps of the method according to any one of claims 1 to 8 are implemented.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, the steps of the method according to any one of claims 1 to 8 are implemented.

Images