CN118093008A

CN118093008A - Multi-platform embedded software management method, system, equipment and storage medium

Info

Publication number: CN118093008A
Application number: CN202410239501.9A
Authority: CN
Inventors: 孙舒婷; 李世豪; 杨坤兴; 黄鹏
Original assignee: Zhejiang Dahua Technology Co Ltd
Current assignee: Zhejiang Dahua Technology Co Ltd
Priority date: 2024-03-01
Filing date: 2024-03-01
Publication date: 2024-05-28

Abstract

The invention discloses a method, a system, equipment and a storage medium for managing multi-platform embedded software, wherein the method comprises the following steps: acquiring a target program provided by any platform, and compiling the target program into an intermediate code file; compiling the intermediate code file by utilizing the just-in-time compiling component, and removing the difference between multiple platforms to obtain an executable file or a dynamic library with corresponding functions and interfaces thereof; the executable file or the dynamic library is correspondingly stored in the version management library according to the time and the function as an index. By the method, the files corresponding to the multiple platforms can be managed according to functions by using the single version management library, the corresponding version management library does not need to be set for the multiple platforms, and management efficiency is improved.

Description

Multi-platform embedded software management method, system, equipment and storage medium

Technical Field

The present application relates to the field of software management technologies, and in particular, to a method, a system, an apparatus, and a storage medium for managing multi-platform embedded software.

Background

In the process of software development and delivery of embedded platforms, it is generally necessary to provide compiled files for a plurality of embedded platforms using different compiling tool chains, and the cross compiling tool chains required for compiling the files are different for different platforms. For embedded software developers, although the functions and codes are not changed, when different platform requirements come, compiling tasks need to be triggered again to provide compiling files which can be loaded by a target platform correctly.

Because the cross-compilation tool chains required to compile files are different for different platforms, separate version management libraries need to be provided for each platform. When the embedded platform which needs to be maintained gradually increases along with the continuous expansion of the business, the number of historical versions of the delivery file is rapidly increased, and the workload of version management and control of the delivery file is not negligible.

Disclosure of Invention

The application provides a method, a system, equipment and a storage medium for managing multi-platform embedded software, which can manage files of a plurality of platforms according to functions by utilizing a single version management library without setting corresponding version management libraries for the plurality of platforms, thereby improving management efficiency.

In order to solve the technical problems, the application adopts a technical scheme that: the method for managing the multi-platform embedded software comprises the following steps: acquiring a target program provided by any platform, and compiling the target program into an intermediate code file; compiling the intermediate code file by utilizing the just-in-time compiling component, and removing the difference between multiple platforms to obtain an executable file or a dynamic library with corresponding functions and interfaces thereof; the executable file or the dynamic library is correspondingly stored in the version management library according to the time and the function as an index.

The method comprises the steps of compiling an intermediate code file by utilizing a just-in-time compiling component, removing differences among multiple platforms, and obtaining an executable file or a dynamic library with corresponding functions and interfaces thereof, wherein the method comprises the following steps: dynamically compiling the intermediate code file by utilizing a just-in-time compiling component; and optimizing the program execution efficiency in the compiling process, and removing the difference between multiple platforms to obtain an executable file or a dynamic library with corresponding functions and interfaces thereof.

The method for optimizing the program execution efficiency in the compiling process, removing the difference among multiple platforms to obtain an executable file or a dynamic library with corresponding functions and interfaces thereof comprises the following steps: optimizing program execution efficiency in the compiling process, removing differences among multiple platforms, and packaging an external interface of a unified protocol to obtain an executable file or a dynamic library with corresponding functions and interfaces thereof.

Wherein, the external interface of encapsulation unified protocol includes: in the packaging layer code of the intermediate code file, a module which needs to be compiled into machine code In real time is marked by using a functional interface provided by a JIT (Just-In-Time compiler) framework, so that the packaging of an external interface of a unified protocol is realized.

Wherein the method further comprises: in response to receiving the target demand, analyzing the target demand, and determining whether a target executable file corresponding to the target demand or a target dynamic library with corresponding functions and interfaces thereof exists in the version management library; if not, program development is carried out according to the target requirement to obtain a requirement program; compiling the demand program into a target executable file or a target dynamic library and storing the target executable file or the target dynamic library in a version management library; if so, acquiring a target executable file or a target dynamic library from the version management library.

Wherein, after obtaining the target executable file or the target dynamic library from the version management library, the method comprises the following steps: acquiring a mark of a target platform to be deployed of a target executable file or a target dynamic library; and compiling the target executable file or the target dynamic library into machine code executable by the target platform according to the mark.

Wherein the target program is a middleware.

In order to solve the technical problems, the application adopts another technical scheme that: there is provided a management system of multi-platform embedded software, the management system comprising: the communication interface is coupled with the plurality of platforms and is used for acquiring a target program provided by any platform; the controller is coupled with the communication interface and used for compiling the target program into an intermediate code file; compiling the intermediate code file by utilizing the just-in-time compiling component, and removing the difference between multiple platforms to obtain an executable file or a dynamic library with corresponding functions and interfaces thereof; and the version management library is used for storing the executable file or the dynamic library as an index according to time and functions.

In order to solve the technical problems, the application adopts another technical scheme that: there is provided an electronic device comprising a memory and a processor coupled to the memory, the memory storing at least one computer program for implementing the method provided by the above technical scheme when the at least one computer program is loaded and executed by the processor.

In order to solve the technical problems, the application adopts another technical scheme that: there is provided a computer readable storage medium having at least one program for implementing the method provided in the above technical solution, when the at least one program is loaded and executed by a processor.

Different from the prior art, the management method, the system, the equipment and the storage medium of the multi-platform embedded software provided by the application utilize the instant compiling component to compile the intermediate code file, remove the difference between the multiple platforms and obtain the executable file or the dynamic library with the corresponding functions and interfaces thereof; storing executable files or dynamic libraries in the version management libraries correspondingly according to time and function indexes, so that files of a plurality of platforms can be managed by using a single version management library according to functions, and setting corresponding version management libraries for the plurality of platforms is not needed; furthermore, the method can be used for directly and rapidly indexing according to functions when the executable file or the dynamic library is acquired, so that the management efficiency is improved.

Drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings required for the description of the embodiments will be briefly described below, and it is apparent that the drawings in the following description are only some embodiments of the present application, and other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art. Wherein:

FIG. 1 is a flow chart of an embodiment of a method for managing multi-platform embedded software according to the present application;

FIG. 2 is a flowchart of an embodiment of a method for managing multi-platform embedded software according to the present application;

FIG. 3 is a schematic diagram of a version management library in the method for managing multi-platform embedded software according to the present application;

FIG. 4 is a flowchart illustrating another embodiment of a method for managing multi-platform embedded software according to the present application;

FIG. 5 is a flowchart illustrating another embodiment of a method for managing multi-platform embedded software according to the present application;

FIG. 6 is a schematic diagram illustrating an embodiment of a management system for multi-platform embedded software according to the present application;

FIG. 7 is a schematic diagram of an embodiment of an electronic device according to the present application;

fig. 8 is a schematic diagram illustrating the structure of an embodiment of a computer-readable storage medium according to the present application.

Detailed Description

The invention is described in further detail below with reference to the drawings and examples. It is specifically noted that the following examples are only for illustrating the present invention, but do not limit the scope of the present invention. Likewise, the following examples are only some, but not all, of the examples of the present invention, and all other examples, which a person of ordinary skill in the art would obtain without making any inventive effort, are within the scope of the present invention.

Reference herein to "an embodiment" means that a particular feature, structure, or characteristic described in connection with the embodiment may be included in at least one embodiment of the invention. The appearances of such phrases in various places in the specification are not necessarily all referring to the same embodiment, nor are separate or alternative embodiments mutually exclusive of other embodiments. Those of skill in the art will explicitly and implicitly appreciate that the embodiments described herein may be combined with other embodiments.

Based on the method, the application provides that the instant compiling component is utilized to compile the intermediate code file, so as to remove the difference between multiple platforms and obtain an executable file or a dynamic library with corresponding functions and interfaces thereof; storing executable files or dynamic libraries in the version management libraries correspondingly according to time and function indexes, so that files of a plurality of platforms can be managed by using a single version management library according to functions, and setting corresponding version management libraries for the plurality of platforms is not needed; furthermore, the method can be used for directly and rapidly indexing according to functions when the executable file or the dynamic library is acquired, so that the management efficiency is improved. See in particular any of the examples below.

Referring to fig. 1, fig. 1 is a flowchart illustrating an embodiment of a method for managing multi-platform embedded software according to the present application. The method comprises the following steps:

step 11: and acquiring the target program provided by any platform, and compiling the target program into an intermediate code file.

In some embodiments, the platform referred to in the present application is a development platform for embedded software. The software developer can write the code logic on the corresponding platform by using the programming language to form the program with the corresponding function.

The execution main body of the management method is electronic equipment which can be separated from the development platform. I.e. the development platform may be implemented by another electronic device.

In other embodiments, the platform may be integrally provided with the electronic device, i.e., the electronic device may not only perform software management, but may also provide a development platform for a software developer. In some embodiments, multiple platforms may be provided on one electronic device.

The type of each platform described above may be different. If the platform A provides C++ language development, the platform B provides C language development, and the platform C provides JAVA language development.

When a developer on any platform completes writing a corresponding program, the program (target program) can be sent to the electronic device, and the electronic device compiles the program into an intermediate code file by utilizing corresponding logic.

Step 12: and compiling the intermediate code file by utilizing the just-in-time compiling component, and removing the difference between multiple platforms to obtain an executable file or a dynamic library with corresponding functions and interfaces thereof.

Because the object program is compiled on the platform, each platform has its own unique properties. In the related technology, according to the platform attribute, a corresponding version storage space is opened for each platform, and management is carried out according to the platform. Specifically, the differences between multi-platform programs are formed by the cross compiler importation of diversity.

In this embodiment, the just-in-time compiling component is utilized to compile the intermediate code file, so as to remove the difference between multiple platforms, and obtain the executable file or the dynamic library with the corresponding function and the interface thereof. I.e. there is no platform-to-platform difference in the executable files mentioned in the present application or in the dynamic libraries with corresponding functions and their interfaces.

Step 13: the executable file or the dynamic library is correspondingly stored in the version management library according to the time and the function as an index.

Where version numbers may be used to characterize the time of an executable file or dynamic library. It will be appreciated that the programs formed at different times are distinguished and may therefore be distinguished by version numbers. If the initial version number is 1, the version numbers of the subsequent executable files or the dynamic libraries with corresponding functions and interfaces thereof can be sequentially overlapped according to time.

In some embodiments, described in conjunction with fig. 2 and 3:

As shown in fig. 2, in the related art, corresponding version management libraries are provided for different platforms due to platform differences.

As shown in fig. 3, the application removes platform differences, uses a version management library, stores executable files of programs or dynamic libraries with corresponding functions and interfaces thereof according to time and functions as indexes, and can finish program management of all platforms.

In the embodiment, the instant compiling component is utilized to compile the intermediate code file, so as to remove the difference between multiple platforms, and obtain an executable file or a dynamic library with corresponding functions and interfaces thereof; storing executable files or dynamic libraries in the version management libraries correspondingly according to time and function indexes, so that files of a plurality of platforms can be managed by using a single version management library according to functions, and setting corresponding version management libraries for the plurality of platforms is not needed; furthermore, the method can be used for directly and rapidly indexing according to functions when the executable file or the dynamic library is acquired, so that the management efficiency is improved.

Further, when the embedded platform is newly added, because the executable files in the version management library or the dynamic library with the corresponding functions and the interfaces thereof have no platform difference, the executable files in the version management library or the dynamic library with the corresponding functions and the interfaces thereof can be reused by the newly added embedded platform, and the compiling environment adapting to the new embedded platform is not required to be added, so that the efficiency of embedded development is improved.

Similarly, since the executable file of each function or the dynamic library with the corresponding function and the interface thereof in the version management library has no platform difference, the existing executable file or the dynamic library with the corresponding function and the interface thereof can be shared by all the platforms. When the platform needs to use the function, the function can be directly used for multiplexing according to the function search, the platform is not required to develop the function again, and the efficiency of embedded development is improved.

Referring to fig. 4, fig. 4 is a flowchart illustrating a method for managing multi-platform embedded software according to another embodiment of the present application. The method comprises the following steps:

step 41: and acquiring the target program provided by any platform, and compiling the target program into an intermediate code file.

Step 41 has the same or similar technical scheme as any embodiment of the present application, and will not be described herein.

Step 42: dynamically compiling the intermediate code file by utilizing a just-in-time compiling component; and optimizing the program execution efficiency in the compiling process, and removing the difference between multiple platforms to obtain an executable file or a dynamic library with corresponding functions and interfaces thereof.

In some embodiments, the just-in-time compilation component, at runtime, dynamically compiles intermediate code files based on platform differences with the goal of optimizing program execution efficiency, and ultimately generates machine code that can be understood by the machine at runtime.

Further, in the compiling process, the program execution efficiency is optimized, the difference between multiple platforms is removed, and the external interfaces of the unified protocol are packaged to obtain executable files or dynamic libraries with corresponding functions and interfaces thereof.

In some embodiments, in the packaging layer code of the intermediate code file, the function interface provided by the JIT framework is used to mark the module that needs to be compiled into the machine code in real time, so as to implement packaging of the external interface of the unified protocol, and if the obtained executable file or the dynamic library with the corresponding function and the interface thereof has no platform attribute corresponding to the target program, step 43 can be executed.

Step 43: the executable file or the dynamic library is correspondingly stored in the version management library according to the time and the function as an index.

Step 43 has the same or similar technical scheme as any embodiment of the present application, and will not be described herein.

In this embodiment, the instant compiling component is utilized to compile the intermediate code file, remove the difference between multiple platforms, and perform unified protocol encapsulation to obtain an executable file or a dynamic library with corresponding functions and interfaces thereof; the executable files or the dynamic libraries with the corresponding functions and interfaces thereof are correspondingly stored in the version management libraries according to the time and the function as indexes, so that the files corresponding to a plurality of platforms can be managed according to the function by utilizing a single version management library without setting the corresponding version management libraries for the plurality of platforms, and furthermore, the executable files or the dynamic libraries with the corresponding functions and interfaces thereof can be directly and quickly indexed according to the function when being acquired, thereby improving the management efficiency. The version maintenance functions of multiple platforms, multiple versions and multiple functional branches can be realized by utilizing one version management library, the workload of version maintenance is reduced, and the delivery efficiency of the program file can be effectively improved.

Referring to fig. 5, fig. 5 is a flowchart illustrating a method for managing multi-platform embedded software according to another embodiment of the present application. The method comprises the following steps:

Step 51: in response to receiving the target demand, the target demand is analyzed.

The general requirement is a requirement for a program, such as a need for a certain function. Therefore, the target demand can be analyzed to obtain the demand function. As can be seen from the above embodiments, the version management library of the present application stores a plurality of executable files according to functions and/or has a dynamic library with corresponding functions and interfaces thereof. Step 52 may be performed by first determining whether the function exists in the version management library, and the executable file corresponding to the function and/or the dynamic library having the corresponding function and its interface.

Step 52: and determining whether a target executable file or a target dynamic library corresponding to the target requirement exists in the version management library.

If the version management library does not have the target executable file or the target dynamic library corresponding to the target requirement, step 53 is executed. If there is a target executable file or a target dynamic library corresponding to the target requirement in the version management library, step 55 is executed.

Step 53: and developing the program according to the target requirement to obtain a requirement program.

The version management library does not have a target executable file or a target dynamic library corresponding to the target requirement, and a developer of a corresponding platform can be prompted to develop a program to obtain a requirement program corresponding to the function.

Step 54: the demand program is compiled into a target executable file or a target dynamic library and stored in a version management library.

And compiling the demand program according to the process of the embodiment to obtain a corresponding target executable file, and storing the target executable file in a version management library. And feeding back the executable file or the target dynamic library to the demand end.

Step 55: and acquiring a target executable file or a target dynamic library from the version management library.

And acquiring a target executable file or a target dynamic library from the version management library and feeding back the target executable file or the target dynamic library to the demand terminal.

Further, in some embodiments, after the target executable file or the target dynamic library is obtained from the version management library, a flag of a target platform that needs to be deployed by the target executable file or the target dynamic library may be obtained; and compiling the target executable file or the target dynamic library into machine code executable by the target platform according to the mark, so as to realize the deployment of the executable file or the target dynamic library on the platform.

In some embodiments, the object is middleware that can be used by upper layer applications.

In an application scenario, the scheme provided by the application can solve the defects and problems existing at present in the stages of multi-platform compiling, function updating, version iteration, multi-platform function verification, version management, continuous integration and the like in the embedded software development flow.

For example, after the function update development of the embedded program is completed once, the scheme provided by the application can obtain an executable file version or a dynamic library version with a new function through one-time compiling, and then, the executable file or the dynamic library is maintained in a version management library with the software update function as an index according to a function update time line. When the demand comes, an executable file version or a dynamic library version with corresponding functions can be provided directly according to the demand, and the executable file or the dynamic library can be directly delivered to an upper layer application, so that the upper layer can call the currently required functions indifferently according to an interaction protocol. After the development of the upper layer application is completed, the upper layer application is deployed on various platforms to complete the demand delivery.

Namely, the program for realizing the specific function in the application can be uniformly developed by shielding the difference of the platforms; and secondly, compiling the program to obtain an intermediate code file based on a real-time compiling technology, packaging an external unified interface by using a JIT compiling component, and generating an executable file or a dynamic library. The generated executable file or dynamic library is stored and managed in the version management library according to the branches of time and functions.

Specifically, the JIT (Just in Time) compiling component can realize the functions of dynamically translating the intermediate code file with the aim of optimizing the program execution efficiency according to the platform difference when running based on the intermediate code file of the program, and finally generating machine code which can be understood by a machine when running. The external interface defines a protocol for providing the functions of the embedded software to the upper layer application according to a certain interface definition specification. The process of packaging the unified protocol of the external interface by using the JIT compiling component marks a module which needs to be compiled into a machine code in real time for the functional interface provided by the JIT framework in the original packaging layer code, so that the packaging layer can achieve the effect of one-time compiling and multi-platform running, and the aim of shielding the lower layer platform difference is fulfilled. The executable file or the dynamic library is an output product provided by the application and having the function of realizing multi-platform operation through one-time compiling. The version management library of the application is equivalent to an embedded software shelf with different functions for upper-layer application, and can take the corresponding version in the library according to the requirement.

Further, the middleware development flow realized by the method provided by the application is as follows:

Step 1: and (5) demand analysis. In order to determine whether the version management library needs to be updated, the incoming demand needs to be analyzed, and whether a middleware version capable of meeting the current incoming demand exists in the current version management library is searched. If yes, executing the step 2, otherwise, jumping to the step 3.

Step 2: and (5) version retrieval. And (5) searching the required version according to the index mode of the version management library, namely according to time and functions, and jumping to the step (5) after the required version is obtained.

Step 3: new functional development based on real-time compilation technology. Firstly, verifying the completeness and stability of the function according to the development of new requirements and the flow of function test to form a corresponding program. And then sequentially generating an intermediate code file and an encapsulated external protocol according to a packaging flow of a real-time compiling technology, and generating an executable file or a dynamic library.

Step 4: and (6) warehousing the new version. Storing the executable file or the dynamic library corresponding to the embedded software developed and verified in the step 3 into a version management library according to a version management library index mode, specifically adding the executable file or the dynamic library obtained by the development on the corresponding functional branches and version indexes according to an organization mode of the version management library, so as to update the version management library.

Step 5: and (5) demand delivery. And indexing according to the function and version history, taking out an executable file or a dynamic library corresponding to the needed embedded software, and carrying out demand delivery.

Referring to fig. 6, fig. 6 is a schematic structural diagram of an embodiment of a management system for multi-platform embedded software according to the present application. The management system 100 includes: a communication interface 10, a controller 20 and a version management library 30.

The communication interface 10 is coupled to a plurality of platforms for acquiring a target program provided by any one of the platforms. The controller 20 is coupled to the communication interface 10 for compiling the object program into an intermediate code file; and compiling the intermediate code file by utilizing the just-in-time compiling component, and removing the difference between multiple platforms to obtain an executable file or a dynamic library with corresponding functions and interfaces thereof.

The version management library 30 is used to store executable files or dynamic libraries indexed by time and function.

It will be appreciated that the communication interface 10, the controller 20 and the version management library 30 cooperate to implement the method of any of the above embodiments.

Referring to fig. 7, fig. 7 is a schematic structural diagram of an electronic device according to an embodiment of the application. The electronic device 70 comprises a memory 71 and a processor 72 coupled to the memory 71, the memory 71 storing at least one computer program for implementing the following methods when loaded and executed by the processor 72:

Acquiring a target program provided by any platform, and compiling the target program into an intermediate code file; compiling the intermediate code file by utilizing the just-in-time compiling component, and removing the difference between multiple platforms to obtain an executable file or a dynamic library with corresponding functions and interfaces thereof; the executable file or the dynamic library is correspondingly stored in the version management library according to the time and the function as an index.

It will be appreciated that at least one computer program, when loaded and executed by the processor 72, is also operative to implement the methods of any of the embodiments described above.

Referring to fig. 8, fig. 8 is a schematic structural diagram of an embodiment of a computer readable storage medium according to the present application. The computer-readable storage medium 80 has at least one program 81, and the at least one program 81, when loaded and executed by a processor, is configured to implement the following method:

It will be appreciated that at least one program 81, when loaded and executed by a processor, is operative to implement a method of any of the embodiments described above.

In summary, the method, system, device and storage medium for managing multi-platform embedded software provided by the application utilize the just-in-time compiling component to compile the intermediate code file, remove the difference between multiple platforms and obtain the executable file or the dynamic library with the corresponding function and interface; storing executable files or dynamic libraries in the version management libraries correspondingly according to time and function indexes, so that files of a plurality of platforms can be managed by using a single version management library according to functions, and setting corresponding version management libraries for the plurality of platforms is not needed; furthermore, the executable files can be directly and rapidly indexed according to functions when being acquired, and management efficiency is improved.

Further, when the embedded platform is newly added, because the executable files or the dynamic libraries in the version management library have no platform difference, the executable files or the dynamic libraries in the version management library can be reused by the newly added embedded platform, and the compiling environment adapting to the new embedded platform is not required to be added, so that the efficiency of embedded development is improved.

In the several embodiments provided in the present invention, it should be understood that the disclosed systems, devices, and methods may be implemented in other manners. For example, the apparatus embodiments described above are merely illustrative, e.g., the division of the modules or units is merely a logical functional division, and there may be additional divisions when actually implemented, e.g., multiple units or components may be combined or integrated into another system, or some features may be omitted, or not performed. Alternatively, the coupling or direct coupling or communication connection shown or discussed with each other may be an indirect coupling or communication connection via some interfaces, devices or units, which may be in electrical, mechanical or other form.

The units described as separate units may or may not be physically separate, and units shown as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the embodiment.

In addition, each functional unit in each embodiment of the present invention may be integrated in one processing unit, each unit may exist alone physically, or two or more units may be integrated in one unit. The integrated units may be implemented in hardware or in software functional units.

The integrated units, if implemented in the form of software functional units and sold or used as stand-alone products, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present invention may be embodied in essence or a part contributing to the prior art or all or part of the technical solution in the form of a software product stored in a storage medium, including several instructions for causing a computer device (which may be a personal computer, a server, or a network device, etc.) or a processor (processor) to execute all or part of the steps of the method according to the embodiments of the present invention. And the aforementioned storage medium includes: a usb disk, a removable hard disk, a Read-Only Memory (ROM), a random access Memory (RAM, random Access Memory), a magnetic disk, or an optical disk, or other various media capable of storing program codes.

The foregoing description is only of embodiments of the present invention, and is not intended to limit the scope of the invention, and all equivalent structures or equivalent processes using the descriptions and the drawings of the present invention or directly or indirectly applied to other related technical fields are included in the scope of the present invention.

Claims

1. A method for managing multi-platform embedded software, the method comprising:

Acquiring a target program provided by any platform, and compiling the target program into an intermediate code file;

compiling the intermediate code file by utilizing a just-in-time compiling component, and removing differences among multiple platforms to obtain an executable file or a dynamic library with corresponding functions and interfaces thereof;

And correspondingly storing the executable file or the dynamic library into a version management library according to the time and the function as indexes.

2. The method according to claim 1, wherein compiling the intermediate code file with the just-in-time compiling component to remove differences between multiple platforms and obtain an executable file or a dynamic library with corresponding functions and interfaces thereof, comprises:

dynamically compiling the intermediate code file using the just-in-time compilation component;

and optimizing the program execution efficiency in the compiling process, and removing the difference between multiple platforms to obtain the executable file or the dynamic library with corresponding functions and interfaces thereof.

3. The method according to claim 2, wherein optimizing program execution efficiency during compiling, removing differences between multiple platforms, and obtaining the executable file or the dynamic library with corresponding functions and interfaces thereof, comprises:

Optimizing program execution efficiency in the compiling process, removing differences among multiple platforms, and packaging an external interface of a unified protocol to obtain the executable file or a dynamic library with corresponding functions and interfaces thereof.

4. The method of claim 3, wherein encapsulating the unified protocol external interface comprises:

In the encapsulation layer code of the intermediate code file, a function interface provided by a JIT framework is used for marking a module which needs to be compiled into machine codes in real time, so that the encapsulation of an external interface of a unified protocol is realized.

5. The method according to claim 1, wherein the method further comprises:

in response to receiving a target demand, analyzing the target demand, and determining whether a target executable file corresponding to the target demand or a target dynamic library with corresponding functions and interfaces thereof exists in the version management library;

if not, program development is carried out according to the target requirement to obtain a requirement program;

Compiling the demand program into a target executable file or a target dynamic library and storing the target executable file or the target dynamic library in the version management library;

if yes, the target executable file or the target dynamic library is obtained from the version management library.

6. The method of claim 5, wherein the obtaining the target executable file or the target dynamic library from the version management library comprises:

Acquiring a mark of a target platform to be deployed of the target executable file or the target dynamic library;

And compiling the target executable file or the target dynamic library into machine codes executable by the target platform according to the marks.

7. The method of any of claims 1-6, wherein the target program is middleware.

8. A management system for multi-platform embedded software, the management system comprising:

The communication interface is coupled with the plurality of platforms and is used for acquiring a target program provided by any platform;

The controller is coupled with the communication interface and used for compiling the target program into an intermediate code file; compiling the intermediate code file by utilizing a just-in-time compiling component, and removing differences among multiple platforms to obtain an executable file or a dynamic library with corresponding functions and interfaces thereof;

And the version management library is used for storing the executable file or the dynamic library as an index according to time and functions.

9. An electronic device comprising a memory and a processor coupled to the memory, the memory storing at least one computer program that, when loaded and executed by the processor, is configured to implement the method of any of claims 1-7.

10. A computer readable storage medium, characterized in that the computer readable storage medium has at least one program, which when loaded and executed by a processor is adapted to carry out the method according to any one of claims 1-7.