CN111597021A

CN111597021A - Method, device and system for realizing application program operation and related equipment

Info

Publication number: CN111597021A
Application number: CN202010377254.0A
Authority: CN
Inventors: 李伟; 李春林
Original assignee: Dongsoft Group Dalian Co ltd; Neusoft Corp
Current assignee: Dongsoft Group Dalian Co ltd; Neusoft Corp
Priority date: 2020-05-07
Filing date: 2020-05-07
Publication date: 2020-08-28
Anticipated expiration: 2040-05-07
Also published as: CN111597021B

Abstract

The embodiment of the application discloses a method, a device, a system and related equipment for realizing application program running, when a cluster computing system comprises a first system on chip and a second system on chip, the first system on chip comprises a first container coordinator and a first container management program, and the second system on chip comprises a second container coordinator, the method comprises the following steps: the method comprises the steps that a first container coordinator obtains a starting request of an application program, and the first container coordinator sends the starting request of the application program to a first container management program so that the first container management program starts a container image file corresponding to the application program; after the first container coordinator obtains the event change information of the application program from the first container management program, the first container coordinator triggers and updates the display content corresponding to the first system on chip according to the event change information, and sends the event change information to the second container coordinator, so that the second container coordinator triggers and updates the display content corresponding to the second system on chip according to the event change information.

Description

Method, device and system for realizing application program operation and related equipment

Technical Field

The present application relates to the field of computer technologies, and in particular, to a method, an apparatus, a system, and a related device for implementing application program operation.

Background

With the popularization of internet technology, more and more applications are installed in an operating system (e.g., an in-vehicle system), and the demand for computing resources of the operating system is increasing. At present, in order to meet the demand of a large number of application programs in an operating System for computing resources, an operating System based on a plurality of Systems On Chip (SOC) may be used. In an operating system based on a plurality of SOCs, the plurality of SOCs form a cluster computing system in a cascading manner, so that the cluster computing system can provide a large amount of computing resources for the operating system. However, many conventional applications (e.g., meter applications installed in an in-vehicle system) cannot run on a clustered computing system because their software frameworks are not suitable for clustered computing systems.

Disclosure of Invention

In view of this, embodiments of the present application provide a method, an apparatus, a system, and related devices for implementing application running, which can solve the technical problem that the conventional application cannot run in a cluster computing system.

In order to solve the above problem, the technical solution provided by the embodiment of the present application is as follows:

a method for implementing application running, the method being applied to a cluster computing system, the cluster computing system comprising a first system on chip and a second system on chip, the first system on chip comprising a first container coordinator and a first container manager, the second system on chip comprising a second container coordinator, the method comprising:

the first container coordinator obtains a starting request of an application program and sends the starting request of the application program to the first container management program so as to enable the first container management program to start a container image file corresponding to the application program, wherein the container image file corresponding to the application program is generated in advance and is deployed to the first system on chip and the second system on chip;

the first container coordinator acquiring event change information of the application program from the first container management program;

the first container coordinator sends the event change information to the second container coordinator, so that the second container coordinator triggers and updates display content corresponding to the second system on chip according to the event change information;

and the first container coordinator triggers and updates the display content corresponding to the first system on chip according to the event change information.

In a possible implementation manner, the generating process of the container image file corresponding to the application program includes:

creating containerized firmware, and adding a file directory system in the containerized firmware;

configuring a running environment variable of the containerized firmware;

specifying an initial program of the containerized firmware at boot-up;

and constructing the containerization firmware into a container image file corresponding to the application program.

In a possible implementation manner, the acquiring, by the first container coordinator, a start request of an application program, and sending the start request of the application program to the first container management program includes:

the first container coordinator obtains a starting request of an application program through a first man-machine interface, and sends the starting request of the application program to the first container management program after judging that the application program is a local starting application;

or, after the second container coordinator obtains a start request of an application program through a second human-machine interface, determines that the application program is a non-local start application, and sends the start request of the application program to the first container coordinator, the first container coordinator receives the start request of the application program and sends the start request of the application program to the first container management program.

In a possible implementation manner, the triggering, by the first container coordinator, to update the display content corresponding to the first system on chip according to the event change information includes:

the first container coordinator updates an application load list according to the event change information and sends the application load list to a first human-machine interface, so that the first human-machine interface updates display content corresponding to the first system on chip according to the application load list;

and/or the first container coordinator sends the event change information to a first human-machine interface, so that the first human-machine interface updates the display content corresponding to the first system on chip according to the event change information.

In one possible implementation, the first system on chip further includes a first display module, the second system on chip further includes a second display module, and the method further includes:

the first display module determines a display screen corresponding to the first system on chip, and sends display content corresponding to the first system on chip to the display screen corresponding to the first system on chip for display;

and/or the second display module determines a display screen corresponding to the second system on chip and sends the display content corresponding to the second system on chip to the display screen corresponding to the second system on chip for display.

In one possible implementation, the second system on chip further includes a second container manager; the method further comprises the following steps:

and the first container coordinator monitors the running state of the application program, and when the running state of the application program is monitored to be abnormal, the first container coordinator sends an application program running abnormal notification to the second container coordinator, so that the second container coordinator starts a container image file corresponding to the application program through the second container management program.

the first container coordinator does not receive the heartbeat signal of the second container coordinator when the preset time length is exceeded, and a target application program is determined according to an application load list, wherein the target application program is an application program started by the second container coordinator through the second container management program;

and sending a starting request of the target application program to the first container management program so as to enable the first container management program to start the container image file corresponding to the target application program.

A first container coordinator, the first container coordinator located in the first system on a chip; the first system on a chip further comprises a first container management program; the first system on a chip is located in the cluster computing system; the clustered computing system further comprises a second system-on-chip; the second system-on-chip comprises a second container coordinator; the first container coordinator comprising:

a first obtaining unit, configured to obtain a start request of an application program, and send the start request of the application program to the first container management program, so that the first container management program starts a container image file corresponding to the application program, where the container image file corresponding to the application program is generated in advance and is deployed to the first system on chip and the second system on chip;

a second acquisition unit configured to acquire event change information of the application program from the first container management program;

a first sending unit, configured to send the event change information to the second container coordinator, so that the second container coordinator triggers and updates display content corresponding to the second soc according to the event change information;

and the updating unit is used for triggering and updating the display content corresponding to the first system on chip by the first container coordinator according to the event change information.

A clustered computing system comprising a first system on a chip comprising a first container coordinator and a first container manager, and a second system on a chip comprising a second container coordinator;

the first container coordinator is used for acquiring a starting request of an application program and sending the starting request of the application program to the first container management program;

the first container management program is configured to start a container image file corresponding to the application program, where the container image file corresponding to the application program is generated in advance and is deployed to the first system on chip and the second system on chip;

the first container coordinator is used for acquiring event change information of the application program from the first container management program;

the first container coordinator is used for sending the event change information to the second container coordinator;

the second container coordinator is used for triggering and updating the display content corresponding to the second system on chip according to the event change information;

and the first container coordinator is used for triggering and updating the display content corresponding to the first system on chip according to the event change information.

An apparatus for implementing application program operation, comprising: the application program comprises a memory, a processor and a computer program which is stored on the memory and can run on the processor, wherein when the processor executes the computer program, the method for realizing the running of the application program is realized.

A computer-readable storage medium, having stored therein instructions, which, when executed on a terminal device, cause the terminal device to execute the above-mentioned method for implementing application running.

Therefore, the embodiment of the application has the following beneficial effects:

in this embodiment of the present application, when the clustered computing system includes a first system on chip and a second system on chip, where the first system on chip includes a first container coordinator and a first container manager, and the second system on chip includes a second container coordinator, the method for implementing application running applied to the clustered computing system may specifically include: after the first container coordinator obtains a starting request of the application program, the first container coordinator firstly sends the starting request of the application program to the first container management program so that the first container management program starts a container image file corresponding to the application program; after the first container coordinator obtains the event change information of the application program from the first container management program, the first container coordinator triggers and updates the display content corresponding to the first system on chip according to the event change information, and the first container coordinator also sends the event change information to the second container coordinator, so that the second container coordinator triggers and updates the display content corresponding to the second system on chip according to the event change information. The first container coordinator of the first system on chip in the cluster computing system can start the container image file corresponding to the application program by means of the first container management program, so that the container image files which are generated in advance and deployed to the first system on chip and the container image file corresponding to the application program on the second system on chip are suitable for the cluster computing system, the application program can run on the cluster computing system by means of the container image file corresponding to the application program, and the technical problem that the application program cannot run on the cluster computing system is solved.

Drawings

Fig. 1 is a schematic structural diagram of a cluster computing system according to an embodiment of the present application;

FIG. 2 is an exemplary diagram of a clustered computing system provided by an embodiment of the present application;

fig. 3 is a flowchart of a method for implementing application program operation according to an embodiment of the present application;

FIG. 4 is an exemplary diagram of another clustered computing system provided by an embodiment of the present application;

FIG. 5 is a schematic structural diagram of a first container coordinator according to an embodiment of the present disclosure;

fig. 6 is a schematic structural diagram of a cluster computing system according to an embodiment of the present application.

Detailed Description

In order to make the aforementioned objects, features and advantages of the present application more comprehensible, embodiments accompanying the drawings are described in detail below.

In the research on the cluster computing system and the traditional application program, the inventor finds that the traditional application program cannot be migrated in the cluster computing system because files such as configuration files, dynamic libraries, basic support libraries and the like forming the traditional application program (for example, an instrument application program installed in a vehicle-mounted system) are dispersed in different directories of the operating system, so that the traditional application program cannot meet the requirement of the cluster computing system for migrating the application program at any time, and a software framework of the traditional application program is not suitable for the cluster computing system.

Based on this, an embodiment of the present application provides a method for implementing application program operation, which is applied to a cluster computing system, and the method specifically includes: if the cluster computing system comprises a first system on chip and a second system on chip, the first system on chip comprises a first container coordinator and a first container management program, and the second system on chip comprises a second container coordinator, after the first container coordinator obtains a starting request of the application program, the first container coordinator firstly sends the starting request of the application program to the first container management program, so that the first container management program starts a container image file corresponding to the application program; after the first container coordinator obtains the event change information of the application program from the first container management program, the first container coordinator triggers and updates the display content corresponding to the first system on chip according to the event change information, and the first container coordinator also sends the event change information to the second container coordinator, so that the second container coordinator triggers and updates the display content corresponding to the second system on chip according to the event change information. Therefore, the first container coordinator in the cluster computing system can start the container image file corresponding to the application program by means of the first container management program, so that the application program can run on the cluster computing system by means of the container image file corresponding to the application program, and the technical problem that the application program cannot run on the cluster computing system is solved.

In order to facilitate understanding of the method for implementing application program operation provided in the embodiment of the present application, the following first introduces relevant contents of the cluster computing system with reference to fig. 1. Fig. 1 is a schematic structural diagram of a cluster computing system according to an embodiment of the present application.

As shown in fig. 1, a cluster computing system provided in the embodiment of the present application includes N systems on a chip, where N is a positive integer; each system on chip comprises a container coordinator and a container management program, and container image files corresponding to all the application programs are deployed on each system on chip. The container coordinator may be configured to obtain a start request of an application program, obtain event change information of the application program, and share the event change information of the application program, which is obtained from the corresponding container management program, with other container coordinators. The container management program may be configured to start a container image file corresponding to the application program according to a start request of the application program sent by the container coordinator. It should be noted that the container image file corresponding to the application program is used to characterize an execution file of the application program in the cluster computing system, that is, the container management program in the cluster computing system may start the application program by starting the container image file corresponding to the application program, so that the application program runs on the cluster computing system.

In the cluster computing system shown in fig. 1, the ith local application program managed by the system on chip is preset, so that the ith local application program managed by the system on chip runs on the ith system on chip, i is a positive integer, and i is not greater than N. It should be noted that the local application program responsible for management by different soc may be different or the same, and this is not specifically limited in this embodiment of the application. In addition, in the cluster computing system shown in fig. 1, all the container coordinators are globally synchronized, the container coordinator of the ith system-on-chip may invoke the local application program of the ith system-on-chip not only by the container manager of the ith system-on-chip, but also by the container coordinators and container managers in other systems-on-chips except the ith system-on-chip, where i is a positive integer and i is less than or equal to N.

Based on the related content of the cluster computing system, the cluster computing system may include a plurality of systems on chip that may communicate with each other, and the container management program in each system on chip may start the container image file corresponding to the application program according to the start request of the application program sent by the container coordinator, so that the application program can run on the cluster computing system.

In addition, in order to further understand the process of implementing the application running in the clustered computing system shown in fig. 1, a clustered computing system including a first system on chip and a second system on chip will be described as an example.

As shown in FIG. 2, assume that the clustered computing system includes a first system-on-chip including a first container coordinator and a first container manager, and a second system-on-chip including a second container coordinator and a second container manager; and pre-generating a first container image file and a second container image file which are both deployed on the first system-on-chip and the second system-on-chip, wherein the first container image file is a container image file of the first application program, and the second container image file is a container image file of the second application program.

Based on the above assumptions, the method for implementing application program operation applied to the cluster computing system shown in fig. 2 specifically includes: if it is preset that the first container management program of the first system-on-chip is responsible for starting the first container image file, after the first container coordinator acquires the start request of the first application, the first container coordinator sends the start request of the first application to the first container manager, such that the first container manager launches the first container image file (i.e., the container image file corresponding to the first application) such that, after the first container coordinator obtains the event change information for the application from the first container manager, the first container coordinator triggers and updates the display content corresponding to the first system on chip according to the event change information, and the first container coordinator also sends the event change information to the second container coordinator, so that the second container coordinator triggers and updates the display content corresponding to the second system on chip according to the event change information.

Therefore, after the first application program is started, the display content corresponding to the first system on chip and the display content corresponding to the second system on chip can be respectively updated by using the event change information generated by the starting of the first application program, so that the display content corresponding to the first system on chip and the display content corresponding to the second system on chip can be synchronized. The first container coordinator in the cluster computing system can start the container image file corresponding to the application program by means of the first container management program, so that the application program can run on the cluster computing system by means of the container image file corresponding to the application program, and the technical problem that the application program cannot run on the cluster computing system is solved.

It should be noted that, the embodiment of the present application is not limited to the first system on chip and the second system on chip, for example, when the first system on chip is the ith system on chip in fig. 1, the second system on chip is another system on chip except the ith system on chip in the cluster computing system shown in fig. 1, i is a positive integer, and i ≦ N.

In order to facilitate understanding of the present application, a method for implementing application running provided by the embodiments of the present application will be described below with reference to the accompanying drawings.

Referring to fig. 3, which is a flowchart of a method for implementing application program operation provided in the embodiment of the present application, as shown in fig. 3, the method for implementing application program operation applied to a cluster computing system (as shown in fig. 2) specifically includes S301 to S304:

s301: the first container coordinator obtains a starting request of the application program and sends the starting request of the application program to the first container management program, so that the first container management program starts a container image file corresponding to the application program.

The launch request for an application is used to characterize an instruction that requests a computer system to launch the application. In addition, the embodiment of the present application further provides two embodiments for the first container coordinator to obtain the start request of the application program, please refer to the following detailed description.

The first container coordinator and the first container manager may communicate with each other, and the embodiment of the present application does not limit the communication manner between the first container coordinator and the first container manager, for example, the first container coordinator and the first container manager may communicate with each other by using Google Remote Procedure Call (GRPC).

The container image files corresponding to the application programs are generated in advance and are deployed to the first system on chip and the second system on chip. That is, a container image corresponding to the application is deployed on each system-on-chip in the clustered computing system. In addition, the embodiment of the present application further provides a generation process of the image file, please refer to the following.

In this embodiment of the application, after the first container coordinator obtains the start request of the application, the first container coordinator sends the start request of the application to the first container management program, so that after the first container management program receives the start request of the application, the first container management program starts the container image file corresponding to the application according to the start request of the application, so that the application runs in the first system on a chip. For example, as shown in fig. 2, the first container coordinator may create a start task of the Application program through an Application Programming Interface (API) of the first container manager, and send the operating environment parameter of the first system on chip to the first container manager, so that the first container manager starts the container image file corresponding to the Application program according to the operating environment parameter.

S302: the first container coordinator obtains event change information of the application from the first container manager.

The event change information of the application program is used for representing the execution information of the corresponding event of the application program. In addition, the embodiment of the present application is not limited to the event change information of the application, for example, the event change information of the application carries information about the state (for example, the state of starting, running, or stopping, etc.) of the application.

In this embodiment of the application, after the first container management program starts the container image file corresponding to the application program, the first container coordinator may monitor all events of the application program from the first container management program in real time, so that the first container coordinator may obtain event change information of the application program from the first container management program, so that the subsequent first container coordinator may use or share the event change information.

S303: and the first container coordinator triggers and updates the display content corresponding to the first system on chip according to the event change information.

In the embodiment of the application, after the first container coordinator obtains the event change information, the first container coordinator triggers and updates the display content corresponding to the first system on chip according to the event change information, so that the display content corresponding to the first system on chip can reflect the application program running information in the cluster computing system in real time.

S304: and the first container coordinator sends the event change information to the second container coordinator, so that the second container coordinator triggers and updates the display content corresponding to the second system on chip according to the event change information.

In this embodiment of the application, after the first container coordinator obtains the event change information, the first container coordinator may further send the event change information to the second container coordinator, so that the second container coordinator may trigger to update the display content corresponding to the second system on chip according to the event change information, so that the display content corresponding to the second system on chip may also reflect the application program running information in the clustered computing system in real time, and thus it is ensured that the display content corresponding to the second system on chip and the display content corresponding to the first system on chip are kept synchronized.

It should be noted that, in the embodiment of the present application, the execution order of S303 and S304 is not limited, S303 and S304 may be executed sequentially, S304 and S303 may be executed sequentially, or S303 and S304 may be executed simultaneously.

Based on the related contents in S301 to S304, in the method for implementing application program operation applied to the cluster computing system provided in the embodiment of the present application, after the first container coordinator obtains the start request of the application program, the first container coordinator first sends the start request of the application program to the first container management program, so that the first container management program starts the container image file corresponding to the application program; after the first container coordinator obtains the event change information of the application program from the first container management program, the first container coordinator triggers and updates the display content corresponding to the first system on chip according to the event change information, and the first container coordinator also sends the event change information to the second container coordinator, so that the second container coordinator triggers and updates the display content corresponding to the second system on chip according to the event change information. The first container coordinator in the cluster computing system can start the container image file corresponding to the application program by means of the first container management program, so that the container image files which are generated in advance and are deployed on the first system on chip and the second system on chip are suitable for the cluster computing system, the application program can run on the cluster computing system by means of the container image file corresponding to the application program, and the technical problem that the application program cannot run on the cluster computing system is solved.

In a possible implementation manner, an embodiment of the present application further provides an implementation manner for generating a container image file corresponding to an application, which may specifically include steps 11 to 15:

step 11: a containerized firmware is created.

The containerization firmware is used to store the relevant files of the application. In addition, the embodiment of the present application does not limit the creation manner of the containerized firmware, for example, the containerized firmware may be constructed by using a "FROM scratch" instruction in Dockerfile. The Dockerfile refers to a description file of a container image file corresponding to the application program, and the Dockerfile includes basic steps of constructing the container image file, so that the Dockerfile can be used for packaging a file directory system of the application program to obtain the container image file corresponding to the application program.

Step 12: a file directory system is added to the containerized firmware.

The file directory system is used to characterize the minimum operating environment of an application. To facilitate understanding of the file directory system, the following description is made with reference to an example.

By way of example, when the application is an in-vehicle application, then the relevant content of the file directory system that constructs the in-vehicle application is as follows:

since the vehicle-mounted application program generally runs on a Linux-based platform, the file directory system of the vehicle-mounted application program is also constructed on the Linux-based platform. The vehicle-mounted application programs generally include files such as a c language system basic function library (libc. so on), an operating system basic function library, a Graphical User Interface (GUI) basic function library (qt5 and the like), an application configuration file (/ etc. under an etc. directory).

The principle of constructing the file directory system of the vehicle-mounted application program is to ensure that the container image file corresponding to the constructed vehicle-mounted application program occupies the minimum space, so that based on the principle, the embodiment of the application can adopt the Alpine operating system as a basic platform to construct the file directory system of the vehicle-mounted application program. Wherein, the Alpine operating system is a security oriented light Linux distribution. Unlike the common Linux distribution, the Alpine operating system adopts musl libc and busy to reduce the volume and runtime resource consumption of the system, but is more sophisticated than busy in function, so that the Alpine operating system is more and more favored by open-source communities. The system can keep the system slim, and meanwhile, the diversified requirements of the system application can be met, so that the system is very suitable for the scene requirements of vehicle-mounted application containerization, and the Alpine operating system can meet the requirements of constructing a c language system basic function library and an operating system basic function library in a file directory system of a vehicle-mounted application program.

The GUI system of the vehicle-mounted application program (especially the instrument application program) mainly comprises QT components, different instrument applications depend on different QT versions, and therefore when the GUI basic library is integrated, UI components of corresponding versions are integrated into a file directory system of the vehicle-mounted application program according to the dependency relationship of the vehicle-mounted application program. For example, in the present application, the meter application relies on the 5.11.2 version of QT, which can satisfy the need to build a GUI base function library in the file directory system of the in-vehicle application.

The vehicle-mounted application program generally has configuration files of the vehicle-mounted application program, such as font library information, starting configuration items and other configuration files, and the configuration files are usually required to be placed under a system/etc directory, so that the vehicle-mounted application program can correspondingly establish/etc directory in the process of establishing a file directory system of the vehicle-mounted application program, and the configuration files of the vehicle-mounted application program are placed under a relevant directory, so that the requirement of establishing application configuration files in the file directory system of the vehicle-mounted application program can be met.

After files for building a basic environment for vehicle-mounted application operation, such as a c language system basic function library, an operating system basic function library, a GUI basic function library and an application configuration file, are built, a file directory system of a vehicle-mounted application program can be built by using the files. Since the car application generally includes an executable file (e.g., EJanus2-hmi file) and a plurality of dynamic components (e.g., libCarInfo control. so component, libHomeControl. so component, libSystemControl. so component, libVToXControl. so component, libearylhexbit. so component, libGaugeControl. so component, libIVIInfoControl. so component, libTelltalesControl. so component, etc.), the executable file is placed under/usr/bin of the file directory system, and the plurality of dynamic components are placed under/usr/lib 64 of the file directory system, so that the construction of the file directory system of the car application can be completed. For example, the directory structure and description of the file directory system of the built vehicle-mounted application are specifically shown in table 1.

TABLE 1

Based on the related content of the file directory system, the file directory system of the application program can accurately represent the minimum operating environment of the application program, so that the file for the application program to operate can be directly acquired from the file directory system of the application program subsequently.

In this embodiment of the application, after the containerized firmware and the file directory system of the application are obtained, the file directory system of the application may be added to the containerized firmware, so that the containerized firmware carries the file directory system of the application.

Step 13: configuring operating environment variables of the containerized firmware.

Applications typically require the use of some pre-configured environment variables at runtime. For a traditional application program, the environment variables are configured in the environment variables of the system in advance, but for a containerized application program, the environment variables of the system cannot affect the inside of the container due to the environment isolation characteristics of the container, so that the environment variable configuration method used by the traditional application program is not suitable for the environment variable configuration of the containerized application program in the application. To address this issue, the present application will configure the runtime environment variables of the containerized firmware in the containerized firmware.

In addition, to facilitate understanding of the operating environment variables of the configuration containerized firmware, the following description is made with reference to examples.

As an example, when the application is an instrument application, the instrument application starts up and needs to configure environment variable parameters of the windows, and fonts, so the application may configure the operating environment variables of the containerized firmware corresponding to the instrument application by using a "QT _ wireless _ DISABLE _ windows ═ 1" instruction, an "ENV QT _ QPA _ permit ═ windows ═ waland-egl" instruction, and an "ENV QT _ QPA _ fontc ═ direetc/fonts" instruction in Dockerfile. In addition, since the GUI system is managed by the weston application on Linux, and the weston communicates with the client application through domain socket, the socket of the weston is usually stored under/run/ias in a file manner, and the application program needs to complete the interactive communication with the weston through the/run/ias/wayland-0 file node. Therefore we also need to configure the RUNTIME environment variable ENV XDG _ RUNTIME _ DIR of the GUI to be/run/ias, so that the interaction interface path of the container application and weston can be specified.

Step 14: specifying the initial programming of the containerized firmware at startup.

The initial program refers to a portal program of a containerized application program, that is, a portal program of a container image file corresponding to the application program.

The embodiment of the present application does not limit the specifying manner of the initial program, for example, a command prompt (CMD) may be used to specify the initial program of the containerized firmware at startup, specifically: CMD [ "/usr/bin/EJanus2-hmi" ].

Step 15: and constructing the containerization firmware into a container image file corresponding to the application program.

In the embodiment of the application, after the file directory systems of the containerized firmware and the application program are obtained, the container image file corresponding to the application program can be constructed according to the file directory systems of the containerized firmware and the application program. It should be noted that, the embodiment of the present application does not limit the construction manner of the container image file, for example, a container image may be constructed by using an image docker instruction, specifically: and constructing a container image file of the containerized vehicle-mounted application by using a docker build instruction, and storing the container image file by using a docker save instruction.

The Docker is an open-source application container engine, and can be used for packaging an application program and a dependent package thereof into a portable mirror image, and then issuing the portable mirror image to any machine using a Linux operating system or a Windows operating system, and can also realize virtualization. The containers are fully sandboxed without any interface between each other.

In addition, compared with the conventional virtualization method, Docker has more advantages, which are specifically as follows: the docker starts quickly in the second level, and the virtual machine usually needs several minutes to start; the resource needed by the docker is less, the docker is virtualized at the level of an operating system, the docker container and the kernel are interacted, the performance loss is almost avoided, and the performance is superior to the virtualization of the kernel layer and the Hypervisor layer; docker is lighter in weight, and the architecture of the Docker can share one kernel and a shared application program library, so that the memory occupied by the Docker is extremely small. In the same hardware environment, the number of images run by the Docker is far more than the number of virtual machines, so that the utilization rate of the system is very high; docker records the container construction process in Dockerfile, and can realize rapid distribution and rapid deployment in the cluster.

Based on the above related contents in steps 11 to 15, in the embodiment of the present application, after the file directory system of the application program is constructed, the file directory system of the application program may be packaged to obtain the containerized firmware, and then the container image file corresponding to the application program is constructed according to the file directory system of the application program and the containerized firmware. Therefore, due to the fact that files and environment information required by the running of the application program exist in the container image file corresponding to the application program, each system on chip in the cluster computing system can start the application program in a mode of starting the container image file corresponding to the application program, and the application program can normally run on the cluster computing system. And because each system on chip in the cluster computing system is deployed with the container image file corresponding to all the application programs, each system on chip can start the application program corresponding to the container image file in a manner of starting the container image file deployed thereon.

In some cases, a container coordinator in one system on chip may obtain a start request of an application from a man-machine interface corresponding to the system on chip, and may also obtain start requests of applications from other container coordinators of the clustered computing system. Based on this, the present application example also provides two implementation manners of S301, which are described below.

As a first possible implementation manner, S301 may specifically be: the first container coordinator obtains a starting request of the application program through the first man-machine interface, and sends the starting request of the application program to the first container management program after judging that the application program is a local starting application.

The first human-machine interface and the first container coordinator have a corresponding relation, and communication can be carried out between the first human-machine interface and the first container coordinator. In addition, the embodiment of the present application does not limit the communication method between the first human machine interface and the first container coordinator, and for example, the first human machine interface and the first container coordinator may communicate with each other through the GRPC.

The locally started application corresponding to the first container coordinator (i.e., the locally started application of the first system on chip) refers to a preconfigured application that needs to be started by the first container manager of the first system on chip. However, the non-locally-launched application corresponding to the first container coordinator (i.e., the non-locally-launched application of the first system-on-chip) refers to a pre-configured application that needs to be launched by a container manager other than the first container manager in the clustered computing system.

Based on the related contents of the first possible implementation manner, in this embodiment of the application, after the first container coordinator obtains the start request of the application program through the first human-machine interface, the first container coordinator first determines whether the application program is a locally started application of the first system on a chip, so that when the first container coordinator determines that the application program is the locally started application of the first system on a chip, the first container coordinator sends the start request of the application program to the first container management program, so that the first container management program starts the container image file corresponding to the application program.

As a second possible implementation manner, S301 may specifically be: and after the second container coordinator obtains the starting request of the application program through the second human-computer interface, judges that the application program is a non-local starting application and sends the starting request of the application program to the first container coordinator, the first container coordinator receives the starting request of the application program and sends the starting request of the application program to the first container management program.

The non-locally started application corresponding to the second container coordinator (i.e., the non-locally started application of the second system-on-chip) refers to a pre-configured application that needs to be started by a container manager other than the second container manager in the clustered computing system. The second container management program refers to a container management program of the second system on chip.

Based on the above related contents of the first possible implementation manner, in the embodiment of the present application, after the second container coordinator obtains the start request of the application program through the second man-machine interface, the second container coordinator first determines whether the application is a locally launched application of the second system-on-chip, such that at the second container coordinator it is determined that the application is not a native boot application of the second system-on-chip, but the application is started locally on the first system on chip, the start request of the application program is forwarded to the first container coordinator by the second container coordinator, so that after the first container coordinator receives a start request of an application program transmitted by the second container coordinator, the first container coordinator sends a starting request of the application program to the first container management program so that the first container management program starts the container image file corresponding to the application program.

Based on the two possible embodiments, it can be known that, in the cluster computing system, the local boot application of the ith system on chip may be preconfigured, so that after receiving the boot request of the application program, the container coordinator in the ith system on chip first determines whether the application program is the local boot application of the ith system on chip, and if so, the container coordinator in the ith system on chip directly sends the boot request of the application program to the container manager in the ith system on chip, so that the container manager in the ith system on chip starts the container image file corresponding to the application program; if not, the container coordinator in the ith system-on-chip determines that the application program is a local starting application of the target system-on-chip according to the first mapping relation, and then the container coordinator in the ith system-on-chip forwards a starting request of the application program to the container coordinator in the target system-on-chip, so that the container coordinator in the target system-on-chip sends the starting request of the application program to the container management program in the target system-on-chip, and the container management program in the target system-on-chip starts a container image file corresponding to the application program. The local boot application of the ith system on chip refers to a preconfigured application program that needs to be started by the container management program of the ith system on chip. The first mapping relation is used for recording the local starting application of each system on chip.

Therefore, in the embodiment of the application, a user can call any application program in the cluster computing system through any human-computer interface, and the calling mode includes local calling and remote calling. The local calling refers to that the on-chip system corresponding to the human-computer interface used by the user directly calls the local starting application of the on-chip system, and the remote calling refers to that the on-chip system corresponding to the human-computer interface used by the user indirectly calls the local starting application of other on-chip systems by virtue of container coordinators in other on-chip systems.

In a possible implementation manner, the present application further provides three implementation manners of updating the display content (i.e., S303) corresponding to the first system on chip, which are described below separately.

As a first embodiment, S303 may specifically be: and the first container coordinator updates the application load list according to the event change information and sends the application load list to the first human-machine interface, so that the first human-machine interface updates the display content corresponding to the first system on the chip according to the application load list.

The application load list is used for recording the state information of all the application programs on the cluster computing system.

In this embodiment of the application, after the first container coordinator obtains the event change information, the first container coordinator may update the application load list according to the event change information, and send the application load list to the first human machine interface, so that the first human machine interface updates the display content corresponding to the first system on chip according to the application load list, so that the display content corresponding to the first system on chip carries the information recorded in the application load list.

As a second embodiment, S303 may specifically be: and the first container coordinator sends the event change information to the first human-machine interface so that the first human-machine interface updates the display content corresponding to the first system-on-chip according to the event change information.

In the embodiment of the application, after the first container coordinator obtains the event change information, the first container coordinator sends the event change information to the first human machine interface, so that the first human machine interface updates the display content corresponding to the first system on chip according to the event change information, and the display content corresponding to the first system on chip carries the event change information.

As a third embodiment, S303 may specifically be: the first container coordinator updates the application load list according to the event change information and sends the application load list to the first human-machine interface, so that the first human-machine interface updates display contents corresponding to the first system on the chip according to the application load list; and the first container coordinator sends the event change information to the first human-machine interface so that the first human-machine interface updates the display content corresponding to the first system-on-chip according to the event change information.

In the embodiment of the application, after the first container coordinator obtains the event change information, the first container coordinator sends the event change information and the application load list updated according to the event change information to the first human-machine interface, so that the first human-machine interface updates the display content corresponding to the first on-chip system according to the event change information and the updated application load list, and the display content corresponding to the first on-chip system carries the event change information and the application load list information.

In addition, in order to ensure that information of different systems on chip is synchronized in the cluster computing system, the embodiment of the present application may further update the display content corresponding to the second system on chip according to the foregoing manner. Based on this, the embodiments of the present application also provide three implementation manners for updating the display content corresponding to the second system on chip, which are described below.

As a first implementation manner, the update process of the display content corresponding to the second soc may specifically be: and the second container coordinator updates the application load list according to the event change information and sends the application load list to the second human-computer interface, so that the second human-computer interface updates the display content corresponding to the second system on chip according to the application load list.

The application load list may be used to record state information for all applications on the clustered computing system.

In this embodiment of the application, after the second container coordinator obtains the event change information, the second container coordinator may update the application load list according to the event change information, and send the application load list to the second human-machine interface, so that the second human-machine interface updates the display content corresponding to the second system on chip according to the application load list, so that the display content corresponding to the second system on chip carries the information recorded in the application load list.

As a second implementation manner, the update process of the display content corresponding to the second soc may specifically be: and the second container coordinator sends the event change information to the second human-computer interface so that the second human-computer interface updates the display content corresponding to the second system on chip according to the event change information.

In the embodiment of the application, after the second container coordinator obtains the event change information, the second container coordinator sends the event change information to the second human-machine interface, so that the second human-machine interface updates the display content corresponding to the second system on chip according to the event change information, and the display content corresponding to the second system on chip carries the event change information.

As a third implementation manner, the update process of the display content corresponding to the second soc may specifically be: the second container coordinator updates the application load list according to the event change information and sends the application load list to the second human-computer interface, so that the second human-computer interface updates display contents corresponding to the second system on chip according to the application load list; and the second container coordinator sends the event change information to the second human-computer interface so that the second human-computer interface updates the display content corresponding to the second system on chip according to the event change information.

In the embodiment of the application, after the second container coordinator obtains the event change information, the second container coordinator sends the event change information and the application load list updated according to the event change information to the second human-machine interface, so that the second human-machine interface updates the display content corresponding to the second system on chip according to the event change information and the updated application load list, and the display content corresponding to the second system on chip carries the event change information and the application load list information.

In some cases, in the event that one locally started application in one system-on-chip fails, the clustered computing system may start a container image file of the locally started application at the other system-on-chip to ensure that the locally started application can resume running. Based on this, the embodiment of the present application further provides another implementation manner of the cluster computing system, in this implementation manner, in addition to S301 to S304, the method for implementing the application program to run further includes step 21:

step 21: and the first container coordinator monitors the running state of the application program, and when the running state of the application program is monitored to be abnormal, sends an application program running abnormal notification to the second container coordinator, so that the second container coordinator starts a container image file corresponding to the application program through the second container management program.

For example, after the first container coordinator monitors that the application program exits abnormally, the first container coordinator may attempt to start the container image file corresponding to the application program M times by using the first container manager, so that when it is determined that the application program fails to run M times, the first container coordinator determines that the running state of the application program is abnormal.

It should be noted that, in this application, the container coordinator of the ith system-on-chip is further configured to monitor an operating state of a locally-started application of the ith system-on-chip, where i is a positive integer and is less than or equal to N.

Based on the content of step 21, in the clustered computing system, the container coordinator of the ith soc monitors the running state of the locally-started application of the ith soc in real time, monitors the running state exception of the target application program of the ith soc at the container coordinator of the ith soc, sends an application program running exception notification to at least one soc (hereinafter referred to as a replacement soc) other than the ith soc, where the application program running exception notification carries information of the running state exception of the target application program of the ith soc, so that the replacement soc can determine the running state exception of the target application program of the ith soc according to the received application program running exception notification, and then the container coordinator of the replacement soc starts the target application program on the replacement soc through the container manager of the replacement soc And corresponding container image files are sequenced so that the target application program can run on the replacement system-on-chip.

It should be noted that, in some cases, after receiving the application program operation exception notification sent by the first container coordinator, the second container coordinator may first determine whether the application program is a critical application program in the first system on chip, if so, the second container coordinator starts a container image file corresponding to the application program through the second container management program, and meanwhile, the second container coordinator may also stop a part or all of the non-critical application programs in the operating state on the second system on chip through the second container management program; if not, the second container coordinator does not perform any related actions for the exception notification.

Based on the above, it can be known that there exists an error fusion mechanism in the cluster computing system, and the error fusion mechanism specifically includes: the container coordinator of the ith system-on-chip monitors the running states of all locally started applications of the ith system-on-chip, when a locally started application exits abnormally, the container coordinator of the ith system-on-chip tries to run the application locally for M times, if the M times fail, the container coordinator of the ith system-on-chip determines that the locally started application is a failed application and triggers a container failure event to the cluster computing system, when the container coordinator of other systems-on-chips (hereinafter referred to as replacement system-on-chip) except the ith system-on-chip in the cluster computing system receives the container failure event, the replacement system-on-chip firstly judges whether the failed application is a critical application of the ith system-on-chip, if not, relevant actions are not taken, if the failed application is a critical application, the replacement system-on-chip first stops all non-critical applications locally and locally starts the container image file corresponding to the failed application on the replacement system-on-chip. The container failure event refers to an event that the application program does not exit according to an exit mode preset by the easy coordinator.

In some cases, for a case where one system-on-chip fails, the clustered computing system may restore applications running on the failed system-on-chip to other systems-on-chips. Based on this, the embodiment of the present application further provides another implementation manner of the cluster computing system, in this implementation manner, in addition to the above-mentioned part or all of the steps, the method for implementing the application program to run further includes step 22 and step 23:

step 22: and the first container coordinator does not receive the heartbeat signal of the second container coordinator when the preset time length is exceeded, and determines a target application program according to the application load list, wherein the target application program is an application program started by the second container coordinator through the second container management program.

Step 23: the first container coordinator sends a starting request of the target application program to the first container management program so that the first container management program starts a container image file corresponding to the target application program.

Based on the foregoing steps 22 and 23, in the clustered computing system, after the container coordinator of the ith system on chip does not receive the heartbeat signal of the container coordinator in the failed system on chip for more than the preset time period, the container coordinator of the ith system on chip may determine, as the target application program, the application program started by the second container coordinator through the second container management program recorded in the application load list, and then the first container management program sends the start request of the target application program, so that the first container management program starts the container image file corresponding to the target application program, so that the application program originally running in the failed system on chip can resume running on the ith system on chip.

It should be noted that, in some cases, when determining the target application, the container coordinator of the ith system on chip may determine, as the target application, only the critical application started by the second container coordinator through the second container manager, which is recorded in the application load list, so that only the critical application originally running in the failed system on chip can be subsequently resumed on the ith system on chip.

Based on the above, another error fusion mechanism exists in the cluster computing system, and the error fusion mechanism specifically includes: all container coordinators in the cluster computing system can mutually monitor heartbeat information of each other, if a certain container coordinator does not send a heartbeat signal within a specified time, after other container coordinators exceed the specified time for a certain time, the system on chip where the container coordinator which does not send the heartbeat signal is located is determined to be a failed system on chip, whether a key application program running on the failed system on chip exists in an application load list is checked, if so, local non-key application is stopped running, and the key application programs running on the failed system on chip are recovered.

In some cases, the embodiment of the application may further display the display content corresponding to each soc. Based on this, an embodiment of the present application further provides another implementation manner of the cluster computing system, in which in the implementation manner, each system on chip in the cluster computing system further includes a display module corresponding to the system on chip, so that the display module is used to display content corresponding to the system on chip. For example, as shown in FIG. 4, when the clustered computing system includes a first system on a chip that may include a first container coordinator, a first container manager, and a first display module, and a second system on a chip that may include a second container coordinator, a second container manager, and a second display module. The first display module is used for displaying display content corresponding to the first on-chip system; the second display module is used for displaying the display content corresponding to the second system on chip.

The embodiment of the present application further provides another implementation of the method for implementing application running, which is applied to the above cluster computing system, in this implementation, in addition to S301 to S304, the method for implementing application running further includes step 23 and/or step 24:

step 23: the first display module determines a display screen corresponding to the first system-on-chip, and sends display content corresponding to the first system-on-chip to the display screen corresponding to the first system-on-chip for display.

Step 24: and the second display module determines a display screen corresponding to the second system on chip and sends the display content corresponding to the second system on chip to the display screen corresponding to the second system on chip for display.

In this embodiment of the application, after the update of the display content corresponding to the first system on chip is completed, the first display module determines the display screen corresponding to the first system on chip first, and then sends the display content corresponding to the first system on chip to the display screen corresponding to the first system on chip for display. Similarly, after the update of the display content corresponding to the second soc is completed, the second display module determines the display screen corresponding to the second soc, and then sends the display content corresponding to the second soc to the display screen corresponding to the second soc for display. Therefore, the purpose of displaying the display content corresponding to each system on chip to the display screen corresponding to the system on chip is achieved.

In some cases, each system on chip usually stores only an application layer corresponding to a locally-launched application (the application layer refers to Display data corresponding to an application program), and in this case, in order to enable each system on chip to Display not only related content of the locally-launched application but also related content of a non-locally-launched application, in the embodiment of the present application, a Display as a service (Daas) architecture is used to design Display deployment of a clustered computing system.

By means of the DaaS mechanism, the cluster computing system can manage the display layers of a plurality of systems on chip, and ensure that the contents between different systems on chip can be displayed on any display screen. After the container coordinator starts each container image file corresponding to an application program, the application program is assigned an application identifier, and the DaaS mechanism sends the application image layers corresponding to the application identifiers to any corresponding display screen to realize the display of the application program.

The display mechanism in the cluster computing system based on the DaaS mechanism is as follows: when a user wants to run a locally started application App4 in the first system on chip and want to display App4 on a display screen corresponding to the second system on chip, the first system on chip may send an application layer of App4 to the second system on chip, so that a second display module in the second system on chip can determine a display screen corresponding to the second system on chip according to the received application layer and send display content corresponding to App4 to a display screen corresponding to the second system on chip for display. For example, the first system on chip may encode the application layer of App4 by using a wayland component in the first system on chip and send the encoded application layer of App4 to the second system on chip by using an RTSP protocol, so that the second system on chip receives and decodes the RTSP packets by using a GStreamer program to obtain the application layer of App 4.

In the software architecture of DaaS, DaaS includes the following key components:

1).DaaS UI

the DaaS UI is a local or containerized user interface that may provide an interface for the container coordinator to start or stop these services. The DaaS UI runs on each system-on-chip in the clustered computing system and is responsible for local display and capture and remote synchronization of user interaction events.

2).DaaS-Agent

The DaaS-Agent is a monitoring program running in a display core component (weston), and is responsible for acquiring a layer creation notification event, and the process specifically includes: after an image layer is created, the DaaS-Agent acquires the position information of the image layer, then triggers a remote Session (Session), sends or receives data from the weston through the Session, and establishes communication with the weston. And simultaneously establishing a session and a communication mechanism with the GSTreamer. Meanwhile, the DaaS-Agent establishes a network cluster through Hashicorp/Serf, each instance in the cluster starts and maintains a Serf, and is bound to the cluster through the Serf, and then starts a thread for receiving events and broadcasting the events, so that event information from the cluster to other on-chip systems is received, and own events are broadcasted to the cluster.

3).Serf(Hashicorp/Serf)

The Serf provides an infrastructure for tracking cluster node information, can effectively detect whether a DaaS node is added into a cluster or whether a node exits from the cluster, and is very suitable for fault-tolerant detection of a container coordinator.

4).Remote Display

Remoteddisplay provides the infrastructure for remote display by which machines in a cluster can convert display data into H264 video stream data and transmit it over a UDP or eAVB network to remote machines.

5).GStreamer

After the remote machine sends the video data stream of H264, the receiving end decodes the data through the GSTreamer and displays the data on a corresponding display screen.

Based on the related content of the method for implementing application program operation provided by the foregoing method embodiment, the embodiment of the present application further provides a first container coordinator, which is described below with reference to the accompanying drawings.

Referring to fig. 5, a schematic structural diagram of a first container coordinator according to an embodiment of the present application is shown. Wherein the first container coordinator is located in the first system-on-a-chip; the first system on a chip further comprises a first container management program; the first system on a chip is located in a cluster computing system; the clustered computing system further includes a second system-on-chip; the second system-on-chip includes a second container coordinator. As shown in fig. 5, the first container coordinator includes:

a first obtaining unit 501, configured to obtain a start request of an application program, and send the start request of the application program to the first container management program, so that the first container management program starts a container image file corresponding to the application program, where the container image file corresponding to the application program is generated in advance and is deployed on the first system on chip and the second system on chip;

a second acquiring unit 502 configured to acquire event change information of the application from the first container management program;

a first sending unit 503, configured to send the event change information to the second container coordinator, so that the second container coordinator triggers to update the display content corresponding to the second soc according to the event change information;

an updating unit 504, configured to trigger, by the first container coordinator, to update the display content corresponding to the first system on chip according to the event change information.

configuring a running environment variable of the containerized firmware;

specifying an initial program of the containerized firmware at boot-up;

In a possible implementation manner, the first obtaining unit 501 is specifically configured to: acquiring a starting request of an application program through a first man-machine interface, and sending the starting request of the application program to the first container management program after judging that the application program is a local starting application;

in a possible implementation manner, the first obtaining unit 501 is specifically configured to: and after the second container coordinator obtains a starting request of an application program through a second human-computer interface, judging that the application program is a non-local starting application, sending the starting request of the application program to the first container coordinator, receiving the starting request of the application program, and sending the starting request of the application program to the first container management program.

In a possible implementation, the update unit 504 includes a first update subunit and/or a second update subunit:

the first updating subunit is configured to update an application load list according to the event change information, and send the application load list to a first human machine interface, so that the first human machine interface updates display content corresponding to the first system on chip according to the application load list;

the second updating subunit is configured to send the event change information to a first human-machine interface, so that the first human-machine interface updates display content corresponding to the first system-on-chip according to the event change information.

In a possible implementation manner, the first system on chip further includes a first display module, the second system on chip further includes a second display module, and the first display module is configured to determine a display screen corresponding to the first system on chip, and send display content corresponding to the first system on chip to the display screen corresponding to the first system on chip for display;

and/or the second display module is configured to determine a display screen corresponding to the second soc, and send display content corresponding to the second soc to the display screen corresponding to the second soc for display.

In one possible implementation, the second system-on-chip further includes a second container manager; the first container coordinator 500 further includes:

and the monitoring unit is used for monitoring the running state of the application program, and when the running state of the application program is monitored to be abnormal, sending an abnormal running notification of the application program to the second container coordinator so that the second container coordinator starts the container image file corresponding to the application program through a second container management program.

the determining unit is used for determining a target application program according to an application load list when the heartbeat signal of the second container coordinator is not received within a preset time period, wherein the target application program is an application program started by the second container coordinator through a second container management program;

a second sending unit, configured to send a start request of the target application to the first container management program, so that the first container management program starts a container image file corresponding to the target application.

Based on the related content of the method for implementing application program operation provided by the above method embodiment, the embodiment of the present application further provides a cluster computing system, which is described below with reference to the accompanying drawings.

Referring to fig. 6, which is a schematic structural diagram of a cluster computing system provided in the embodiment of the present application, as shown in fig. 6, the cluster computing system 600 includes a first system on chip 601 and a second system on chip 602, where the first system on chip 601 includes a first container coordinator 6011 and a first container management program 6012, and the second system on chip 602 includes a second container coordinator 6021;

a first container coordinator 6011, configured to obtain a start request of an application program, and send the start request of the application program to a first container management program 6012;

a first container management program 6012, configured to start a container image file corresponding to an application, where the container image file corresponding to the application is generated in advance and is deployed to the first system-on-chip 601 and the second system-on-chip 602;

a first container coordinator 6011 configured to acquire event change information of an application from a first container management program 6012;

a first container coordinator 6011 configured to transmit the event change information to the second container coordinator 6021;

the second container coordinator 6021 is configured to trigger updating of display content corresponding to the second system-on-chip 602 according to the event change information;

the first container coordinator 6011 is configured to trigger to update the display content corresponding to the first on-chip system 601 according to the event change information.

configuring a running environment variable of the containerized firmware;

specifying an initial program of the containerized firmware at startup;

In one possible implementation, the first container coordinator 6011 is specifically configured to: the start request of the application program is acquired through the first man-machine interface, and after the application program is judged to be the local start application, the start request of the application program is sent to the first container management program 6012.

In one possible implementation, the first container coordinator 6011 is specifically configured to: after the second container coordinator 6021 acquires the start request of the application through the second human-machine interface, determines that the application is a non-local start application, sends the start request of the application to the first container coordinator 6011, receives the start request of the application, and sends the start request of the application to the first container management program 6012.

In one possible implementation, the first container coordinator 6011 is specifically configured to: updating the application load list according to the event change information, and sending the application load list to the first human-machine interface so that the first human-machine interface updates the display content corresponding to the first system-on-chip 601 according to the application load list; and/or sending the event change information to the first human-machine interface, so that the first human-machine interface updates the display content corresponding to the first system-on-chip 601 according to the event change information.

In one possible embodiment, the first system-on-chip 601 further comprises a first display module, and the second system-on-chip 602 further comprises a second display module;

the first display module is configured to determine a display screen corresponding to the first system-on-chip 601, and send display content corresponding to the first system-on-chip 601 to the display screen corresponding to the first system-on-chip 601 for display;

and/or the second display module is configured to determine a display screen corresponding to the second system-on-chip 602, and send display content corresponding to the second system-on-chip 602 to the display screen corresponding to the second system-on-chip 602 for display.

In one possible implementation, the second system-on-chip 602 further includes a second container manager;

the first container coordinator 6011 is further configured to monitor an operation state of the application program, and send an application program operation exception notification to the second container coordinator 6021 when the operation state of the application program is monitored to be abnormal;

the second container coordinator 6021 is further configured to start the container image file corresponding to the application program through the second container management program.

the first container coordinator 6011 is further configured to, when the preset time duration is exceeded, not receive a heartbeat signal of the second container coordinator 6021, determine a target application program according to the application load list, where the target application program is an application program started by the second container coordinator 6021 through a second container management program; sending a start request of the target application to the first container management program 6012;

the first container management program 6012 is further configured to start a container image file corresponding to the target application.

In addition, an embodiment of the present application further provides an apparatus for implementing application running, including: the application program comprises a memory, a processor and a computer program which is stored on the memory and can run on the processor, and when the processor executes the computer program, the processor realizes any embodiment of the method for realizing the application program running.

In addition, an embodiment of the present application further provides a computer-readable storage medium, where instructions are stored in the computer-readable storage medium, and when the instructions are executed on a terminal device, the instructions cause the terminal device to execute any implementation of the method for implementing application running as described above.

It should be noted that, in the present specification, the embodiments are described in a progressive manner, each embodiment focuses on differences from other embodiments, and the same and similar parts among the embodiments may be referred to each other. For the system or the device disclosed by the embodiment, the description is simple because the system or the device corresponds to the method disclosed by the embodiment, and the relevant points can be referred to the method part for description.

It should be understood that in the present application, "at least one" means one or more, "a plurality" means two or more. "and/or" for describing an association relationship of associated objects, indicating that there may be three relationships, e.g., "a and/or B" may indicate: only A, only B and both A and B are present, wherein A and B may be singular or plural. The character "/" generally indicates that the former and latter associated objects are in an "or" relationship. "at least one of the following" or similar expressions refer to any combination of these items, including any combination of single item(s) or plural items. For example, at least one (one) of a, b, or c, may represent: a, b, c, "a and b", "a and c", "b and c", or "a and b and c", wherein a, b, c may be single or plural.

It is further noted that, herein, relational terms such as first and second, and the like may be used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Also, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other identical elements in a process, method, article, or apparatus that comprises the element.

The steps of a method or algorithm described in connection with the embodiments disclosed herein may be embodied directly in hardware, in a software module executed by a processor, or in a combination of the two. A software module may reside in Random Access Memory (RAM), memory, Read Only Memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, hard disk, a removable disk, a CD-ROM, or any other form of storage medium known in the art.

The previous description of the disclosed embodiments is provided to enable any person skilled in the art to make or use the present application. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the generic principles defined herein may be applied to other embodiments without departing from the spirit or scope of the application. Thus, the present application is not intended to be limited to the embodiments shown herein but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A method for realizing application program running is applied to a cluster computing system, the cluster computing system comprises a first system on chip and a second system on chip, the first system on chip comprises a first container coordinator and a first container management program, the second system on chip comprises a second container coordinator, and the method comprises the following steps:

2. The method according to claim 1, wherein the generating of the container image file corresponding to the application program comprises:

configuring a running environment variable of the containerized firmware;

specifying an initial program of the containerized firmware at boot-up;

3. The method of claim 1, wherein the first container coordinator obtaining a start request of an application and sending the start request of the application to the first container manager comprises:

4. The method according to claim 1, wherein the first container coordinator triggers to update the corresponding display content of the first system on chip according to the event change information, and the method comprises:

5. The method of claim 1 or 4, wherein the first system-on-chip further comprises a first display module, wherein the second system-on-chip further comprises a second display module, and wherein the method further comprises:

6. The method of claim 1, wherein the second system-on-chip further comprises a second container manager; the method further comprises the following steps:

7. A first container coordinator, wherein the first container coordinator is located in the first system on a chip; the first system on a chip further comprises a first container management program; the first system on a chip is located in the cluster computing system; the clustered computing system further comprises a second system-on-chip; the second system-on-chip comprises a second container coordinator; the first container coordinator comprising:

8. A clustered computing system, the clustered computing system comprising a first system on a chip comprising a first container coordinator and a first container manager, and a second system on a chip comprising a second container coordinator;

9. An apparatus for implementing application program operation, comprising: a memory, a processor, and a computer program stored on the memory and executable on the processor, the processor implementing the method of implementing application execution as claimed in any one of claims 1-6 when executing the computer program.

10. A computer-readable storage medium, having stored therein instructions, which, when run on a terminal device, cause the terminal device to execute a method of enabling application running according to any one of claims 1-6.