WO2024051290A1

WO2024051290A1 - Code compiling method and apparatus, storage medium and electronic device

Info

Publication number: WO2024051290A1
Application number: PCT/CN2023/102751
Authority: WO
Inventors: 张超炯
Original assignee: 深圳Tcl新技术有限公司
Priority date: 2022-09-09
Filing date: 2023-06-27
Publication date: 2024-03-14
Also published as: CN117170634A

Abstract

The present application relates to the technical field of computers. Disclosed are a code compiling method and apparatus, a storage medium and an electronic device. The method comprises: injecting a compilation accelerating plugin into a compiler, and carrying out change analysis to obtain an unchanged code module; obtaining accelerated compilation logic by means of the compilation accelerating plugin; and executing the accelerated compilation logic, and by means of modifying module dependency, controlling to only compile a changed code module. The present application improves the code compilation accelerating effect and compiling reliability.

Description

Code compilation method, device, storage medium and electronic equipment

This application claims priority to the Chinese patent application filed with the China Patent Office on September 9, 2022, with the application number 202211102504.5 and the application name "Code Compilation Method, Device, Storage Medium and Electronic Equipment", the entire content of which is incorporated by reference. in this application.

Technical field

This application relates to the field of computer technology, and specifically to a code compilation method, device, storage medium and electronic equipment.

Background technique

As the size of the project code of various application projects (such as Android application projects) becomes larger and larger, the compilation speed of the compiler (such as the Gradle compiler) also increases. Sometimes a modification of the project code needs to wait for a long time. It takes several minutes to compile.

Currently, in the related technology, there is a solution to accelerate the compilation by setting the module dependencies of the project code in advance and then having the compiler perform the compilation.

technical problem

In related technologies, related setting operations are isolated from the compiler itself, and even more isolated from the compiler's compilation process. Moreover, it is difficult for related setting operations to implement adaptive settings for module dependencies. The overall accelerated compilation process has poor adaptability to project code, resulting in code Compilation reliability is poor, and the acceleration effect on code compilation is limited.

Technical solutions

The embodiments of the present application provide a solution that can effectively improve the acceleration effect of code compilation and effectively improve the reliability of code compilation.

The embodiments of this application provide the following technical solutions:

According to one embodiment of the present application, a code compilation method includes: injecting a compilation acceleration plug-in into a compiler, the compilation acceleration plug-in including change analysis logic and dependency modification logic; in response to the compiler executing a predetermined Compile process node, execute the change analysis logic to perform change analysis on the project code, and obtain the unchanged code module; modify the compilation logic of the compiler through the compilation acceleration plug-in, and dynamically inject the dependency modification logic into the Compile logic to obtain accelerated compilation logic; execute the accelerated compilation logic, and control only the changed code modules in the project code to be compiled in the compilation process by modifying the module dependencies of the unchanged code modules.

In some embodiments of the present application, executing the change analysis logic to perform change analysis on the project code to obtain an unchanged code module includes: executing the change analysis logic, and comparing code file changes to the project code, Obtain the modified code file of the project code; search for the code module to which the modified file belongs according to the file path corresponding to the modified code file, and obtain the changed code module; search for the modified code module in the project code except for the changed code module other code modules to obtain the unchanged code modules.

In some embodiments of the present application, executing the change analysis logic to perform change analysis on the project code to obtain unchanged code modules includes: executing the change analysis logic and recursively searching for each code module in the project code Download the modification time of the code file to obtain the current modification time of the code file under each code module; compare the current modification time of the code file under each code module with the historical modification time of the code file under each code module. , to obtain the unchanged code module.

In some embodiments of the present application, the current modification time of the code file under each of the code modules is compared with the historical modification time of the code files under each of the code modules to obtain the unchanged code module, The method includes: performing information summary calculation on the current modification time of the code file under each code module to obtain the current summary corresponding to each code module; obtaining the historical summary corresponding to each code module, and the historical summary is It is obtained by calculating the information summary of the historical modification time of the code file under each code module; comparing the current summary and the historical summary corresponding to each code module, the unchanged code module is obtained.

In some embodiments of the present application, the dependency modification logic includes module dependency graph analysis logic and dependency modification logic; the execution of the accelerated compilation logic controls the compilation process by modifying the module dependencies of the unchanged code modules. Compiling only the changed code modules in the project code includes: executing the module dependency graph analysis logic in the accelerated compilation logic, performing dependency analysis on the code modules in the project code, and obtaining a module dependency graph; Execute the dependency modification logic in the accelerated compilation logic, modify the unchanged code module in the module dependency graph to the corresponding compiled file, and obtain the modified dependency graph; execute the accelerated compilation logic The compilation logic is used to compile code according to the modified dependency graph, so as to compile only the changed code modules in the project code.

In some embodiments of the present application, the compilation acceleration plug-in also includes a local warehouse; the dependency modification logic in the acceleration compilation logic is executed, and the unchanged code in the module dependency graph is Modifying the module into the corresponding compiled file and obtaining the modified dependency graph includes: executing the dependency modification logic in the accelerated compilation logic, and querying the compiled file corresponding to the unchanged code module from the local warehouse; Modify the changed code module in the module dependency graph into the compiled file to obtain a modified dependency graph.

In some embodiments of the present application, after the accelerated compilation logic is executed and the module dependencies of the unchanged code modules are modified to control only the changed code modules in the project code to be compiled in the compilation process, the The method also includes: if the compilation of the modified code module is completed, packaging the compiled modified code module into a modified code module compiled file through the compilation acceleration plug-in; and storing the modified code module compiled file in the compiled file. Accelerate local repository in plugin.

According to an embodiment of the present application, a code compilation device includes: an injection unit for injecting a compilation acceleration plug-in into a compiler, where the compilation acceleration plug-in includes change analysis logic and dependency modification logic; an analysis unit for responding Execute to the predetermined compilation process node in the compiler, execute the change analysis logic to perform change analysis on the project code, and obtain the unchanged code module; the modification unit is used to compile the compiler through the compilation acceleration plug-in The logic is modified, and the dependency modification logic is dynamically injected into the compilation logic to obtain accelerated compilation logic; the compilation unit is used to execute the accelerated compilation logic and control the compilation process by modifying the module dependencies of the unchanged code modules. Only the changed code modules in the project code will be compiled.

In some embodiments of the present application, the analysis unit is used to: execute the change analysis logic, perform code file change comparison on the project code, and obtain a modified code file of the project code; according to the modified code Find the file path corresponding to the file, search for the code module to which the modified file belongs, and obtain the changed code module; search for code modules in the project code other than the changed code module, and obtain the unchanged code module.

In some embodiments of this application, the analysis unit is used to: execute the change analysis logic, recursively search the modification time of the code files under each code module in the project code, and obtain the code files under each code module. The current modification time of the code file under each code module is compared with the historical modification time of the code file under each code module to obtain the unchanged code module.

In some embodiments of the present application, the analysis unit is used to: perform information summary calculation on the current modification time of the code file under each of the code modules to obtain the current summary corresponding to each of the code modules; obtain each A historical summary corresponding to each of the code modules. The historical summary is obtained by calculating the information summary of the historical modification time of the code file under each of the code modules; compare the current summary and the historical summary corresponding to each of the code modules. , to obtain the unchanged code module.

In some embodiments of the present application, the dependency modification logic includes module dependency graph analysis logic and dependency relationship modification logic; the compilation unit is used to: execute the module dependency graph analysis logic in the accelerated compilation logic, Perform dependency analysis on the code modules in the project code to obtain a module dependency graph; execute the dependency modification logic in the accelerated compilation logic to modify the unchanged code modules in the module dependency graph to the corresponding compiled files to obtain a modified dependency graph; execute the compilation logic in the accelerated compilation logic, and perform code compilation according to the modified dependency graph to compile only the changed code modules in the project code.

In some embodiments of the present application, the compilation acceleration plug-in also includes a local warehouse; the compilation unit is used to: execute the dependency modification logic in the accelerated compilation logic, and query all the dependencies from the local warehouse. The compiled file corresponding to the unchanged code module is modified; the changed code module in the module dependency graph is modified into the compiled file to obtain a modified dependency graph.

In some embodiments of the present application, the device further includes a packaging unit, configured to: if the compilation of the modified code module is completed, package the compiled modified code module into a modified code module through the compilation acceleration plug-in. File; store the modified code module compiled file into the local warehouse in the compilation acceleration plug-in.

According to another embodiment of the present application, a storage medium has a computer program stored thereon. When the computer program is executed by a processor of a computer, the computer is caused to execute the method described in the embodiment of the present application.

According to another embodiment of the present application, an electronic device may include: a memory storing a computer program; and a processor reading the computer program stored in the memory to execute the method described in the embodiment of the present application.

According to another embodiment of the present application, a computer program product or computer program includes computer instructions stored in a computer-readable storage medium. The processor of the computer device reads the computer instructions from the computer-readable storage medium, and the processor executes the computer instructions, so that the computer device executes the methods provided in the various optional implementations described in the embodiments of this application.

beneficial effects

In the embodiment of the present application, a compilation acceleration plug-in is injected into the compiler, and the compilation acceleration plug-in includes change analysis logic and dependency modification logic; in response to the execution of the predetermined compilation process node in the compiler, the change analysis logic pair is executed Conduct change analysis on the project code to obtain the unchanged code module; modify the compilation logic of the compiler through the compilation acceleration plug-in, and dynamically inject the dependency modification logic into the compilation logic to obtain accelerated compilation logic; execute the above To accelerate the compilation logic, by modifying the module dependencies of the unchanged code modules, the compilation process is controlled to only compile the changed code modules in the project code.

In this way, by providing a compilation acceleration plug-in that includes change analysis logic and acceleration logic that relies on modification logic, the acceleration logic is injected into the compiler as a plug-in, so that the acceleration logic cooperates with the compiler, and the compiler can use the change analysis logic to modify the project code. To realize automatic change analysis, the compilation acceleration plug-in can modify the compilation logic of the compiler, dynamically inject the dependency modification logic into the compilation logic, and obtain the accelerated compilation logic of deep collaborative acceleration logic and compilation logic. By accelerating the compilation logic, the project code can be modified. Module dependencies are adaptively modified to accelerate the compilation process, and the overall compilation process is adapted to the project code. It has high adaptability, which can effectively improve the acceleration effect of code compilation and effectively improve the reliability of code compilation.

Description of the drawings

In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings needed to be used in the description of the embodiments will be briefly introduced below. Obviously, the drawings in the following description are only some embodiments of the present application. For those skilled in the art, other drawings can also be obtained based on these drawings without exerting creative efforts.

Figure 1 shows a flow chart of a code compilation method according to an embodiment of the present application.

Figure 2 shows the module structure diagram of the compilation acceleration plug-in in one scenario.

Figure 3 shows a flow chart of code compilation using an embodiment of the present application in one scenario.

Figure 4 shows a block diagram of a code compilation device according to an embodiment of the present application.

Figure 5 shows a block diagram of an electronic device according to one embodiment of the present application.

Embodiments of the invention

The technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present application. Obviously, the described embodiments are only some of the embodiments of the present application, rather than all of the embodiments. Based on the embodiments in this application, all other embodiments obtained by those skilled in the art without making creative efforts fall within the scope of protection of this application.

Figure 1 schematically shows a flow chart of a code compilation method according to an embodiment of the present application. The execution subject of the code compilation method can be any device, for example, terminals such as computers, mobile phones, smart watches, and home appliances, or servers such as server clusters and cloud servers.

As shown in Figure 1, the code compilation method may include steps S110 to S140.

Step S110, inject the compilation acceleration plug-in into the compiler. The compilation acceleration plug-in includes change analysis logic and dependency modification logic; Step S120, in response to the execution of the predetermined compilation process node in the compiler, execute the change analysis logic pair Perform change analysis on the project code to obtain the unchanged code module; step S130, modify the compilation logic of the compiler through the compilation acceleration plug-in, and dynamically inject the dependency modification logic into the compilation logic to obtain accelerated compilation logic; Step S140: Execute the accelerated compilation logic, and control only the changed code modules in the project code to be compiled in the compilation process by modifying the module dependencies of the unchanged code modules.

The compilation acceleration plug-in is a plug-in that contains acceleration logic to accelerate the compilation process. The acceleration logic can include change analysis logic and dependency modification logic. Change analysis logic can be code that analyzes changes in code modules in the project code. The dependency modification logic can be analyzing the module dependencies of the code module and modifying the code of the module dependencies. The compilation acceleration plug-in can be injected into the compiler in the form of plug-in injection. The compiler is a tool used to compile the project code. For example, the compiler can be the Gradle tool.

The user can trigger the compiler to start the compilation process. After the compilation process is started, it will be executed to the predetermined compilation process node (for example, after the compilation process is started, the initialization phase will be carried out first, and then the configuration phase will be carried out (this phase can traverse the scripts of each code module to establish tasks). Execution relationship diagram), the completion of the configuration phase is regarded as execution to the scheduled compilation process node), the compiler can trigger the execution of the change analysis logic in the compilation acceleration plug-in, the change analysis logic can perform change analysis on the project code, and obtain the unchanged code module. Unchanged code modules may be code modules in the project code that have not been modified within a predetermined period of time.

Through the compilation acceleration plug-in, the compilation logic of the compiler (that is, the code of the compiler itself) can be reflected or callback (HOOK) to modify the compilation logic, thereby dynamically injecting the dependency modification logic into the compilation logic, and injecting the compilation of the dependency modification logic. The logic can be accelerated compilation logic.

Execute accelerated compilation logic, that is, the module dependencies of unchanged code modules can be reliably modified through the injected dependency modification logic to control the compilation logic to only modify the changed code modules in the project code during the compilation process. Line compilation, that is, skipping the compilation of unchanged code modules and only compiling the changed code modules, thereby adaptively speeding up the compilation of the project code.

In this way, based on steps S110 to S140, by providing a compilation acceleration plug-in including change analysis logic and acceleration logic that depends on modification logic, the acceleration logic is injected into the compiler as a plug-in, so that the acceleration logic cooperates with the compiler, and the compiler can Implement automatic change analysis on the project code through change analysis logic. The compilation acceleration plug-in can modify the compilation logic of the compiler, dynamically inject the dependency modification logic into the compilation logic, and obtain the accelerated compilation logic of deep collaborative acceleration logic and compilation logic. Through acceleration The compilation logic can adaptively modify the module dependencies in the project code, thereby accelerating the compilation process. The overall accelerated compilation process is highly adaptable to the project code, which can effectively improve the acceleration effect of code compilation and effectively improve the reliability of code compilation.

The following describes further specific optional embodiments of each step performed when compiling code under the embodiment in Figure 1.

In one embodiment, in step S120, the execution of the change analysis logic performs change analysis on the project code to obtain an unchanged code module, including:

Execute the change analysis logic, compare the code file changes of the project code, and obtain the modified code file of the project code; according to the file path corresponding to the modified code file, search for the code module to which the modified file is subordinate, and obtain The changed code module; search for code modules other than the changed code module in the project code to obtain the unchanged code module.

In this embodiment, the change analysis logic can efficiently and accurately analyze the changed code modules and unchanged code modules by comparing the code file changes of the project code and searching under the file path.

Specifically, the change analysis logic can include the git diff command line. Executing the git diff command line can compare the current project code with the scheduled version of the project code, obtain the modified code files in the current project code, and obtain the modified code. File list of files. After the modified code file is determined, the path search command line in the change analysis logic can be used to find the code module to which each modified code file is dependent, and the code module to which the modified code file is dependent can be found based on the file path (path) corresponding to each modified code file. The code module is the changed code module that has been modified. Furthermore, the code modules in the project code other than the changed code module can be determined as the unchanged code module.

Execute the change analysis logic, recursively search the modification time of the code file under each code module in the project code, and obtain the current modification time of the code file under each code module; add the current modification time of the code file under each code module The modification time is compared with the historical modification time of the code file under each code module to obtain the unchanged code module.

In this embodiment, the change analysis logic recursively searches the modification time of the code file under each code module and compares it. In a certain program, the changed code module and the unchanged code module can be quickly analyzed.

Specifically, each time a code file is modified, the modification time can be recorded accordingly. The change analysis logic can recursively search the modification time of the code file under each code module in the project code to obtain the current modification time of the code file under each code module. Furthermore, the change analysis logic can compare the current modification time of the code file under each code module with the historical modification time of the code file under each code module. If the current modification time under a certain code module is inconsistent with the historical modification time, the A certain code module is a changed code module, and the code modules in the project code other than the changed code modules can be determined as unchanged code modules. Among them, the historical modification time can be the modification time of each code file recorded in a certain historical version of the project code.

Further, in one embodiment, the current modification time of the code file under each of the code modules is compared with the historical modification time of the code files under each of the code modules to obtain the unchanged code module, include:

Calculate the information summary of the current modification time of the code file under each code module to obtain the current summary corresponding to each code module; obtain the historical summary corresponding to each code module, and the historical summary is for each code module The historical modification time of the code files under each of the code modules is obtained by calculating the information summary; comparing the current summary and the historical summary corresponding to each of the code modules, the unchanged code module is obtained.

For example, calculate the information summary of the current modification time of the code file under the A code module to obtain the current summary A1 corresponding to the A code module; obtain the historical summary A2 corresponding to the A code module. The historical summary A2 is the code file under each code module. It is obtained by calculating the information summary of the historical modification time; compare the current summary A1 and the historical summary A2 corresponding to the A code module. If the current summary A1 and the historical summary A2 are consistent, the A code module is an unchanged code module. In this way, the efficiency of recursively searching and comparing the modification times of code files under each code module can be further improved.

In one embodiment, the dependency modification logic includes module dependency graph analysis logic and dependency relationship modification logic; in step S140, the execution of the accelerated compilation logic controls compilation by modifying the module dependencies of the unchanged code modules. During the process, only the changed code modules in the project code are compiled, including:

Execute the module dependency graph analysis logic in the accelerated compilation logic to perform dependency analysis on the code modules in the project code to obtain a module dependency graph; execute the dependency modification logic in the accelerated compilation logic to obtain The unchanged code module in the module dependency graph is modified into the corresponding compiled file to obtain a modified dependency graph; the compilation logic in the accelerated compilation logic is executed, and code compilation is performed according to the modified dependency graph , to compile only the changed code modules in the project code.

Dependency modification logic includes module dependency graph analysis logic and dependency modification logic. Dependency modification logic is injected into compilation logic to obtain accelerated compilation logic. Furthermore, accelerated compilation logic can include collaborative module dependency graph analysis logic, dependency modification logic and compilation logic.

The module dependency graph analysis logic can be code that analyzes the dependencies between code modules. The module dependency graph analysis logic in the accelerated compilation logic can be executed to perform dependency analysis on all code modules in the project code and analyze the dependencies between code modules. Calling relationships (i.e., dependencies), and obtaining a module dependency graph describing the calling relationships (i.e., dependencies) between code modules.

The dependency modification logic can be the code that modifies the dependencies in the module dependency graph. The dependency modification logic in the accelerated compilation logic can be executed. The unchanged code module in the module dependency graph can be modified into the corresponding compiled file to obtain the modified dependencies. picture. The compiled file may be an AAR file corresponding to the unchanged code module.

Furthermore, when the compilation logic in the accelerated compilation logic is executed and the code is compiled according to the modified dependency graph, the compilation of the compiled files can be automatically skipped, so that only the changed code modules in the project code are compiled.

In one embodiment, the compilation acceleration plug-in further includes a local warehouse; the execution of the dependency modification logic in the acceleration compilation logic modifies the changed code module in the module dependency graph to the corresponding Compiled files, get the modified dependency graph, including:

Execute the dependency modification logic in the accelerated compilation logic, query the compiled file corresponding to the changed code module from the local warehouse; modify the changed code module in the module dependency graph to the changed code module Compile the file and get the modified dependency graph.

In this embodiment, the compilation acceleration plug-in also includes a local warehouse, and the local warehouse that stores compiled files will also be injected into the compiler. In the compiler, the dependency modification logic in the accelerated compilation logic is executed. The compiled files corresponding to the changed code modules will be queried from the local warehouse injected into the compiler to make modifications. In this way, the stability and efficiency of accelerated compilation are further improved.

Further, in one embodiment, after the accelerated compilation logic is executed and the module dependencies of the unchanged code modules are modified to control only the changed code modules in the project code to be compiled in the compilation process, the The above methods also include:

If the compilation of the modified code module is completed, the compiled modified code module is packaged into a modified code module compiled file through the compilation acceleration plug-in; and the modified code module compiled file is stored in a local location in the compiled acceleration plug-in. storehouse.

In this embodiment, after the compilation of the change code module is completed, the compiler further uses the compilation acceleration plug-in to package the compiled change code module into a change code module compilation file. The change code module compilation file is the AAR file corresponding to the change code module. , and then store the changed code module compiled files to the local warehouse in the compilation acceleration plug-in, which can be used as needed during subsequent compilation.

In order to better describe the code compilation method provided by the embodiments of the present application, the foregoing embodiments are further described below in conjunction with the code compilation process in a scenario in which code compilation is performed by applying the foregoing embodiments of the present application. Figure 2 shows the module architecture diagram of the compilation acceleration plug-in in this scenario. Figure 3 shows the flow chart of code compilation in this scenario.

Refer to Figure 2. In this scenario, the compilation acceleration plug-in at least includes engineering change awareness code, module dependency graph analysis code, dependency modification algorithm and local storage warehouse. Among them, the engineering change awareness code is the change analysis logic, and the module dependency graph analysis code is The module dependency graph analysis logic, the dependency modification algorithm is the dependency modification logic, and the local storage warehouse is the local warehouse.

Referring to Figure 3, in this scenario, the code compilation process may include steps S210 to S2110.

Step S210, inject code. Specifically, a compilation acceleration plug-in is injected into the compiler. The compilation acceleration plug-in includes change analysis logic, dependency modification logic, and a local warehouse. The dependency modification logic includes module dependency graph analysis logic and dependency modification logic.

In step S220, the developer clicks to start compilation, that is, the developer clicks on the compiler to trigger compilation.

Step S230: Obtain which module has not been changed. Specifically, in response to the execution of the predetermined compilation process node in the compiler, the change analysis logic is executed to perform change analysis on the project code, and an unchanged code module is obtained.

Executing the change analysis logic to perform change analysis on the project code to obtain an unchanged code module may include: executing the change analysis logic, comparing code file changes to the project code, and obtaining a modified code file of the project code; According to the file path corresponding to the modified code file, search for the code module to which the modified file is subordinate to obtain the changed code module; search for code modules other than the changed code module in the project code to obtain the unchanged code module. Change code modules.

Alternatively, executing the change analysis logic to perform change analysis on the project code to obtain unchanged code modules may include: executing the change analysis logic, recursively searching for the modification time of the code file under each code module in the project code, and obtaining The current modification time of the code file under each code module; compare the current modification time of the code file under each code module with the historical modification time of the code file under each code module to obtain the unchanged code module . Comparing the current modification time of the code file under each code module with the historical modification time of the code file under each code module to obtain the unchanged code module may include: Calculate the information summary of the current modification time of the code file to obtain the current summary corresponding to each code module; obtain the historical summary corresponding to each code module, and the historical summary is the code file under each code module It is obtained by calculating the information summary of the historical modification time; compare the current summary corresponding to each code module with Historical summary, resulting in the unchanged code module.

Step S240, return the module list, that is, the module list of unchanged code modules obtained by the change analysis logic analysis is returned to the compilation acceleration plug-in.

Furthermore, the compilation logic of the compiler is modified through the compilation acceleration plug-in, and the dependency modification logic is dynamically injected into the compilation logic to obtain accelerated compilation logic.

In step S250, the unchanged modules are fed to the modification algorithm, that is, the compilation acceleration plug-in feeds the module list of the unchanged code modules to the dependency modification logic.

Step S260: Obtain the dependency graph and return the dependency graph. Specifically, the module dependency graph analysis logic in the accelerated compilation logic is executed, dependency analysis is performed on the code modules in the project code, the module dependency graph is obtained, and the module dependency graph is given to the dependency modification logic.

Step S270: Obtain the AAR corresponding to the unchanged module and return the AAR. Specifically, the dependency modification logic in the accelerated compilation logic is executed, and the compiled files corresponding to the unchanged code modules (i.e., AAR files) are queried from the local warehouse.

Step S280: Modify the dependencies of the entire project. Specifically, the dependency modification logic modifies the changed code module in the module dependency graph into a compiled file to obtain a modified dependency graph.

That is, from step S270 to step S280, the dependency modification logic in the accelerated compilation logic is executed, and the unchanged code modules in the module dependency graph are modified into corresponding compiled files to obtain a modified dependency graph.

Step S290: After the modification is completed, compilation continues. Specifically, after obtaining the modified dependency graph, the compilation logic in the accelerated compilation logic is executed, and code compilation is performed according to the modified dependency graph, so that only the changed code modules in the project code are compiled.

That is, from step S260 to step S290, the accelerated compilation logic is executed, and by modifying the module dependencies of the unchanged code modules, the compilation process is controlled to compile only the changed code modules in the project code.

Step S2100: Compilation is completed, that is, compilation of the changed code modules in the project code is completed.

Step S2110: After compilation is completed, the modified module is packaged into AAR. Specifically, if the compilation of the modified code module is completed, the compiled modified code module is packaged into a modified code module compilation file (ie, an AAR file) through the compilation acceleration plug-in.

Step S2120: Update the local warehouse for next compilation and use. Specifically, the changed code module compilation file is stored in a local warehouse in the compilation acceleration plug-in.

In this way, by applying the aforementioned embodiments of the present application in this scenario, at least the following beneficial effects are achieved: the overall accelerated compilation process has high adaptability to the project code, can effectively improve the acceleration effect of code compilation, and effectively improves the reliability of code compilation. .

In order to facilitate better implementation of the code compilation method provided by the embodiment of the present application, the embodiment of the present application also provides a code compilation device based on the above code compilation method. The meanings of the nouns are the same as in the above code compilation method. For specific implementation details, please refer to the description in the method embodiment. Figure 3 shows a block diagram of a code compilation device according to an embodiment of the present application.

As shown in FIG. 4 , the code compilation device 300 may include an injection unit 310 , an analysis unit 320 , a modification unit 330 , and a compilation unit 340 .

The injection unit 310 can be used to inject the compilation acceleration plug-in into the compiler, the compilation acceleration plug-in includes change analysis logic and dependency modification logic; the analysis unit 320 can be used to respond to the execution of the predetermined compilation process node in the compiler, execute The change analysis logic performs change analysis on the project code to obtain an unchanged code module; the modification unit 330 can be used to modify the compilation logic of the compiler through the compilation acceleration plug-in, and dynamically inject the dependency modification logic into all The compilation logic is described above to obtain accelerated compilation logic; the compilation unit 340 can be used to execute the accelerated compilation logic by modifying the unchanged code. Module dependencies of code modules control the compilation process of only changed code modules in the project code.

It should be noted that although several modules or units of equipment for action execution are mentioned in the above detailed description, this division is not mandatory. In fact, according to the embodiments of the present application, the features and functions of two or more modules or units described above may be embodied in one module or unit. Conversely, the features and functions of one module or unit described above may be further divided into being embodied by multiple modules or units.

In addition, embodiments of the present application also provide an electronic device, which may be a terminal or a server, as shown in Figure 5, which shows a schematic structural diagram of the electronic device involved in the embodiment of the present application. Specifically:

The electronic device may include components such as a processor 401 of one or more processing cores, a memory 402 of one or more computer-readable storage media, a power supply 403, and an input unit 404. Those skilled in the art can understand that the structure of the electronic device shown in FIG. 5 does not constitute a limitation of the electronic device, and may include more or fewer components than shown, or combine certain components, or arrange different components. in:

The processor 401 is the control center of the electronic device, using various interfaces and lines to connect various parts of the entire computer device, by running or executing software programs and/or modules stored in the memory 402, and calling programs stored in the memory 402. Data, perform various functions of computer equipment and process data to provide overall monitoring of electronic equipment. Optionally, the processor 401 may include one or more processing cores; preferably, the processor 401 may integrate an application processor and a modem processor, where the application processor mainly processes operating systems, user pages, application programs, etc. , the modem processor mainly handles wireless communications. It can be understood that the above modem processor may not be integrated into the processor 401.

The memory 402 can be used to store software programs and modules. The processor 401 executes various functional applications and data processing by running the software programs and modules stored in the memory 402 . The memory 402 may mainly include a storage program area and a storage data area, wherein the storage program area may store an operating system, an application program required for at least one function (such as a sound playback function, an image playback function, etc.), etc.; the storage data area may store data based on Data created by the use of computer equipment, etc. In addition, memory 402 may include high-speed random access memory, and may also include non-volatile memory, such as at least one magnetic disk storage device, flash memory device, or other volatile solid-state storage device. Accordingly, the memory 402 may also include a memory controller to provide the processor 401 with access to the memory 402 .

The electronic device also includes a power supply 403 that supplies power to various components. Preferably, the power supply 403 can be logically connected to the processor 401 through a power management system, so that functions such as charging, discharging, and power consumption management can be implemented through the power management system. The power supply 403 may also include one or more DC or AC power supplies, recharging systems, power failure detection circuits, power converters or inverters, power status indicators, and other arbitrary components.

The electronic device may also include an input unit 404 that may be used to receive input numeric or character information and generate keyboard, mouse, joystick, optical or trackball signal inputs related to user settings and function control.

Although not shown, the electronic device may also include a display unit and the like, which will not be described again here. Specifically, in this embodiment, the processor 401 in the electronic device will load the executable files corresponding to the processes of one or more computer programs into the memory 402 according to the following instructions, and the processor 401 will run the executable files stored in the computer program. The computer program in the memory 402 can realize various functions in the aforementioned embodiments of the present application. For example, the processor 401 can perform the following steps:

Inject the compilation acceleration plug-in into the compiler, the compilation acceleration plug-in includes change analysis logic and dependency modification logic; in response to the execution of the compiler to a predetermined compilation process node, execute the change analysis logic to perform change analysis on the project code, Obtain the unchanged code module; modify the compilation logic of the compiler through the compilation acceleration plug-in, and dynamically inject the dependency modification logic into the compilation logic to obtain the accelerated compilation logic; execute the accelerated compilation logic, and through the modification The module dependencies of the unchanged code modules control the compilation process of only the changed code modules in the project code.

In some embodiments of the present application, executing the change analysis logic to perform change analysis on the project code to obtain an unchanged code module includes: executing the change analysis logic, and comparing code file changes to the project code, Obtain the modified code file of the project code; search for the code module to which the modified file belongs according to the file path corresponding to the modified code file, and obtain the changed code module; search for the modified code module in the project code except for the changed code module other code modules to obtain the unchanged code module.

In some embodiments of the present application, executing the change analysis logic to perform change analysis on the project code to obtain unchanged code modules includes: executing the change analysis logic and recursively searching for each code module in the project code Download the modification time of the code file to obtain the current modification time of the code file under each code module; compare the current modification time of the code file under each code module with each code module The historical modification time of the code files under the block is compared to obtain the unchanged code module.

In some embodiments of the present application, the compilation acceleration plug-in also includes a local warehouse; the execution of the dependency modification logic in the accelerated compilation logic converts the unchanged code in the module dependency graph Modifying the module into the corresponding compiled file and obtaining the modified dependency graph includes: executing the dependency modification logic in the accelerated compilation logic, and querying the compiled file corresponding to the unchanged code module from the local warehouse; Modify the changed code module in the module dependency graph into the compiled file to obtain a modified dependency graph.

In some embodiments of the present application, after the accelerated compilation logic is executed, by modifying the module dependencies of the unchanged code modules, and controlling only the changed code modules in the project code to be compiled in the compilation process, there is also The method may include: if the compilation of the modified code module is completed, packaging the compiled modified code module into a modified code module compiled file through the compilation acceleration plug-in; and storing the modified code module compiled file in the compilation acceleration plug-in local repository in .

Those of ordinary skill in the art can understand that all or part of the steps in the various methods of the above embodiments can be completed by a computer program, or by controlling relevant hardware by a computer program. The computer program can be stored in a computer-readable storage. media and loaded and executed by the processor.

To this end, embodiments of the present application also provide a storage medium in which a computer program is stored, and the computer program can be loaded by the processor to execute steps in any method provided by the embodiments of the present application.

Among them, the storage medium may include: read-only memory (ROM, Read Only Memory), random access memory (RAM, Random Access Memory), magnetic disk or optical disk, etc.

Since the computer program stored in the storage medium can execute steps in any of the methods provided by the embodiments of the present application, it is possible to achieve the beneficial effects that can be achieved by the methods provided by the embodiments of the present application. For details, see above The embodiments will not be described again here.

Other embodiments of the present application will be readily apparent to those skilled in the art from consideration of the specification and practice of the embodiments disclosed herein. This application is intended to cover any variations, uses, or adaptations of this application that follow the general principles of this application and include common knowledge or customary technical means in the technical field that are not disclosed in this application. .

It should be understood that the present application is not limited to the embodiments which have been described above and shown in the drawings, but various modifications and changes may be made without departing from the scope thereof.

Claims

A code compilation method, including:

Inject the compilation acceleration plug-in into the compiler, which includes change analysis logic and dependency modification logic;

In response to execution in the compiler reaching a predetermined compilation process node, executing the change analysis logic to perform change analysis on the project code to obtain an unchanged code module;

Modify the compilation logic of the compiler through the compilation acceleration plug-in, and dynamically inject the dependency modification logic into the compilation logic to obtain accelerated compilation logic;

Execute the accelerated compilation logic, and by modifying the module dependencies of the unchanged code modules, control the compilation process to compile only the changed code modules in the project code.
The method according to claim 1, wherein executing the change analysis logic to perform change analysis on the project code to obtain an unchanged code module includes:

Execute the change analysis logic, compare the code file changes of the project code, and obtain the modified code file of the project code;

According to the file path corresponding to the modified code file, search for the code module to which the modified file belongs, and obtain the changed code module;

Search for code modules in the project code other than the changed code module to obtain the unmodified code module.
The method according to claim 1, wherein executing the change analysis logic to perform change analysis on the project code to obtain an unchanged code module includes:

Execute the change analysis logic, recursively search the modification time of the code file under each code module in the project code, and obtain the current modification time of the code file under each code module;

Compare the current modification time of the code file under each code module with the historical modification time of the code file under each code module to obtain the unchanged code module.
The method according to claim 3, wherein the current modification time of the code file under each of the code modules is compared with the historical modification time of the code files under each of the code modules to obtain the unchanged code Modules, including:

Calculate the information summary of the current modification time of the code file under each code module to obtain the current summary corresponding to each code module;

Obtain the historical summary corresponding to each of the code modules. The historical summary is obtained by calculating the information summary of the historical modification time of the code file under each of the code modules;

Compare the current summary and the historical summary corresponding to each code module to obtain the unchanged code module.
The method according to claim 1, wherein the dependency modification logic includes module dependency graph analysis logic and dependency relationship modification logic;

The execution of the accelerated compilation logic, by modifying the module dependencies of the unchanged code modules, controls the compilation process to compile only the changed code modules in the project code, including:

Execute the module dependency graph analysis logic in the accelerated compilation logic, perform dependency analysis on the code modules in the project code, and obtain a module dependency graph;

Execute the dependency modification logic in the accelerated compilation logic, modify the unchanged code module in the module dependency graph to the corresponding compiled file, and obtain a modified dependency graph;

Execute the compilation logic in the accelerated compilation logic, and perform code compilation according to the modified dependency graph to compile only the changed code modules in the project code.
The method according to claim 4, wherein the compilation acceleration plug-in further includes a local warehouse;

Execute the dependency modification logic in the accelerated compilation logic, modify the unchanged code module in the module dependency graph into the corresponding compiled file, and obtain a modified dependency graph, including:

Execute the dependency modification logic in the accelerated compilation logic, and query the compiled files corresponding to the unchanged code modules from the local warehouse;

Modify the changed code module in the module dependency graph into the compiled file to obtain a modified dependency graph.
The method according to claim 1, wherein after the execution of the accelerated compilation logic, by modifying the module dependencies of the unchanged code modules, the compilation process is controlled to compile only the changed code modules in the project code. , the method also includes:

If the compilation of the modified code module is completed, the compiled modified code module is packaged into a modified code module compilation file through the compilation acceleration plug-in;

The modified code module compilation file is stored in the local warehouse in the compilation acceleration plug-in.
The method according to claim 2, wherein the execution of the change analysis logic, comparing the code file changes of the project code, and obtaining the modified code file of the project code includes:

Execute the git diff command line in the change analysis logic to compare the current project code with the project code of the predetermined version to obtain the modified code files that have been modified in the current project code.
The method according to claim 2, wherein the step of searching for the code module to which the modified file belongs based on the file path corresponding to the modified code file to obtain the changed code module includes:

Execute the path search command line in the change analysis logic to find the code module to which each modified code file is subordinate based on the file path corresponding to each modified code file. The code module to which each modified code file is subordinate is found. That is, the modified code module has been modified.
The method according to claim 3, wherein the current modification time of the code file under each of the code modules is compared with the historical modification time of the code files under each of the code modules to obtain the unchanged code Modules, including:

Compare the current modification time of the code file under each of the code modules with the historical modification time of the code file under each of the code modules to obtain the code module whose current modification time is inconsistent with the historical modification time;

The code module whose current modification time is inconsistent with the historical modification time is determined as the changed code module, wherein the code modules in the project code other than the changed code module are the unchanged code modules.
The method according to claim 1, wherein the response to executing a predetermined compilation process node in the compiler includes:

After starting the compilation process in the compiler, if the compilation process completes the configuration phase of traversing the scripts of each code module in the project code to establish a task execution relationship graph, then it is determined that the compiler executes to the scheduled Compile process node.
A code compilation device, which includes:

An injection unit is used to inject the compilation acceleration plug-in into the compiler. The compilation acceleration plug-in includes change analysis logic and dependency modification logic;

An analysis unit, configured to execute the change analysis logic to perform change analysis on the project code in response to the execution of the predetermined compilation process node in the compiler to obtain an unchanged code module;

a modification unit, used to modify the compilation logic of the compiler through the compilation acceleration plug-in, Dynamically inject the dependency modification logic into the compilation logic to obtain accelerated compilation logic;

A compilation unit is used to execute the accelerated compilation logic and control only the changed code modules in the project code to be compiled in the compilation process by modifying the module dependencies of the unchanged code modules.
The device according to claim 12, wherein the analysis unit is configured to: execute the change analysis logic, perform code file change comparison on the project code, and obtain a modified code file of the project code; according to the Modify the file path corresponding to the code file, search for the code module to which the modified file is subordinate, and obtain the changed code module; search for the code modules in the project code other than the changed code module, and obtain the unchanged code module. .
The device according to claim 12, wherein the analysis unit is used to: execute the change analysis logic, recursively search the modification time of the code file under each code module in the project code, and obtain the modification time under each code module. The current modification time of the code file; compare the current modification time of the code file under each of the code modules with the historical modification time of the code file under each of the code modules to obtain the unchanged code module.
The device according to claim 14, wherein the analysis unit is used to: perform information summary calculation on the current modification time of the code file under each of the code modules to obtain the current summary corresponding to each of the code modules; Obtain the historical summary corresponding to each of the code modules. The historical summary is obtained by calculating the information summary of the historical modification time of the code file under each of the code modules; compare the current summary corresponding to each of the code modules with Historical summary, resulting in the unchanged code module.
The device according to claim 12, wherein the dependency modification logic includes module dependency graph analysis logic and dependency relationship modification logic; the compilation unit is configured to: perform the module dependency graph analysis in the accelerated compilation logic Logic: perform dependency analysis on the code modules in the project code to obtain a module dependency graph; execute the dependency modification logic in the accelerated compilation logic to modify the unchanged code modules in the module dependency graph For the corresponding compiled file, obtain a modified dependency graph; execute the compilation logic in the accelerated compilation logic, and perform code compilation according to the modified dependency graph to only modify the changed code modules in the project code. Compile.
The device according to claim 16, wherein the compilation acceleration plug-in further includes a local warehouse; the compilation unit is configured to: execute the dependency modification logic in the accelerated compilation logic, and obtain the dependency modification logic from the local warehouse. Query the compiled file corresponding to the unchanged code module; modify the changed code module in the module dependency graph to the compiled file to obtain a modified dependency graph.
The device according to claim 12, wherein the device further includes a packaging unit configured to: if the compilation of the modified code module is completed, package the compiled modified code module into modified code through the compilation acceleration plug-in. Module compilation file; store the changed code module compilation file in the local warehouse in the compilation acceleration plug-in.
A storage medium, wherein a computer program is stored thereon, and when the computer program is executed by a processor of a computer, the computer is caused to perform the method described in any one of claims 1 to 11.
An electronic device, which includes: a memory storing a computer program; and a processor reading the computer program stored in the memory to execute the method according to any one of claims 1 to 11.