Application program compilation and operation method and device, and storage medium

Abstract

The present disclosure provides an application compilation and operation method, device, and storage medium. The compilation method includes: extracting information to be compiled from the bytecode file corresponding to the application; constructing a data structure corresponding to the information to be compiled; compiling the bytecode file based on the data structure corresponding to the information to be compiled to generate an intermediate file; determining file description information for describing the information content included in the intermediate file; and generating a target file after compiling the application based on the intermediate file and the file description information. The present disclosure can realize the in-situ execution of the application, saving a large amount of memory of the Internet of Things device, and is applicable to a variety of Internet of Things device platforms. It has the value of being used on small or even micro embedded Internet of Things device systems, and has high availability and security.

Description

Technical Field

[0001] The present disclosure relates to the field of software compilation, and in particular to a method and device for compiling and running an application program, and a storage medium. Background Art

[0002] Currently, when an Internet of Things (IoT) device runs an application, it needs to copy the code file corresponding to the application from the flash memory to the memory, read the file from the memory and then start the application, which causes a large amount of memory consumption. Summary of the invention

[0003] In view of this, the present application discloses a method and device for compiling and running an application, and a storage medium.

[0004] According to a first aspect of an embodiment of the present disclosure, a method for compiling an application is provided, the method being applied to a terminal, the method comprising:

[0005] Extracting information to be compiled from a bytecode file corresponding to the application;

[0006] Constructing a data structure corresponding to the information to be compiled;

[0007] Compiling the bytecode file based on a data structure corresponding to the information to be compiled to generate an intermediate file;

[0008] Determining file description information for describing information content included in the intermediate file;

[0009] Based on the intermediate file and the file description information, a target file after compiling the application is generated.

[0010] Optionally, the method further comprises:

[0011] Verifying at least one of the integrity and legality of the bytecode file and determining a verification result;

[0012] In the case where the verification result indicates that the bytecode file is a complete file and / or a legal file, the step of extracting the information to be compiled from the bytecode file corresponding to the application is performed.

[0013] Optionally, the constructing a data structure corresponding to the information to be compiled includes at least one of the following:

[0014] In the case where the information to be compiled includes data segment information to be compiled, determining a first memory space corresponding to the data segment information; wherein the size of the first memory space is equal to the amount of data indicated by the data segment information;

[0015] In the case that the information to be compiled includes code segment information to be compiled, at least one array is determined based on the number of interfaces of the function included in the code segment information; wherein the number of the arrays is equal to the number of the interfaces.

[0016] Optionally, compiling the bytecode file based on a data structure corresponding to the information to be compiled to generate an intermediate file includes:

[0017] Based on the data structure corresponding to the information to be compiled, converting the instructions included in the bytecode file into an intermediate representation of the underlying virtual machine;

[0018] Based on the intermediate representation, the intermediate file is generated.

[0019] Optionally, the converting the code included in the bytecode file into an intermediate representation of an underlying virtual machine based on a data structure corresponding to the information to be compiled includes:

[0020] In the case where the instruction includes a data access instruction, converting the address accessed by the data access instruction into the intermediate representation for accessing a first memory space; wherein the first memory space is a memory space determined when constructing the data structure;

[0021] In the case where the instruction includes a function definition instruction, converting the function definition instruction into an intermediate representation that determines the serial number of the defined function and stores the serial number in an array corresponding to the defined function; wherein the array is determined when constructing the data structure;

[0022] In the case where the instruction includes a function call instruction, converting the function call instruction into the intermediate representation for calling from the array corresponding to the called function;

[0023] In the case where the instruction includes a switch instruction, converting the switch instruction into the intermediate representation in a conditional jump manner;

[0024] In the case where the instruction includes an atomic instruction, the atomic instruction is converted into the data access instruction; wherein the atomic instruction refers to an instruction that allows only one processor to perform read and write operations on the cache within the same time period.

[0025] Optionally, the method further comprises:

[0026] In the case where the instruction includes a function call instruction, a data structure parameter is added before the parameter included in the bytecode file.

[0027] Optionally, the file description information includes at least one of the following:

[0028] Correspondence information between the serial numbers of the functions included in the intermediate file and the naming information of the functions;

[0029] Using description information of a first memory space; wherein the first memory space is a memory space determined when constructing the data structure;

[0030] The intermediate file includes mapping relationship information between function names and function indexes; wherein the function index is determined based on the serial number of the function.

[0031] Optionally, generating a target file after compiling the application based on the intermediate file and the file description information includes:

[0032] Copying the code segment included in the intermediate file to the file to be generated;

[0033] The file description information is generated at a specified location of the file to be generated to obtain the target file.

[0034] Optionally, after generating the target file, the method further includes:

[0035] The target file is sent to the IoT device.

[0036] According to a second aspect of an embodiment of the present disclosure, a method for running an application is provided, the method being applied to an Internet of Things (IoT) device, the method comprising:

[0037] When the application needs to be run, a target file is loaded from the flash memory; wherein the target file is a file obtained based on any of the above-mentioned application compilation methods;

[0038] After the target file is loaded, the application is started.

[0039] Optionally, the loading of the target file from the flash memory includes:

[0040] The target file is loaded from the flash memory based on the file description information included in the target file.

[0041] Optionally, the loading the target file from the flash memory based on the file description information included in the target file includes:

[0042] Based on the correspondence relationship information between the serial number of the function included in the file description information and the naming information of the function, determining an interface corresponding to each of the functions in the system of the IoT device;

[0043] Recording the interface in an array of data structures corresponding to each of the functions;

[0044] Allocate a second memory space for the target file based on the description information of using the first memory space included in the file description information; wherein the size of the second memory space is equal to the size of the first memory space;

[0045] Based on the mapping relationship information between the function name and the function index included in the file description information, the array of the data structure corresponding to each of the functions is sorted.

[0046] Optionally, starting the application includes:

[0047] The application is started through the interface recorded in the array corresponding to the sorted specified order.

[0048] According to a third aspect of an embodiment of the present disclosure, there is provided an application compilation device, the device being applied to a terminal, the device comprising:

[0049] An extraction module, used to extract information to be compiled from a bytecode file corresponding to the application;

[0050] A construction module, used to construct a data structure corresponding to the information to be compiled;

[0051] A first generating module, used to compile the bytecode file based on a data structure corresponding to the information to be compiled to generate an intermediate file;

[0052] A determination module, used to determine file description information used to describe the information content included in the intermediate file;

[0053] The second generating module is used to generate a target file after compiling the application based on the intermediate file and the file description information.

[0054] According to a fourth aspect of an embodiment of the present disclosure, a device for running an application is provided, the device being applied to an Internet of Things (IoT) device, the device comprising:

[0055] A loading module, used to load a target file from a flash memory when the application needs to be run; wherein the target file is a file obtained based on any of the above-mentioned application compilation methods;

[0056] A startup module is used to start the application after loading the target file.

[0057] According to a fifth aspect of an embodiment of the present disclosure, there is provided a computer-readable storage medium on which a computer program is stored. When the computer program is executed by a processor, the steps of the application compilation method described in any one of the above items are implemented.

[0058] According to a sixth aspect of an embodiment of the present disclosure, there is provided a computer-readable storage medium on which a computer program is stored. When the computer program is executed by a processor, the steps of the application running method described in any one of the above items are implemented.

[0059] According to a seventh aspect of an embodiment of the present disclosure, there is provided an application compilation device, including:

[0060] processor;

[0061] a memory for storing processor-executable instructions;

[0062] The processor is configured to execute the executable instructions to implement any of the steps of the application compilation method described above.

[0063] According to an eighth aspect of an embodiment of the present disclosure, there is provided an application program running device, including:

[0064] processor;

[0065] a memory for storing processor-executable instructions;

[0066] The processor is configured to execute the executable instructions to implement the steps of any of the above-mentioned application running methods.

[0067] The technical solution provided by the embodiments of the present disclosure may have the following beneficial effects:

[0068] In the present disclosure, the terminal can precompile the bytecode file corresponding to the application to obtain the compiled target file. When the IoT device needs to run the application, it can directly load the target file from the flash memory to start the application. The present disclosure can realize the in-situ execution of the application, saving a large amount of memory of the IoT device, and is applicable to a variety of IoT device platforms. It has the value of being used on small or even micro embedded IoT device systems, and has high availability and security.

[0069] It is to be understood that the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the present disclosure. BRIEF DESCRIPTION OF THE DRAWINGS

[0070] The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the invention and, together with the description, serve to explain the principles of the invention.

[0071] Figure 1 It is a flowchart of an application compilation method in the related art;

[0072] Figure 2is a flowchart of an application compilation method according to an exemplary embodiment of the present disclosure;

[0073] Figure 3 is a flowchart of another application compilation method according to an exemplary embodiment of the present disclosure;

[0074] Figure 4 is a flowchart of another application compilation method according to an exemplary embodiment of the present disclosure;

[0075] Figure 5 is a flowchart of another application compilation method according to an exemplary embodiment of the present disclosure;

[0076] Figure 6 is a flowchart of a method for running an application program according to an exemplary embodiment of the present disclosure;

[0077] Figure 7 is a flowchart of another application program running method according to an exemplary embodiment of the present disclosure;

[0078] Figure 8 is a flowchart of a method for compiling and running an application program according to an exemplary embodiment of the present disclosure;

[0079] Fig. 9 is a block diagram of an application compilation device according to an exemplary embodiment of the present disclosure;

[0080] Fig.10 is a block diagram of an application running device according to an exemplary embodiment of the present disclosure;

[0081] Fig.11 is a structural diagram of an application compilation device according to an exemplary embodiment of the present disclosure;

[0082] Fig.12 The present invention is a schematic diagram of a structure of an application program running device according to an exemplary embodiment of the present invention. DETAILED DESCRIPTION

[0083] Exemplary embodiments will be described in detail herein, examples of which are shown in the accompanying drawings. When the following description refers to the drawings, the same numbers in different drawings represent the same or similar elements unless otherwise indicated. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with the present invention. Instead, they are merely examples of devices and methods consistent with some aspects of the present invention as detailed in the appended claims.

[0084] Before introducing the application compilation and running method provided by the present disclosure, the software compilation method in the related art is introduced. In the embodiment of the present disclosure, bytecode refers to the code preprocessed by the compiler, the bytecode file can refer to the existence form of JAVA executable file, and the machine code refers to the code that can be executed by the machine device.

[0085] Currently, there are two ways to convert bytecode into machine code:

[0086] The first method is the Just In Time (JIT) method.

[0087] This method is suitable for applications with sufficient computing resources and are not sensitive to startup time. Using JIT requires the operating environment to complete the entire process of compilation and linking. It is not suitable for IoT devices with limited computing resources. The advantage of using JIT is that bytecode can be distributed directly, and the process of compiling bytecode into machine code is completed at runtime.

[0088] The second method is the Ahead of Time (AOT) method.

[0089] This method is to compile bytecode into machine code for the IoT device platform in advance, thereby solving the problem of long JIT compilation time, achieving lower startup delays, and eliminating the compilation overhead required at runtime. However, this method requires pre-compilation for certain device platforms, and the pre-compiled files cannot be used in other different operating environments.

[0090] In addition, let me introduce the virtual machines in the IoT field:

[0091] WebAssembly Micro Runtime (WAMR): Supports JIT and / or AOT of Wasm bytecode, but even when running AOT code, the code needs to be relocated, which has a large runtime overhead.

[0092] Hongmeng ARK Runtime: supports compiling JavaScript into bytecode, and plans to implement AOT for bytecode.

[0093] MicroPython: It supports the generation of machine code on some platforms to improve program performance, but it has limitations in the use of Python-like languages ​​and cannot achieve full AOT.

[0094] Among them, the AOT solution based on WAMR can refer to Figure 1As shown in FIG. 1 , the process of generating an AOT file includes: first obtaining the Wasm bytecode, then parsing the Wasm bytecode and loading it into the memory, converting each instruction into the intermediate representation (IR) of the underlying virtual machine (LLVM), extracting the structural information, and thus generating the AOT file.

[0095] In the above implementation, each function call and memory access instruction is checked to confirm that the memory address accessed by the application is legal, and that the called function interface is within the range provided by the system to ensure that the application cannot access system resources at will, thereby ensuring security.

[0096] The present application takes into account the limited memory resources of IoT devices. If the corresponding code segment is copied to the memory, such as the random access memory (RAM), each time the application is run, a large amount of memory consumption will be caused. In order to solve this technical problem, the present disclosure provides the following application compilation and running method.

[0097] The following first introduces the application compilation method provided by the present disclosure from the terminal side.

[0098] Reference Figure 2 As shown, Figure 2 FIG. 1 is a flowchart of an application compilation method shown in an exemplary embodiment of the present disclosure. The embodiment is described from the terminal side, wherein the terminal includes but is not limited to a mobile phone, a laptop computer, a desktop computer, an iPad, etc. Figure 2 As shown, the application compilation method includes the following steps:

[0099] In step 201, information to be compiled is extracted from a bytecode file corresponding to the application.

[0100] In the disclosed embodiment, the terminal device may load the bytecode file corresponding to the application program through a central processing unit (CPU) and extract the information to be compiled therefrom.

[0101] The information to be compiled includes but is not limited to data segment information to be compiled and / or code segment information to be compiled. The data segment information is used to indicate the parameters included in the bytecode file, including but not limited to the number of data variables, data initial values, etc. The code segment information is used to indicate the code instructions to be compiled.

[0102] In step 202, a data structure corresponding to the information to be compiled is constructed.

[0103] In the embodiment of the present disclosure, the terminal may construct corresponding data structures for different information to be compiled.

[0104] In step 203, the bytecode file is compiled based on the data structure corresponding to the information to be compiled to generate an intermediate file.

[0105] In the embodiments of the present disclosure, the intermediate file may refer to a file generated based on LLVM IR.

[0106] In a possible implementation, the terminal may generate the intermediate file based on LLVM IR through a machine code generation module.

[0107] In step 204, file description information for describing the information content included in the intermediate file is determined.

[0108] In step 205, a target file after compiling the application is generated based on the intermediate file and the file description information.

[0109] In the embodiment of the present disclosure, the target file finally generated includes the code segment of the intermediate file and also includes the file description information.

[0110] In the above embodiment, the target file generated after terminal compilation can be directly loaded from the flash memory of the IoT device to start the application, saving a large amount of memory of the IoT device. It is suitable for a variety of IoT device platforms and has the value of being used in small or even micro embedded IoT device systems, with high availability and security.

[0111] In some optional embodiments, reference Figure 3 As shown, Figure 3 is based on Figure 2 The embodiment shown is a flowchart of another method for compiling an application program, the method further comprising the following steps:

[0112] In step 200, at least one of the integrity and legality of the bytecode file is verified to determine a verification result.

[0113] In a possible implementation, the verification result may be determined by judging whether the bytecode file complies with a preset file rule.

[0114] When the verification result indicates that the bytecode file is a complete file and / or a legal file, the above step 201 is performed.

[0115] In the above embodiment, in order to avoid errors in the subsequently generated target file and ensure the legality of the target file, the integrity and / or legality of the bytecode file can be verified before compiling it. When the verification result indicates that the bytecode file is a complete file and / or a legal file, the bytecode file can be compiled according to the file, which is simple to implement and has high availability.

[0116] In some optional embodiments, the information to be compiled may include data segment information to be compiled and / or code segment information to be compiled.

[0117] In a possible implementation, when the information to be compiled includes data segment information to be compiled, the above step 202 may be specifically as follows:

[0118] Determine a first memory space corresponding to the data segment information.

[0119] In an embodiment of the present disclosure, the size of the first memory space is equal to the amount of data indicated by the data segment information to be compiled.

[0120] For example, a first memory space of the same size is applied for according to the data amount indicated by the data segment information, and the first memory space may be env->mblock.

[0121] In another possible implementation, when the information to be compiled includes information of code segments to be compiled, step 202 may be specifically as follows:

[0122] At least one array is determined based on the number of interfaces of the functions included in the code segment.

[0123] In the embodiment of the present disclosure, the number of arrays is equal to the number of interfaces. The array can be used to record information such as the index of the function.

[0124] For example, the terminal can apply for an equal number of arrays env->funcidx according to the number of function interfaces. In the above embodiment, a corresponding data structure can be constructed according to the information to be compiled extracted from the bytecode file corresponding to the application, so as to compile the bytecode file later, which is simple to implement and has high usability.

[0125] In some optional embodiments, reference Figure 4 As shown, Figure 4 is based on Figure 2 The embodiment shown is a flowchart of another method for compiling an application program, wherein the above step 203 may include:

[0126] In step 203-1, based on the data structure corresponding to the information to be compiled, the instructions included in the bytecode file are converted into an intermediate representation of the underlying virtual machine.

[0127] In the disclosed embodiment, each instruction of the bytecode file may be converted into an intermediate representation of the underlying virtual machine, that is, converted into VVLM IR, one by one according to the data structure constructed in step 202 .

[0128] In step 203 - 2 , the intermediate file is generated based on the intermediate representation.

[0129] In the disclosed embodiment, the machine code generation module on the terminal may generate an intermediate file based on the complete intermediate representation obtained after the conversion.

[0130] In the above embodiment, the instructions included in the bytecode file can be converted into an intermediate representation of the underlying virtual machine to generate an intermediate file so that the target file can be subsequently generated based on the intermediate file, thereby achieving the purpose of converting the bytecode file into machine code based on the AOT method, ensuring the security of the subsequent running of the target file and high availability.

[0131] In some optional embodiments, for the above step 203-1, the instructions included in the bytecode file are different, and thus can be converted into different intermediate representations accordingly:

[0132] In the first case, when the instruction includes a data access instruction, the address accessed by the data access instruction is converted into the intermediate representation for accessing the first memory space.

[0133] In the embodiment of the present disclosure, the first memory space is the memory space determined when constructing the data structure in step 202 .

[0134] For example, the address accessed by the data access instruction is converted into an IR for accessing the mblock.

[0135] In a second case, when the instruction includes a function definition instruction, the function definition instruction is converted into the intermediate representation that determines the serial number of the defined function and stores the serial number in an array corresponding to the defined function.

[0136] In the disclosed embodiment, the array is determined when the data structure is constructed. The terminal can number the defined functions in sequence, determine the sequence number of the function, and save the sequence number in the corresponding array funcidx.

[0137] In a third case, when the instruction includes a function call instruction, the function call instruction is converted into the intermediate representation for calling from the array corresponding to the called function.

[0138] In an embodiment of the present disclosure, the index of a called function can be searched in an index list including multiple function indexes. In the present disclosure, in order to facilitate function calls, when the functions are defined before, the serial numbers corresponding to the functions have been determined according to the order in which the functions appear in the bytecode file. Therefore, the function call instruction can be converted into an IR that calls the function from the array corresponding to the called function (calls the function directly according to the serial number).

[0139] In a fourth case, when the instruction includes a switch instruction, the switch instruction is converted into the intermediate representation in a conditional jump manner.

[0140] In the disclosed embodiment, the conditional jump mode refers to the if-else-if mode. Some IoT device platforms do not support the execution of the switch instruction, so the switch instruction can be converted into an IR of the conditional jump mode, so as to be applicable to different IoT device platforms.

[0141] In a fifth case, when the instruction includes an atomic instruction, the atomic instruction is converted into a data access instruction.

[0142] In the disclosed embodiment, an atomic instruction refers to an instruction that allows only one processor to perform read and write operations in the same time period. Here, multi-processor devices are mainly considered. Also, considering that some IoT device platforms do not support the use of atomic instructions, the terminal can convert atomic instructions into ordinary data access instructions.

[0143] It should also be noted that, in the embodiment of the present disclosure, when the instruction includes a function call instruction, that is, during the execution of the function call, a parameter may be added before the parameters included in the bytecode file, and the parameter may be a data structure env parameter. In the embodiment of the present disclosure, the data structure parameter is added for subsequent function calls based on the constructed data structure.

[0144] For example, if the bytecode file originally includes two parameters, then the data structure env parameter can be added before these two parameters.

[0145] In the above embodiment, the code included in the bytecode file can be converted into an intermediate representation of the machine code based on the previously constructed data structure, thereby generating an intermediate file with high usability.

[0146] In some optional embodiments, the file description information includes but is not limited to at least one of the following: correspondence information between the serial number of the function included in the intermediate file and the naming information of the function; description information using the first memory space; wherein the first memory space is the memory space determined when constructing the data structure; mapping relationship information between the function name included in the intermediate file and the function index.

[0147] Among them, the serial number of the function can be determined according to the order in which the function appears in the intermediate file. The naming information of the function includes but is not limited to the relevant information when the function is named, such as naming time information, naming rule information, and the corresponding interface information called when naming. The first memory space refers to the memory space corresponding to the data segment information to be compiled when the data structure is constructed. In addition, the terminal itself can determine the index value corresponding to the function according to the serial number of the function, thereby obtaining the function index. The function index may be equal to or different from the serial number, and the present disclosure does not limit this.

[0148] In the disclosed embodiment, the terminal can scan the function serial number and the function naming information collected in the bytecode file to generate a corresponding relationship list between the two. The terminal can also obtain the description information of the first memory space used when scanning the bytecode file, and determine the mapping relationship information between the function name and the function index.

[0149] Further, refer to Figure 5 As shown, Figure 5 is based on Figure 2 The embodiment shown is a flowchart of another method for compiling an application program, wherein the above step 205 may include:

[0150] In step 205 - 1 , the code segment included in the intermediate file is copied to the file to be generated.

[0151] In the disclosed embodiment, a new file to be generated may be created, and the terminal may copy the code segments included in the intermediate file, that is, the machine codes obtained by compiling the instructions included in the bytecode file, into the file to be generated.

[0152] In step 205 - 2 , the file description information is generated at a specified location of the file to be generated to obtain the target file.

[0153] In the disclosed embodiment, the designated location includes but is not limited to the head, any middle position, tail, etc. of the file to be generated. The designated location can be determined by negotiation between the terminal and the IoT device. The target file is a file in the eXecute In Place (XIP) format.

[0154] Optionally, after generating the target file, the terminal may send the target file to an IoT device, so that the IoT device may directly load the target file from the flash memory to run the application.

[0155] The present disclosure does not limit the execution order of copying the code segments included in the intermediate file to the file to be generated and generating the file description information at the specified position of the file to be generated.

[0156] In the above embodiment, the bytecode file of the application can be compiled on the terminal side, and finally a target file in the in-situ execution format is generated, so as to achieve the purpose of in-situ execution of the application on the IoT device side, with high availability and security. The following is an introduction to the application running method provided by the present disclosure from the IoT device side.

[0157] Reference Figure 6 As shown, Figure 6 FIG. 1 is a flowchart of an application program running method shown in an exemplary embodiment of the present disclosure. The embodiment is described from the perspective of an IoT device, wherein the IoT device includes but is not limited to wearable devices, smart home devices, unmanned driving devices, etc. Figure 6 As shown, the application running method includes the following steps:

[0158] In step 301, when the application needs to be run, a target file is loaded from the flash memory.

[0159] In the disclosed embodiment, the target file is a file obtained based on the above-mentioned application compilation method. When the IoT device detects a trigger operation on the application, it can determine that the application needs to be run. At this time, the IoT device can directly load the target file from the flash memory.

[0160] In a possible implementation, the IoT device may load the target file from the flash memory based on the file description information included in the target file.

[0161] In step 302, after the target file is loaded, the application is started.

[0162] In the embodiment of the present disclosure, the format of the target file may be in XIP format.

[0163] In the above embodiment, when the IoT device needs to run an application, it does not need to copy the bytecode file corresponding to the application to the memory, but can directly load the target file compiled by the terminal side from the flash memory to start the application. The purpose of executing the application in situ is achieved, a large amount of memory of the IoT device is saved, and it is applicable to a variety of IoT device platforms, and has the value of being used on small or even micro embedded IoT device systems, with high availability and security.

[0164] In some optional embodiments, reference Figure 7 As shown, Figure 7 is based on Figure 6 The embodiment shown is a flowchart of another method for running an application program, wherein the above step 301 may include the following steps:

[0165] In step 301 - 1 , based on the correspondence information between the sequence number of the function included in the file description information and the naming information of the function, the interface corresponding to each of the functions is determined.

[0166] In the embodiment of the present disclosure, the target file includes file description information, and the file description information includes the correspondence between the serial number of the function and the naming information of the function. The IoT device can determine the interface corresponding to each of the functions in its own system.

[0167] In step 301 - 2 , the interface is recorded in an array of data structures corresponding to each of the functions.

[0168] In an embodiment of the present disclosure, the IoT device may record the found interface in an array of a data structure corresponding to each function, for example, in env-funcidx.

[0169] In step 301 - 3 , a second memory space is allocated to the target file based on the description information of using the first memory space included in the file description information.

[0170] In an embodiment of the present disclosure, the size of the allocated second memory space is equal to the size of the first memory space.

[0171] In step 301 - 4 , the array of the data structure corresponding to each of the functions is sorted based on the mapping relationship information between the function name and the function index included in the file description information.

[0172] In the embodiment of the present disclosure, the function index is determined based on the serial number of the function. Therefore, based on the file description information and the mapping relationship information, the array corresponding to each function can be sorted in the order in which each function appears in the target file, so as to find the startup entry of the application and start the application.

[0173] Accordingly, the above step 302 may be specifically as follows:

[0174] After the target file is loaded, the application is started through the interface recorded in the array corresponding to the sorted specified order.

[0175] In the disclosed embodiment, after the target file is loaded, the application can be started through env-funcidx, and the specified order can be the first one. Then the IoT device can determine that the interface recorded in the first array after sorting is the startup entry of the application, thereby starting the application.

[0176] In the above embodiments, the IoT device can use the above method to achieve the purpose of executing the application program in situ, so that the IoT device platform that originally does not support the execution of bytecode AOT can support the application program to start in situ, achieving a breakthrough from impossible to feasible. It is especially suitable for embedded systems without memory management units and has high availability. In some optional embodiments, refer to Figure 8 As shown, Figure 8 FIG. 1 is a flowchart of a method for compiling and running an application program according to an exemplary embodiment of the present disclosure. The method may include the following steps:

[0177] In step 401, the terminal verifies at least one of the integrity and legality of the bytecode file corresponding to the application program, and determines a verification result.

[0178] In the disclosed embodiment, the terminal may determine the verification result by judging whether the bytecode file complies with a preset file rule.

[0179] In step 402, when the verification result indicates that the bytecode file is a complete file and / or a legal file, the terminal extracts the information to be compiled from the bytecode file corresponding to the application.

[0180] The information to be compiled includes but is not limited to data segment information to be compiled and / or code segment information to be compiled. The data segment information is used to indicate the parameters included in the bytecode file, including but not limited to the number of data variables, data initial values, etc. The code segment information is used to indicate the code instructions to be compiled.

[0181] In step 403, the terminal constructs a data structure corresponding to the information to be compiled.

[0182] The specific construction method is similar to the method of constructing the data structure in step 202-, and will not be repeated here.

[0183] In step 404, the terminal compiles the bytecode file based on the data structure corresponding to the information to be compiled to generate an intermediate file.

[0184] The specific generation method is similar to the method of generating the intermediate file in the above steps 203 - 1 to 203 - 2, and will not be repeated here.

[0185] In step 405, the terminal determines file description information for describing the information content included in the intermediate file.

[0186] The file description information includes but is not limited to at least one of the following: the correspondence information between the serial number of the function included in the intermediate file and the naming information of the function; the description information of using the first memory space; wherein the first memory space is the memory space determined when constructing the data structure; the mapping relationship information between the function name included in the intermediate file and the function index.

[0187] In step 406, the terminal copies the code segment included in the intermediate file to the file to be generated.

[0188] In step 407, the terminal generates the file description information at a designated location of the file to be generated to obtain the target file.

[0189] In step 408, the terminal sends the target file to the IoT device.

[0190] In step 409, the IoT device loads the target file from the flash memory when it needs to run the application.

[0191] The method of loading the target file is similar to the above steps 301 - 1 to 301 - 4 and will not be repeated here.

[0192] In step 410, after the IoT device loads the target file, it starts the application through the interface recorded in the array corresponding to the sorted specified order.

[0193] The specified order may be the first one.

[0194] The above embodiments are further described by way of example as follows.

[0195] Assuming an application of 400 kilobytes (kb) in size, according to relevant technologies, when an IoT device needs to run the application, it needs to copy the corresponding bytecode file into the memory, resulting in 400kb of memory consumption. The memory of many IoT devices may even be less than 400kb. By adopting the technical solution of the present application, the IoT device can directly load the target file into the flash memory and start the application, saving a lot of memory.

[0196] In the above embodiment, the IoT device platform that previously did not support the execution of bytecode AOT supports the AOT solution, achieving a breakthrough from impossible to feasible, and retaining the safe operation capability of the original AOT solution, which has the value of being used in small embedded information.

[0197] Corresponding to the aforementioned application function implementation method embodiment, the present disclosure also provides an application function implementation device embodiment.

[0198] Reference Fig. 9 , Fig. 9 The present invention is a block diagram of an application compilation device according to an exemplary embodiment, wherein the device is applied to a terminal, and the device includes:

[0199] An extraction module 501 is used to extract information to be compiled from a bytecode file corresponding to the application program;

[0200] A construction module 502 is used to construct a data structure corresponding to the information to be compiled;

[0201] A first generating module 503, used to compile the bytecode file based on the data structure corresponding to the information to be compiled to generate an intermediate file;

[0202] A determination module 504, configured to determine file description information for describing information content included in the intermediate file;

[0203] The second generating module 505 is used to generate a target file after compiling the application based on the intermediate file and the file description information.

[0204] Optionally, the device further comprises:

[0205] A verification module, used to verify at least one of the integrity and legality of the bytecode file and determine a verification result;

[0206] The control module is used to control the extraction module to extract the information to be compiled from the bytecode file corresponding to the application program when the verification result indicates that the bytecode file is a complete file and / or a legal file.

[0207] Optionally, the building block includes at least one of the following:

[0208] A first determination submodule is used to determine a first memory space corresponding to the data segment information when the information to be compiled includes the data segment information to be compiled; wherein the size of the first memory space is equal to the amount of data indicated by the data segment information;

[0209] The second determination submodule is used to determine at least one array based on the number of interfaces of the function included in the code segment information when the information to be compiled includes the code segment information to be compiled; wherein the number of the arrays is equal to the number of the interfaces.

[0210] Optionally, the first generating module includes:

[0211] A conversion submodule, configured to convert instructions included in the bytecode file into an intermediate representation of an underlying virtual machine based on a data structure corresponding to the information to be compiled;

[0212] The first generating submodule is used to generate the intermediate file based on the intermediate representation.

[0213] Optionally, the conversion submodule includes:

[0214] A first conversion unit is used for converting the address accessed by the data access instruction into the intermediate representation for accessing the first memory space when the instruction includes a data access instruction; wherein the first memory space is the memory space determined when constructing the data structure;

[0215] a second conversion unit, configured to, when the instruction includes a function definition instruction, convert the function definition instruction into the intermediate representation for determining the serial number of the defined function and storing the serial number in an array corresponding to the defined function; wherein the array is determined when constructing the data structure;

[0216] A third conversion unit, configured to, when the instruction includes a function call instruction, convert the function call instruction into the intermediate representation for calling from the array corresponding to the called function;

[0217] a fourth conversion unit, configured to convert the switch instruction into the intermediate representation in a conditional jump manner when the instruction includes a switch instruction;

[0218] A fifth conversion unit is used to convert the atomic instruction into the data access instruction when the instruction includes an atomic instruction; wherein the atomic instruction refers to an instruction that only allows one processor to perform read and write operations on the cache within the same time period.

[0219] Optionally, the device further comprises:

[0220] An adding module is used to add data structure parameters before the parameters included in the bytecode file when the instruction includes a function call instruction.

[0221] Optionally, the file description information includes at least one of the following:

[0222] Correspondence information between the serial numbers of the functions included in the intermediate file and the naming information of the functions;

[0223] Using description information of a first memory space; wherein the first memory space is a memory space determined when constructing the data structure;

[0224] The intermediate file includes mapping relationship information between function names and function indexes; wherein the function index is determined based on the serial number of the function.

[0225] Optionally, the second generating module includes:

[0226] A copy submodule, used to copy the code segment included in the intermediate file to the file to be generated;

[0227] The second generation submodule is used to generate the file description information at a specified location of the file to be generated to obtain the target file.

[0228] Optionally, the device further comprises:

[0229] The sending module is used to send the target file to the IoT device.

[0230] Reference Fig.10 , Fig.10 The present invention is a block diagram of an application program running device according to an exemplary embodiment, wherein the device is applied to an IoT device, and the device includes:

[0231] A loading module 601, used to load a target file from a flash memory when the application needs to be run; wherein the target file is a file obtained based on any of the above-mentioned application compilation methods;

[0232] The startup module 602 is used to start the application after loading the target file.

[0233] Optionally, the loading module includes:

[0234] The loading submodule is used to load the target file from the flash memory based on the file description information included in the target file.

[0235] Optionally, the loading submodule includes:

[0236] A determining unit, configured to determine, in the system of the IoT device, an interface corresponding to each of the functions based on the correspondence relationship information between the serial number of the function included in the file description information and the naming information of the function;

[0237] A recording unit, used for recording the interface in an array of data structures corresponding to each of the functions;

[0238] an allocating unit, configured to allocate a second memory space to the target file based on the description information of using the first memory space included in the file description information; wherein the size of the second memory space is equal to the size of the first memory space;

[0239] The sorting unit is used to sort the array of the data structure corresponding to each function based on the mapping relationship information between the function name and the function index included in the file description information.

[0240] Optionally, the startup module includes:

[0241] The startup submodule is used to start the application through the interface recorded in the array corresponding to the sorted specified order.

[0242] For the device embodiments, since they basically correspond to the method embodiments, the relevant parts can refer to the partial description of the method embodiments. The device embodiments described above are only schematic, wherein the units described above as separate components may or may not be physically separated, and the components displayed as units may or may not be physical units, that is, they may be located in one place, or they may be distributed on multiple network units. Some or all of the modules may be selected according to actual needs to achieve the purpose of the disclosed solution. A person of ordinary skill in the art may understand and implement it without creative work.

[0243] Correspondingly, the present disclosure also provides a computer-readable storage medium for storing a computer program, wherein the computer program, when executed by a processor, is used to implement the steps of any one of the above-mentioned application compilation methods on the terminal side.

[0244] Accordingly, the present disclosure also provides a computer-readable storage medium for storing a computer program, which, when executed by a processor, is used to implement the steps of the application running method described in any one of the above-mentioned Internet of Things (IoT) device sides.

[0245] Accordingly, the present disclosure also provides an application compilation device, comprising:

[0246] processor;

[0247] a memory for storing processor-executable instructions;

[0248] The processor is configured to execute the executable instructions to implement the steps of any one of the application compilation methods described above on the terminal side.

[0249] Fig.111 is a block diagram of an application compilation device according to an exemplary embodiment. For example, the device 1100 may be a mobile phone, a computer, a digital broadcast terminal, a messaging device, a game console, a tablet device, a medical device, a fitness device, a personal digital assistant, or the like.

[0250] Reference Fig.11 , the device 1100 may include one or more of the following components: a processing component 1102 , a memory 1104 , a power component 1106 , a multimedia component 1108 , an audio component 1110 , an input / output (I / O) interface 1112 , a sensor component 1116 , and a communication component 1118 .

[0251] The processing component 1102 generally controls the overall operation of the device 1100, such as operations associated with display, phone calls, data communications, camera operations, and recording operations. The processing component 1102 may include one or more processors 1120 to execute instructions to perform all or part of the steps of the above-described method. In addition, the processing component 1102 may include one or more modules to facilitate interaction between the processing component 1102 and other components. For example, the processing component 1102 may include a multimedia module to facilitate interaction between the multimedia component 1108 and the processing component 1102.

[0252] One of the processors 1120 in the processing component 1102 may be configured to execute the above-mentioned application compilation method.

[0253] The memory 1104 is configured to store various types of data to support the operation of the device 1100. Examples of such data include instructions for any application or method operating on the device 1100, contact data, phone book data, messages, pictures, videos, etc. The memory 1104 can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as static random access memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, magnetic disk or optical disk.

[0254] The power supply component 1106 provides power to the various components of the device 1100. The power supply component 1106 may include a power management system, one or more power supplies, and other components associated with generating, managing, and distributing power to the device 1100.

[0255] The multimedia component 1108 includes a screen that provides an output interface between the device 1100 and the user. In some embodiments, the screen may include a liquid crystal display (LCD) and a touch panel (TP). If the screen includes a touch panel, the screen may be implemented as a touch screen to receive input signals from the user. The touch panel includes one or more touch sensors to sense touch, slide, and gestures on the touch panel. The touch sensor may not only sense the boundaries of the touch or slide action, but also detect the duration and pressure associated with the touch or slide operation. In some embodiments, the multimedia component 1108 includes a front camera and / or a rear camera. When the device 1100 is in an operating mode, such as a shooting mode or a video mode, the front camera and / or the rear camera may receive external multimedia data. Each front camera and rear camera may be a fixed optical lens system or have a focal length and optical zoom capability.

[0256] The audio component 1110 is configured to output and / or input audio signals. For example, the audio component 1110 includes a microphone (MIC), and when the device 1100 is in an operation mode, such as a call mode, a recording mode, and a speech recognition mode, the microphone is configured to receive an external audio signal. The received audio signal can be further stored in the memory 1104 or sent via the communication component 1118. In some embodiments, the audio component 1110 also includes a speaker for outputting audio signals.

[0257] I / O interface 1112 provides an interface between processing component 1102 and peripheral interface modules, which may be keyboards, click wheels, buttons, etc. These buttons may include but are not limited to: a home button, a volume button, a start button, and a lock button.

[0258] The sensor assembly 1116 includes one or more sensors for providing various aspects of the status assessment of the device 1100. For example, the sensor assembly 1116 can detect the open / closed state of the device 1100, the relative positioning of components, such as the display and keypad of the device 1100, the sensor assembly 1116 can also detect the position change of the device 1100 or a component of the device 1100, the presence or absence of user contact with the device 1100, the orientation or acceleration / deceleration of the device 1100, and the temperature change of the device 1100. The sensor assembly 1116 may include a proximity sensor configured to detect the presence of a nearby object without any physical contact. The sensor assembly 1116 may also include an optical sensor, such as a CMOS or CCD image sensor, for use in imaging applications. In some embodiments, the sensor assembly 1116 may also include an accelerometer, a gyroscope sensor, a magnetic sensor, a pressure sensor, or a temperature sensor.

[0259] The communication component 1118 is configured to facilitate wired or wireless communication between the device 1100 and other devices. The device 1100 can access a wireless network based on a communication standard, such as WiFi, 3G, 4G, 5G, 6G or a combination thereof. In an exemplary embodiment, the communication component 1118 receives a broadcast signal or broadcast-related information from an external broadcast management system via a broadcast channel. In an exemplary embodiment, the communication component 1118 also includes a near field communication (NFC) module to facilitate short-range communication. For example, the NFC module can be implemented based on radio frequency identification (RFID) technology, infrared data association (IrDA) technology, ultra-wideband (UWB) technology, Bluetooth (BT) technology and other technologies.

[0260] In an exemplary embodiment, the device 1100 can be implemented by one or more application-specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs), field programmable gate arrays (FPGAs), controllers, microcontrollers, microprocessors or other electronic components to perform the above methods.

[0261] In an exemplary embodiment, a non-transitory computer-readable storage medium including instructions is also provided, such as a memory 1104 including instructions, and the instructions can be executed by the processor 1120 of the device 1100 to perform the above method. For example, the non-transitory computer-readable storage medium can be a ROM, a random access memory (RAM), a CD-ROM, a magnetic tape, a floppy disk, an optical data storage device, etc.

[0262] Accordingly, the present disclosure also provides an application program running device, comprising:

[0263] processor;

[0264] a memory for storing processor-executable instructions;

[0265] Among them, the processor is configured to execute the executable instructions to implement the steps of the application running method described in any one of the above-mentioned Internet of Things IoT device sides.

[0266] like Fig.12 As shown, Fig.12 FIG. 1 is a schematic diagram of a structure of an application program running device 1200 according to an exemplary embodiment. The device 1200 may be provided as an IoT device. Fig.12 The device 1200 includes a processing component 1222, a wireless transmission / reception component 1224, an antenna component 1226, and a signal processing part specific to the wireless interface. The processing component 1222 may further include one or more processors.

[0267] One of the processors in the processing component 1222 can be configured to execute any of the application running methods described above on the IoT device side.

[0268] It should be noted that, in this article, relational terms such as first and second, etc. are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any such actual relationship or order between these entities or operations. The terms "include", "comprises" or any other variants thereof are intended to cover non-exclusive inclusion, so that a process, method, article or device including a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, article or device. In the absence of further restrictions, the elements defined by the statement "comprises a ..." do not exclude the presence of other identical elements in the process, method, article or device including the elements.

[0269] Those skilled in the art will readily appreciate other embodiments of the present disclosure after considering the specification and practicing the disclosure disclosed herein. This application is intended to cover any variations, uses, or adaptations of the present disclosure that follow the general principles of the present disclosure and include common knowledge or customary techniques in the art that are not disclosed in the present disclosure. The description and examples are intended to be exemplary only, and the true scope and spirit of the present disclosure are indicated by the following claims.

[0270] It should be understood that the present disclosure is not limited to the exact structures that have been described above and shown in the drawings, and that various modifications and changes may be made without departing from the scope thereof. The scope of the present disclosure is limited only by the appended claims.

Claims

1. A method for compiling an application, characterized in that: The method is applied to a terminal, and the method includes: Extracting information to be compiled from a bytecode file corresponding to the application; Constructing a data structure corresponding to the information to be compiled; Compiling the bytecode file based on a data structure corresponding to the information to be compiled to generate an intermediate file; Determining file description information for describing information content included in the intermediate file; Based on the intermediate file and the file description information, generating a target file after compiling the application program; The file description information includes at least one of the following: Correspondence information between the serial numbers of the functions included in the intermediate file and the naming information of the functions; Using description information of a first memory space; wherein the first memory space is a memory space determined when constructing the data structure; The intermediate file includes mapping relationship information between function names and function indexes; wherein the function index is determined based on the serial number of the function.

2. The method according to claim 1, characterized in that The method further comprises: Verifying at least one of the integrity and legality of the bytecode file and determining a verification result; In the case where the verification result indicates that the bytecode file is a complete file and / or a legal file, the step of extracting the information to be compiled from the bytecode file corresponding to the application is performed.

3. The method according to claim 1, characterized in that: The step of constructing a data structure corresponding to the information to be compiled includes at least one of the following: In the case where the information to be compiled includes data segment information to be compiled, determining a first memory space corresponding to the data segment information; wherein the size of the first memory space is equal to the amount of data indicated by the data segment information; In the case that the information to be compiled includes code segment information to be compiled, at least one array is determined based on the number of interfaces of the function included in the code segment information; wherein the number of the arrays is equal to the number of the interfaces.

4. The method according to claim 1, characterized in that The step of compiling the bytecode file based on the data structure corresponding to the information to be compiled to generate an intermediate file includes: Based on the data structure corresponding to the information to be compiled, converting the instructions included in the bytecode file into an intermediate representation of the underlying virtual machine; Based on the intermediate representation, the intermediate file is generated.

5. The method according to claim 4, characterized in that The converting the code included in the bytecode file into an intermediate representation of the underlying virtual machine based on the data structure corresponding to the information to be compiled includes: In the case where the instruction includes a data access instruction, converting the address accessed by the data access instruction into the intermediate representation for accessing a first memory space; wherein the first memory space is a memory space determined when constructing the data structure; In the case where the instruction includes a function definition instruction, converting the function definition instruction into an intermediate representation that determines the serial number of the defined function and stores the serial number in an array corresponding to the defined function; wherein the array is determined when constructing the data structure; In the case where the instruction includes a function call instruction, converting the function call instruction into the intermediate representation for calling from the array corresponding to the called function; In the case where the instruction includes a switch instruction, converting the switch instruction into the intermediate representation in a conditional jump manner; In the case where the instruction includes an atomic instruction, the atomic instruction is converted into the data access instruction; wherein the atomic instruction refers to an instruction that allows only one processor to perform read and write operations within the same time period.

6. The method according to claim 4, characterized in that The method further comprises: In case the instruction comprises a function call instruction, a data structure parameter is added before the parameter included in the bytecode file.

7. The method according to claim 1, characterized in that The generating, based on the intermediate file and the file description information, a target file after compiling the application program, comprises: Copying the code segment included in the intermediate file to the file to be generated; The file description information is generated at a specified location of the file to be generated to obtain the target file.

8. The method according to claim 1, characterized in that: After generating the target file, the method further includes: The target file is sent to an IoT device.

9. A method for running an application, characterized in that: The method is applied to an IoT device, and the method comprises: When the application needs to be run, a target file is loaded from the flash memory; wherein the target file is a file obtained based on the application compilation method according to any one of claims 1 to 8; After the target file is loaded, the application is started.

10. The method according to claim 9, characterized in that The loading of the target file from the flash memory comprises: The target file is loaded from the flash memory based on the file description information included in the target file.

11. The method according to claim 10, characterized in that The step of loading the target file from the flash memory based on the file description information included in the target file includes: Determine an interface corresponding to each of the functions based on the correspondence relationship information between the serial number of the function included in the file description information and the naming information of the function; Recording the interface in an array of data structures corresponding to each of the functions; Allocate a second memory space for the target file based on the description information of using the first memory space included in the file description information; wherein the size of the second memory space is equal to the size of the first memory space; Based on the mapping relationship information between the function name and the function index included in the file description information, the array of the data structure corresponding to each of the functions is sorted; wherein the function index is determined based on the serial number of the function.

12. The method according to claim 11, characterized in that The starting of the application comprises: The application is started through the interface recorded in the array corresponding to the sorted specified order.

13. An application compilation device, characterized in that: The device is applied to a terminal, and the device includes: An extraction module, used to extract information to be compiled from a bytecode file corresponding to the application; A construction module, used to construct a data structure corresponding to the information to be compiled; A first generating module, used to compile the bytecode file based on a data structure corresponding to the information to be compiled to generate an intermediate file; A determination module, used to determine file description information used to describe the information content included in the intermediate file; A second generating module, used to generate a target file after compiling the application program based on the intermediate file and the file description information; The file description information includes at least one of the following: Correspondence information between the serial numbers of the functions included in the intermediate file and the naming information of the functions; Using description information of a first memory space; wherein the first memory space is a memory space determined when constructing the data structure; The intermediate file includes mapping relationship information between function names and function indexes; wherein the function index is determined based on the serial number of the function.

14. An application program running device, characterized in that: The device is applied to an IoT device, and the device includes: A loading module, used to load a target file from a flash memory when the application needs to be run; wherein the target file is a file obtained based on the application compilation method according to any one of claims 1 to 8; A startup module is used to start the application after loading the target file.

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

16. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the steps of the application program running method described in any one of claims 9 to 12 are implemented.

17. An application compilation device, characterized in that: include: processor; a memory for storing processor-executable instructions; The processor is configured to execute the executable instructions to implement the steps of the application compilation method according to any one of claims 1 to 8.

18. An application compilation device, characterized in that: include: processor; a memory for storing processor-executable instructions; Wherein, the processor is configured to execute the executable instructions to implement the steps of the application running method described in any one of claims 9-12.

Images