CN114443051A

CN114443051A - Application program compiling and running method and device and storage medium

Info

Publication number: CN114443051A
Application number: CN202210072064.7A
Authority: CN
Inventors: 黄齐
Original assignee: Beijing Xiaomi Mobile Software Co Ltd
Current assignee: Beijing Xiaomi Mobile Software Co Ltd
Priority date: 2022-01-21
Filing date: 2022-01-21
Publication date: 2022-05-06
Also published as: WO2023137909A1

Abstract

The disclosure provides an application program compiling and running method, an application program compiling and running device and a storage medium. The compiling method comprises the following steps: extracting information to be compiled from the byte code file corresponding to the application program; constructing a data structure corresponding to the information to be compiled; compiling the byte code 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; and generating a target file obtained by compiling the application program based on the intermediate file and the file description information. The method and the device can realize in-situ execution of the application program, save a large amount of memory of the Internet of things equipment, are suitable for various Internet of things equipment platforms, have use value on small or even micro embedded Internet of things equipment systems, and have high usability and safety.

Description

Application program compiling and running method and device and storage medium

Technical Field

The present disclosure relates to the field of software compilation, and in particular, to a method and an apparatus for compiling and running an application program, and a storage medium.

Background

Currently, when an Internet of Things (IoT) device runs an application program, a code file corresponding to the application program needs to be copied from a flash memory to a memory, and the application program is started after the file is read through the memory, thereby causing a large amount of memory consumption.

Disclosure of Invention

In view of the above, the present application discloses an application program compiling and running method, an application program compiling and running device, and a storage medium.

According to a first aspect of the embodiments of the present disclosure, there is provided an application compiling method, which is applied to a terminal, the method including:

extracting information to be compiled from the byte code file corresponding to the application program;

constructing a data structure corresponding to the information to be compiled;

compiling the byte code 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;

and generating a target file obtained by compiling the application program based on the intermediate file and the file description information.

Optionally, the method further comprises:

verifying at least one of the integrity and the legality of the byte code file to determine a verification result;

and under the condition that the verification result indicates that the byte code file is a complete file and/or a legal file, executing the step of extracting the information to be compiled from the byte code file corresponding to the application program.

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

under the condition that the information to be compiled comprises 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 data volume indicated by the data segment information;

determining at least one array based on the number of interfaces of a function included in the code section information in the case that the information to be compiled includes the code section information to be compiled; wherein the number of the arrays is equal to the number of the interfaces.

Optionally, the compiling the bytecode file based on the data structure corresponding to the information to be compiled to generate an intermediate file, including:

converting instructions included in the byte code file into an intermediate representation of a bottom layer virtual machine based on a data structure corresponding to the information to be compiled;

generating the intermediate file based on the intermediate representation.

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

converting an address accessed by the data access instruction into the intermediate representation for accessing a first memory space if the instruction comprises a data access instruction; wherein the first memory space is a memory space determined when the data structure is constructed;

in the case that the instruction comprises a function definition instruction, converting the function definition instruction into a sequence number determining the defined function and storing the intermediate representation of the sequence number in an array corresponding to the defined function; wherein the array is determined when the data structure is constructed;

converting the function call instruction into the intermediate representation called from the array corresponding to the called function if the instruction comprises the function call instruction;

in the event that the instruction comprises a switch instruction, converting the switch instruction to the intermediate representation of a conditional jump approach;

if the instruction comprises an atomic instruction, converting the atomic instruction into the data access instruction; the atomic instruction is an instruction which allows only one processor to perform read-write operation on the cache in the same time period.

Optionally, the method further comprises:

in the case where the instruction comprises a function call instruction, a data structure parameter is added before a parameter comprised by the bytecode file.

Optionally, the file description information includes at least one of:

the corresponding relation information between the serial number of the function included in the intermediate file and the naming information of the function;

using description information of the first memory space; wherein the first memory space is a memory space determined when the data structure is constructed;

mapping relation information between the function name and the function index included in the intermediate file; wherein the function index is determined based on the sequence number of the function.

Optionally, the generating a target file obtained by compiling the application program based on the intermediate file and the file description information includes:

copying the code segments included in the intermediate file to a file to be generated;

and generating the file description information at the specified position of the file to be generated to obtain the target file.

Optionally, after generating the target file, the method further includes:

sending the target file to an IoT device.

According to a second aspect of the embodiments of the present disclosure, there is provided an application running method, which is applied to an internet of things IoT device, the method including:

under the condition that the application program needs to be operated, loading a target file from a flash memory; wherein, the target file is a file obtained based on any one of the application program compiling methods;

and starting the application program after the target file is loaded.

Optionally, the loading the target file from the flash memory includes:

and loading the target file from the flash memory based on the file description information included in the target file.

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

determining an interface corresponding to each function in a system of the IoT equipment based on corresponding relation information between a sequence number of the function and naming information of the function, wherein the sequence number of the function is included in the file description information;

recording the interface in an array of data structures corresponding to each function;

allocating a second memory space for the target file based on the description information which uses the first memory space and is included in the file description information; wherein the size of the second memory space is equal to the size of the first memory space;

and sorting the arrays of the data structures corresponding to the functions based on the mapping relation information between the function names and the function indexes included in the file description information.

Optionally, the starting the application includes:

and starting the application program through the interfaces recorded in the array corresponding to the sorted designated sequence.

According to a third aspect of the embodiments of the present disclosure, there is provided an application compiling apparatus, which is applied to a terminal, the apparatus including:

the extraction module is used for extracting information to be compiled from the byte code file corresponding to the application program;

the building module is used for building a data structure corresponding to the information to be compiled;

the first generation module is used for compiling the byte code file based on a data structure corresponding to the information to be compiled to generate an intermediate file;

a determining module, configured to determine file description information used for describing information content included in the intermediate file;

and the second generation module is used for generating a target file obtained by compiling the application program based on the intermediate file and the file description information.

According to a fourth aspect of the embodiments of the present disclosure, there is provided an application running apparatus, which is applied to an internet of things IoT device, the apparatus including:

the loading module is used for loading the target file from the flash memory under the condition that the application program needs to be operated; wherein, the target file is a file obtained based on any one of the application program compiling methods;

and the starting module is used for starting the application program after the target file is loaded.

According to a fifth aspect of the embodiments of the present disclosure, there is provided a computer-readable storage medium, on which a computer program is stored, which, when executed by a processor, implements the steps of the application compiling method according to any one of the above.

According to a sixth aspect of the embodiments of the present disclosure, there is provided a computer-readable storage medium, on which a computer program is stored, which when executed by a processor implements the steps of the application program execution method according to any one of the above.

According to a seventh aspect of the embodiments of the present disclosure, there is provided an application compiling apparatus including:

a processor;

a memory for storing processor-executable instructions;

wherein the processor is configured to execute the executable instructions to implement the steps of any of the above-described application compilation methods.

According to an eighth aspect of the embodiments of the present disclosure, there is provided an application execution device including:

a processor;

a memory for storing processor-executable instructions;

wherein the processor is configured to execute the executable instructions to implement the steps of any of the above-described application program execution methods.

The technical scheme provided by the embodiment of the disclosure can have the following beneficial effects:

in the present disclosure, the terminal may perform pre-compiling on the bytecode file corresponding to the application program, so as to obtain a compiled target file. When the internet of things equipment needs to run the application program, the target file can be directly loaded from the flash memory, and then the application program is started. The method and the device can realize in-situ execution of the application program, save a large amount of memory of the Internet of things equipment, are suitable for various Internet of things equipment platforms, have use value on small or even micro embedded Internet of things equipment systems, and have high usability and safety.

It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the disclosure.

Drawings

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.

FIG. 1 is a flow chart illustrating an application compiling method in the related art;

FIG. 2 is a flowchart illustrating a method of application compilation according to an exemplary embodiment of the present disclosure;

FIG. 3 is a flowchart illustrating another method of application compilation according to an exemplary embodiment of the present disclosure;

FIG. 4 is a flowchart illustrating another method of application compilation according to an exemplary embodiment of the present disclosure;

FIG. 5 is a flowchart illustrating another method of application compilation according to an exemplary embodiment of the present disclosure;

FIG. 6 is a flowchart illustrating a method of running an application according to an exemplary embodiment of the present disclosure;

FIG. 7 is a flowchart illustrating another method of application execution according to an exemplary embodiment of the present disclosure;

FIG. 8 is a flowchart illustration of an application compilation and execution method according to an exemplary embodiment of the present disclosure;

FIG. 9 is a block diagram illustrating an application compilation device in accordance with an exemplary embodiment of the present disclosure;

fig. 10 is a block diagram illustrating an application execution apparatus according to an exemplary embodiment of the present disclosure;

FIG. 11 is a block diagram illustrating an application compilation device according to an exemplary embodiment of the present disclosure;

fig. 12 is a schematic structural diagram of an application running apparatus according to an exemplary embodiment of the present disclosure.

Detailed Description

Reference will now be made in detail to the exemplary embodiments, examples of which are illustrated in the accompanying drawings. When the following description refers to the accompanying drawings, like 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. Rather, they are merely examples of apparatus and methods consistent with certain aspects of the invention, as detailed in the appended claims.

Before describing the method for compiling and running the application program provided by the present disclosure, a software compiling method in the related art is described. In the embodiments of the present disclosure, the bytecode refers to a code preprocessed by a compiler, the bytecode file may refer to a presence form of a JAVA execution file, and the machine code refers to a code executable by a machine device.

Currently, the methods for converting bytecode into machine code include the following two methods:

the first mode, Just In Time (JIT) mode.

The method is suitable for applications with sufficient computing resources and insensitive to starting time, the JIT is used for requiring the running environment to complete the whole compiling and linking process, the method is not suitable for IoT equipment with tense computing resources, and the JIT has the advantages that the byte codes can be directly distributed, and the process of compiling the byte codes into machine codes is completed at the running time.

The second mode is the advanced of Time (AOT) mode.

The method is to compile byte codes into machine codes for the Internet of things equipment platform in advance, so that the problem of long JIT compiling time is solved, lower starting delay can be obtained, compiling overhead required in running is avoided, but the method needs to perform pre-compiling on certain equipment platforms, and pre-compiled files cannot be used in other different running environments.

In addition, the IoT domain virtual machines are introduced:

WebAssembly Micro Runtime (WebAssembly Micro Runtime, WAMR): the JIT and/or AOT of the Wasm bytecode is supported, but even the AOT code is executed, the code needs to be relocated, and the running cost is large.

When the hongmeng ARK runs: the JavaScript is compiled into byte codes in a supporting mode, and the realization of AOT on the byte codes is planned.

Micro python (micropython): the generation of machine codes is supported in a part of platforms to improve the performance of programs, but the use of a Python-like language is limited, and the complete AOT cannot be achieved.

The WAMR-based AOT scheme may be as shown in fig. 1, and the process of generating the AOT file includes: firstly, acquiring a Wasm byte code, then analyzing the Wasm byte code and loading the Wasm byte code into a memory, converting the Wasm byte code into an Intermediate Representation (IR) of a bottom layer Virtual Machine (LLVM) one by one instruction, and extracting structural information so as to generate the AOT file.

In the implementation scheme, each function call and memory access instruction is checked to confirm that the memory address accessed by the application is legal, and the called function interface is in the range provided by the system to ensure that the application cannot randomly access system resources, so that the security is ensured.

In view of the limited Memory resources of the IoT device, if the corresponding code segment is copied to a Memory, such as a Random Access Memory (RAM), each time the application is run, a large amount of Memory consumption may be caused.

The following first introduces the application compiling method provided by the present disclosure from the terminal side.

Referring to fig. 2, fig. 2 is a flowchart illustrating an application compiling method according to an exemplary embodiment of the disclosure, which is described from a terminal side, wherein the terminal includes, but is not limited to, a mobile phone, a notebook computer, a desktop computer, an ipad, and the like. As shown in fig. 2, the application compiling method includes the following steps:

in step 201, information to be compiled is extracted from the bytecode file corresponding to the application program.

In this embodiment of the present disclosure, the terminal device may load the bytecode file corresponding to the application program through a Central Processing Unit (CPU), and extract information to be compiled from the bytecode file.

The information to be compiled includes, but is not limited to, information of data segments to be compiled and/or information of code segments to be compiled. The data segment information is used for indicating parameters included in the byte code file, the parameters include but are not limited to the number of data variables, initial values of data, and the like, and the code segment information is used for indicating code instructions to be compiled.

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

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

In step 203, the bytecode file is compiled based on the data structure corresponding to the information to be compiled, and an intermediate file is generated.

In the disclosed embodiments, the intermediate file may refer to a file generated based on LLVM IR.

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

In step 204, file description information is determined for describing the information content comprised by the intermediate file.

In step 205, a target file obtained by compiling the application program is generated based on the intermediate file and the file description information.

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

In the above embodiment, the target file generated after the terminal compiling is subsequently and directly loaded from the flash memory by the internet of things device, so that the application program is started, a large amount of memory of the internet of things device is saved, the device is suitable for various internet of things device platforms, and the device has use value on a small or even micro embedded internet of things device system, and has high usability and safety.

In some alternative embodiments, referring to fig. 3, fig. 3 is a flow chart illustrating another method for compiling an application according to the embodiment shown in fig. 2, the method further comprising the steps of:

in step 200, at least one of the integrity and the validity of the bytecode file is verified, and a verification result is determined.

In one possible implementation manner, the verification result may be determined by determining whether the bytecode file conforms to a preset file rule.

In case that the verification result indicates that the bytecode file is a complete file and/or a legal file, the above step 201 is performed.

In the above embodiment, in order to avoid errors in subsequently generated target files and ensure the validity of the target files, the integrity and/or validity of the byte code files may be verified before the byte code files are compiled, and the byte codes are compiled according to the files under the condition that the verification result indicates that the byte code files are complete files and/or valid files, so that the method is simple and convenient to implement and high in availability.

In some optional embodiments, the information to be compiled may include information of data segments to be compiled and/or information of code segments to be compiled.

In a possible implementation manner, in the case that the information to be compiled includes information of a data segment to be compiled, the step 202 may specifically be:

and determining a first memory space corresponding to the data segment information.

In the 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.

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

In another possible implementation manner, in the case that the information to be compiled includes information about code segments to be compiled, the step 202 may specifically be:

at least one array is determined based on the number of interfaces of the function included in the code segment.

In the disclosed embodiment, the number of arrays is equal to the number of interfaces. The array can be used for recording information such as an index of a function.

For example, the terminal may apply for an equal number of arrays env- > funcidx according to the number of interfaces of the function. In the above embodiment, the corresponding data structure may be constructed according to the information to be compiled extracted from the bytecode file corresponding to the application program, so that the bytecode file is compiled subsequently, and the implementation is simple and convenient, and the availability is high.

In some alternative embodiments, referring to fig. 4, fig. 4 is a flowchart of another method for compiling an application program according to the embodiment shown in fig. 2, where the step 203 may include:

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

In the embodiment of the present disclosure, each instruction of the bytecode file may be converted into an intermediate representation of the underlying virtual machine, i.e., into a VVLM IR, item by item, according to the data structure constructed in step 202.

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

In the embodiment of the present disclosure, the machine code generation module on the terminal may generate the intermediate file based on the complete intermediate representation obtained after the conversion.

In the above embodiment, the instruction included in the bytecode file may be converted into the intermediate representation of the underlying virtual machine, and the intermediate file is generated, so that the target file is generated based on the intermediate file in the following, the purpose of converting the bytecode file into the machine code based on the AOT mode is achieved, the security of the target file in the following operation is ensured, and the usability is high.

In some optional embodiments, for step 203-1, the bytecode file includes different instructions, and may be correspondingly converted into different intermediate representations:

in a first case, where the instruction comprises a data access instruction, an address accessed by the data access instruction is converted into the intermediate representation of access to a first memory space.

In the embodiment of the present disclosure, the first memory space is the memory space determined when the data structure is constructed in step 202.

For example, the address accessed by the data access instruction is translated into an IR to access mblock.

In a second case, in the case where the instruction comprises a function definition instruction, the function definition instruction is converted to determine a sequence number of the defined function and to store the intermediate representation of the sequence number in an array corresponding to the defined function.

In embodiments of the present disclosure, the array is determined when the data structure is constructed. The terminal can number the defined functions in sequence, and after determining the serial numbers of the functions, the terminal stores the serial numbers in the corresponding array funcid x.

In a third case, in the case where the instruction includes a function call instruction, the function call instruction is converted into the intermediate representation that is called from the array corresponding to the called function.

In the embodiment of the present disclosure, the index of the called function may be searched in an index list including a plurality of function indexes, and in the present disclosure, in order to facilitate function call, when the function is defined, the sequence number corresponding to the function is already determined according to the sequence of the function appearing in the bytecode file, and therefore, the function call instruction may be converted into an IR for making a function call from an array corresponding to the called function (making a function call directly according to the sequence number).

In a fourth case, in a case where the instruction comprises a switch (switch) instruction, the switch instruction is converted into the intermediate representation of a conditional jump manner.

In the embodiment of the present disclosure, the conditional jump mode is an if-else-if mode. Some Internet of things equipment platforms do not support execution of a switch instruction, so that the switch instruction can be converted into an IR (Infrared) of a conditional jump mode, and the method is suitable for different Internet of things equipment platforms.

In a fifth case, where the instruction comprises an atomic instruction, the atomic instruction is converted to a data access instruction.

In the embodiment of the present disclosure, an atomic instruction refers to an instruction that allows only one processor to perform read and write operations in the same time period. The method mainly considers the equipment of multiple processors, and also considers that some Internet of things equipment platforms do not support the use of atomic instructions, and the terminal can convert the atomic instructions into common data access instructions.

It should be further noted that, in the embodiment of the present disclosure, in a case that the instruction includes a function call instruction, that is, in the process of executing the function call, a parameter may be added before a parameter included in the bytecode file, where the parameter may be a data structure env parameter. In the embodiment of the present disclosure, the data structure parameter is added for the purpose of subsequently making a function call based on the constructed data structure.

For example, if the original in the bytecode file includes 2 parameters, then the data structure env parameter may be added before these 2 parameters.

In the above embodiment, the codes included in the bytecode file can be converted into the intermediate representation of the machine code based on the previously constructed data structure, so as to generate the intermediate file, and the usability is high.

In some optional embodiments, the file description information includes, but is not limited to, at least one of: the corresponding relation information between the serial number of the function included in the intermediate file and the naming information of the function; using description information of the first memory space; wherein the first memory space is a memory space determined when the data structure is constructed; and mapping relation information between the function name and the function index included in the intermediate file.

Wherein the sequence number of the function may be determined according to the order in which the functions appear in the intermediate file. The naming information of the function includes, but is not limited to, related information when the function is named, such as naming time information, naming rule information, interface information called correspondingly when naming, and the like. The first memory space is a memory space corresponding to the information of the data segment to be compiled, which is determined when the data structure is constructed. In addition, the terminal may determine the index value corresponding to the function according to the sequence number of the function, thereby obtaining the function index. The function index may be equal to or different from the sequence number, which is not limited by this disclosure.

In the embodiment of the present disclosure, the terminal may scan the serial number of the function and the naming information of the function collected in the bytecode file, and generate a correspondence list between the serial number and the naming information of the function. The terminal can also determine the description information using the first memory space, which is acquired when the bytecode file is scanned, and the mapping relation information between the function name and the function index.

Further, referring to fig. 5, fig. 5 is a flowchart of another method for compiling an application program according to the embodiment shown in fig. 2, where the step 205 may include:

in step 205-1, the code segments comprised by the intermediate file are copied to the file to be generated.

In the embodiment of the present disclosure, a file to be generated may be newly created, and the terminal copies the code segments included in the intermediate file, that is, the machine code obtained by compiling the instructions included in the bytecode file, to the file to be generated.

In step 205-2, the file description information is generated at the designated location of the file to be generated, so as to obtain the target file.

In the disclosed embodiment, the designated position includes, but is not limited to, a head, an intermediate arbitrary position, a tail, etc. of the file to be generated. The specified location may be determined by negotiation between the terminal and the internet of things device. The target file is a file In eXecute In Place (XIP) format.

Optionally, after generating the object file, the terminal may send the object file to the internet of things IoT device, so that the internet of things device may directly load the object file from the flash memory, thereby running the application program.

The present disclosure does not limit an execution order of copying code segments included in an intermediate file into a file to be generated and generating the file description information at a designated position of the file to be generated.

In the embodiment, the bytecode file of the application program can be compiled at the terminal side, and the target file in the in-place execution format is finally generated, so that the purpose of in-place execution of the application program is realized at the equipment side of the internet of things, and the usability and the safety are high. Next, the application program running method provided by the present disclosure is introduced from the internet of things device side.

Referring to fig. 6, fig. 6 is a flowchart illustrating an application running method according to an exemplary embodiment of the present disclosure, which is described from the internet of things IoT device side, where the IoT device includes, but is not limited to, a wearable device, a smart home device, an unmanned device, and the like. As shown in fig. 6, the application program running method includes the following steps:

in step 301, in case the application needs to be run, the target file is loaded from the flash memory.

In the embodiment of the present disclosure, the target file is a file obtained based on the above application program compiling method. The internet of things device may determine that the application program needs to be run when detecting a trigger operation on the application program, and at this time, the IoT device may directly load the target file from a flash memory (flash).

In one possible implementation, the IoT device may load the object file from the flash memory based on the file description information included in the object file.

In step 302, after the target file is loaded, the application program is started.

In the embodiment of the present disclosure, the format of the target file may be an XIP format.

In the above embodiment, when the internet of things device needs to run the application program, the bytecode file corresponding to the application program does not need to be copied into the memory, but the target file obtained after the terminal side compiling can be directly loaded from the flash memory, so that the application program is started. The method and the device achieve the purpose of executing the application program in situ, save a large amount of memory of the Internet of things equipment, are suitable for various Internet of things equipment platforms, have use value on small or even micro embedded Internet of things equipment systems, and have high usability and safety.

In some alternative embodiments, referring to fig. 7, fig. 7 is a flowchart illustrating another application program running method according to the embodiment shown in fig. 6, and the step 301 may include the following steps:

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

In the embodiment of the present disclosure, the target file includes file description information, the file description information includes a correspondence between a sequence number of a function and naming information of the function, and the IoT device may determine an interface corresponding to each function in its own system.

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

In the 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.

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

In this embodiment, the size of the allocated second memory space is equal to the size of the allocated first memory space.

In step 301-4, 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 function is sorted.

In this embodiment of the present disclosure, the function index is determined based on the sequence number of the function, and therefore, based on the mapping relationship information of the file description information and the sequence of each function appearing in the target file, the array corresponding to each function is sorted so as to find the start entry of the application program and start the application program.

Accordingly, the step 302 may specifically be:

and after the target file is loaded, starting the application program through the interfaces recorded in the array corresponding to the ordered specified sequence.

In the embodiment of the disclosure, after the target file is loaded, the application program may be started through env-funcidx, and the designated sequence may be the first one, and then the internet of things device may determine that the interface recorded in the first array after the sequencing is the start entry of the application program, so as to start the application program.

In the embodiment, the internet of things device can realize the purpose of executing the application program in situ by adopting the mode, and an internet of things device platform which originally does not support bytecode execution AOT supports the in-situ starting of the application program, so that the breakthrough from impossible to feasible is realized. The method is particularly suitable for the embedded system without the memory management unit, and has high availability. In some alternative embodiments, referring to fig. 8, fig. 8 is a flowchart illustrating an application compiling and running method according to an exemplary embodiment of the disclosure, which may include the following steps:

in step 401, the terminal verifies at least one of integrity and validity of the bytecode file corresponding to the application program, and determines a verification result.

In the embodiment of the present disclosure, the terminal may determine the verification result by determining whether the bytecode file conforms to a preset file rule.

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

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

The specific construction method is similar to the method for constructing the data structure in step 202 — and will not be described herein again.

In step 404, the terminal compiles the bytecode file based on the data structure corresponding to the information to be compiled, and generates an intermediate file.

The specific generation manner is similar to the manner of generating the intermediate file in the above steps 203-1 to 203-2, and is not described herein again.

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

The file description information includes, but is not limited to, at least one of: the corresponding relation information between the serial number of the function included in the intermediate file and the naming information of the function; using description information of the first memory space; wherein the first memory space is a memory space determined when the data structure is constructed; and mapping relation information between the function name and the function index included in the intermediate file.

In step 406, the terminal copies the code segments included in the intermediate file to the file to be generated.

In step 407, the terminal generates the file description information at the designated position of the file to be generated, so as to obtain the target file.

In step 408, the terminal sends the target file to the internet of things device.

In step 409, the internet of things device loads the target file from the flash memory when the application needs to be run.

The manner of loading the target file is similar to the above steps 301-1 to 301-4, and is not described herein again.

In step 410, after the target file is loaded by the internet of things device, the application program is started through the interfaces recorded in the array corresponding to the sorted designated sequence.

Wherein the specified order may be first.

The above embodiments are further illustrated as follows.

Assuming that for an application program with a size of 400 kilobytes (kb), according to the related technology, when the internet of things device needs to run the application program, the corresponding bytecode file needs to be copied into the memory, so that memory consumption of 400kb is caused, and the memory of many IoT devices may even be smaller than 400 kb.

In the embodiment, the IOT equipment platform which does not support the execution of the bytecode AOT before supports the AOT scheme, so that the breakthrough from impossible to feasible is realized, the safe operation capability of the original AOT scheme is reserved, and the method has the value of being used on small embedded information.

Corresponding to the embodiment of the application function implementation method, the disclosure further provides an embodiment of an application function implementation device.

Referring to fig. 9, fig. 9 is a block diagram illustrating an application compiling apparatus applied to a terminal according to an exemplary embodiment, the apparatus including:

an extracting module 501, configured to extract information to be compiled from a bytecode file corresponding to the application program;

a building module 502, configured to build a data structure corresponding to the information to be compiled;

a first generating module 503, configured to compile the byte code file based on a data structure corresponding to the information to be compiled, and generate an intermediate file;

a determining module 504, configured to determine file description information used for describing information content included in the intermediate file;

a second generating module 505, configured to generate a target file obtained by compiling the application program based on the intermediate file and the file description information.

Optionally, the apparatus further comprises:

the verification module is used for verifying at least one of the integrity and the legality of the byte code file and determining a verification result;

and the control module is used for controlling the extraction module to extract the information to be compiled from the byte code file corresponding to the application program under the condition that the verification result indicates that the byte code file is a complete file and/or a legal file.

Optionally, the building module comprises at least one of:

the first determining submodule is used for determining a first memory space corresponding to the data segment information under the condition that the information to be compiled comprises the data segment information to be compiled; wherein the size of the first memory space is equal to the data volume indicated by the data segment information;

a second determining submodule, configured to determine at least one array based on the number of interfaces of a function included in the code segment information when the to-be-compiled information includes the code segment information to be compiled; wherein the number of the arrays is equal to the number of the interfaces.

Optionally, the first generating module comprises:

the conversion submodule is used for converting the instruction included in the byte code file into an intermediate representation of a bottom layer virtual machine based on a data structure corresponding to the information to be compiled;

and the first generation submodule is used for generating the intermediate file based on the intermediate representation.

Optionally, the conversion sub-module includes:

a first conversion unit, configured to, if the instruction includes a data access instruction, convert an 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 the data structure is constructed;

a second conversion unit, configured to, if the instruction includes a function definition instruction, convert the function definition instruction into a sequence number that determines a defined function and store the intermediate representation of the sequence number in an array corresponding to the defined function; wherein the array is determined when the data structure is constructed;

a third conversion unit, configured to, if the instruction includes a function call instruction, convert the function call instruction into the intermediate representation called from the array corresponding to the called function;

a fourth conversion unit, configured to convert the switch instruction into the intermediate representation of the conditional jump approach if the instruction includes a switch instruction;

a fifth conversion unit, configured to, if the instruction includes an atomic instruction, convert the atomic instruction into the data access instruction; the atomic instruction is an instruction which allows only one processor to perform read-write operation on the cache in the same time period.

Optionally, the apparatus further comprises:

and the adding module is used for adding data structure parameters before the parameters included in the byte code file under the condition that the instruction comprises a function calling instruction.

Optionally, the file description information includes at least one of:

Optionally, the second generating module includes:

the copying submodule is used for copying the code segments included in the intermediate file into a file to be generated;

and the second generation submodule is used for generating the file description information at the specified position of the file to be generated to obtain the target file.

Optionally, the apparatus further comprises:

a sending module, configured to send the target file to an IoT device.

Referring to fig. 10, fig. 10 is a block diagram illustrating an application running apparatus applied to an internet of things IoT device, according to an exemplary embodiment, and the apparatus includes:

a loading module 601, configured 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 one of the application program compiling methods;

a starting module 602, configured to start the application program after the target file is loaded.

Optionally, the loading module includes:

and the loading submodule is used for loading the target file from the flash memory based on the file description information included in the target file.

Optionally, the loading submodule includes:

a determining unit, configured to determine, in the system of the IoT device, an interface corresponding to each function based on correspondence information between a sequence number of the function included in the file description information and naming information of the function;

the recording unit is used for recording the interface in an array of a data structure corresponding to each function;

the allocation unit is used for allocating a second memory space for the target file based on the description information which uses the first memory space and is included in the file description information; wherein the size of the second memory space is equal to the size of the first memory space;

and the sorting unit is used for sorting the arrays of the data structures corresponding to the functions based on the mapping relation information between the function names and the function indexes included in the file description information.

Optionally, the starting module includes:

and the starting submodule is used for starting the application program through the interfaces recorded in the array corresponding to the sorted specified sequence.

For the device embodiments, since they substantially correspond to the method embodiments, reference may be made to the partial description of the method embodiments for relevant points. The above-described embodiments of the apparatus are merely illustrative, and the units described as separate parts may or may not be physically separate, and parts displayed 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 modules can be selected according to actual needs to achieve the purpose of the scheme of the disclosure. One of ordinary skill in the art can understand and implement it without inventive effort.

Accordingly, the present disclosure also provides a computer-readable storage medium for storing a computer program, which when executed by a processor is used for implementing the steps of the application compiling method of any one of the above-mentioned terminal sides.

Accordingly, the present disclosure also provides a computer-readable storage medium for storing a computer program, which when executed by a processor is configured to implement the steps of the application running method of any one of the IoT device sides in the internet of things.

Correspondingly, the present disclosure also provides an application compiling apparatus, including:

a 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 compiling method of any one of the terminal sides.

Fig. 11 is a block diagram illustrating an application compiling apparatus according to an example embodiment. For example, the apparatus 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 terminal.

Referring to fig. 11, apparatus 1100 may include one or more of the following components: processing component 1102, memory 1104, power component 1106, multimedia component 1108, audio component 1110, input/output (I/O) interface 1112, sensor component 1116, and communication component 1118.

The processing component 1102 generally controls the overall operation of the device 1100, such as operations associated with display, telephone 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 a portion of the steps of the methods described above. Further, the processing component 1102 may include one or more modules that 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.

One of the processors 1120 in the processing component 1102 may be configured to perform the application compilation method described above.

The memory 1104 is configured to store various types of data to support operations at the apparatus 1100. Examples of such data include instructions for any application or method operating on device 1100, contact data, phonebook data, messages, pictures, videos, and so forth. The memory 1104 may be implemented by any type or combination of volatile or non-volatile memory devices 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 or optical disks.

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

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 an input signal from a 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 boundary of a 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 facing camera and/or a rear facing camera. The front camera and/or the rear camera may receive external multimedia data when the device 1100 is in an operating mode, such as a shooting mode or a video mode. Each front camera and rear camera may be a fixed optical lens system or have a focal length and optical zoom capability.

The audio component 1110 is configured to output and/or input audio signals. For example, the audio component 1110 includes a Microphone (MIC) configured to receive external audio signals when the apparatus 1100 is in operating modes, such as a call mode, a recording mode, and a voice recognition mode. The received audio signals may further be stored in the memory 1104 or transmitted via the communication component 1118. In some embodiments, the audio assembly 1110 further includes a speaker for outputting audio signals.

The I/O interface 1112 provides an interface between the 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.

The sensor module 1116 includes one or more sensors for providing various aspects of status assessment for the device 1100. For example, the sensor module 1116 can detect an open/closed state of the device 1100, the relative positioning of the components, such as a display and keypad of the device 1100, the sensor module 1116 can also detect a change in position of the device 1100 or a component of the device 1100, the presence or absence of user contact with the device 1100, orientation or acceleration/deceleration of the device 1100, and a change in temperature of the device 1100. The sensor assembly 1116 may include a proximity sensor configured to detect the presence of a nearby object in the absence of any physical contact. The sensor assembly 1116 may also include a light 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 acceleration sensor, a gyroscope sensor, a magnetic sensor, a pressure sensor, or a temperature sensor.

The communication component 1118 is configured to facilitate communications between the apparatus 1100 and other devices in a wired or wireless manner. The apparatus 1100 may 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 broadcast signals or broadcast related information from an external broadcast management system via a broadcast channel. In an exemplary embodiment, the communication component 1118 further includes a Near Field Communication (NFC) module to facilitate short-range communications. For example, the NFC module may be implemented based on Radio Frequency Identification (RFID) technology, infrared data association (IrDA) technology, Ultra Wideband (UWB) technology, Bluetooth (BT) technology, and other technologies.

In an exemplary embodiment, the apparatus 1100 may 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, micro-controllers, microprocessors or other electronic components for performing the above-described methods.

In an exemplary embodiment, a non-transitory computer-readable storage medium comprising instructions, such as the memory 1104 comprising instructions, executable by the processor 1120 of the apparatus 1100 to perform the method described above is also provided. For example, the non-transitory computer readable storage medium may be a ROM, a Random Access Memory (RAM), a CD-ROM, a magnetic tape, a floppy disk, an optical data storage device, and the like.

Correspondingly, the present disclosure also provides an application running device, including:

a 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 of any one of the internet of things IoT device sides.

As shown in fig. 12, fig. 12 is a schematic structural diagram of an application running apparatus 1200 according to an exemplary embodiment. The apparatus 1200 may be provided as an internet of things IoT device. Referring to fig. 12, apparatus 1200 includes a processing component 1222, a wireless transmit/receive component 1224, an antenna component 1226, and wireless interface-specific signal processing components, and processing component 1222 may further include one or more processors.

One of the processors in the processing components 1222 may be configured to execute the application execution method described in any of the internet of things IoT device sides above.

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

Other embodiments of the disclosure will be apparent to those skilled in the art from consideration of the specification and practice of the disclosure disclosed herein. This application is intended to cover any variations, uses, or adaptations of the disclosure following, in general, the principles of the disclosure and including such departures from the present disclosure as come within known or customary practice within the art to which the disclosure pertains. It is intended that the specification and examples be considered as exemplary only, with a true scope and spirit of the disclosure being indicated by the following claims.

It will be understood that the present disclosure is not limited to the precise arrangements 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. An application compiling method, applied to a terminal, the method comprising:

constructing a data structure corresponding to the information to be compiled;

2. The method of claim 1, further comprising:

3. The method of claim 1, wherein the constructing a data structure corresponding to the information to be compiled comprises at least one of:

4. The method according to claim 1, wherein compiling the bytecode file based on the data structure corresponding to the information to be compiled to generate an intermediate file comprises:

generating the intermediate file based on the intermediate representation.

5. The method of claim 4, wherein 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 comprises:

in the event that the instruction comprises a function call instruction, converting the function call instruction to the intermediate representation for calling from the array corresponding to the called function;

in the event that the instruction comprises a switch instruction, converting the switch instruction into the intermediate representation of a conditional jump mode;

if the instruction comprises an atomic instruction, converting the atomic instruction into the data access instruction; the atomic instruction is an instruction which allows only one processor to perform read and write operations in the same time period.

6. The method of claim 4, further comprising:

in the case where the instruction comprises a function call instruction, data structure parameters are added before the parameters comprised by the bytecode file.

7. The method of claim 1, wherein the file description information comprises at least one of:

8. The method of claim 1, wherein generating the compiled object file for the application based on the intermediate file and the file description information comprises:

9. The method of claim 1, wherein after generating the target file, the method further comprises:

and sending the target file to an IoT (Internet of things) device.

10. An application program running method is applied to an IoT (Internet of things) device and comprises the following steps:

under the condition that the application program needs to be operated, loading a target file from a flash memory; wherein the object file is a file obtained based on the application program compiling method according to any one of claims 1 to 9;

and starting the application program after the target file is loaded.

11. The method of claim 10, wherein loading the target file from the flash memory comprises:

12. The method according to claim 11, wherein the loading the target file from the flash memory based on the file description information included in the target file comprises:

determining an interface corresponding to each function based on corresponding relation information between the sequence number of the function included in the file description information and the naming information of the function;

based on mapping relation information between function names and function indexes included in the file description information, sequencing the arrays of the data structures corresponding to the functions; wherein the function index is determined based on the sequence number of the function.

13. The method of claim 12, wherein the launching the application comprises:

14. An apparatus for compiling an application program, the apparatus being applied to a terminal, the apparatus comprising:

15. An application running device, the device being applied to an internet of things (IoT) device, the device comprising:

the loading module is used for loading the target file from the flash memory under the condition that the application program needs to be operated; wherein the object file is a file obtained based on the application program compiling method according to any one of claims 1 to 9;

16. A computer-readable storage medium, on which a computer program is stored, which, when being executed by a processor, carries out the steps of the application compilation method of any one of claims 1 to 9.

17. A computer-readable storage medium, on which a computer program is stored which, when being executed by a processor, carries out the steps of the application program execution method of any one of claims 10 to 13.

18. An application compiling apparatus comprising:

a 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 compilation method of any of claims 1-6.

19. An application compiling apparatus comprising:

a 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 program execution method of any one of claims 10-13.