WO2018072493A1

WO2018072493A1 - Compiling method and compiling system

Info

Publication number: WO2018072493A1
Application number: PCT/CN2017/093061
Authority: WO
Inventors: 王春锦
Original assignee: 宁德时代新能源科技股份有限公司
Priority date: 2016-10-17
Filing date: 2017-07-15
Publication date: 2018-04-26
Also published as: CN106325970A

Abstract

The present application provides a compiling method and a compiling system. The compiling method comprises: detecting in real time whether a source file is changed; and traversing, when it is determined that the source file is changed, dependent files corresponding to the source file by means of regular expression matching, so as to determine whether to recompile the source file. The technical solution of the present application facilitates automatically recompiling all files starting from the source file without a large number of manual operations, thereby improving software integration efficiency and reducing compiling costs.

Description

Compilation method and compilation system

Technical field

The present application relates to the field of background compilation technology, and in particular, to a compilation method and a compilation system.

Background technique

At present, with the rapid development of electric vehicles, the continuous improvement of BMS (Battery Management System) has made the development of BMS more and more complicated, and the complexity and cost of development have increased dramatically. For example, in AUTOSAR (Automotive Open System Architecture), the use of traditional software integration and compilation often faces problems such as low system efficiency, poor scalability, long development cycle, and many bugs.

Specifically, based on AUTOSAR-based BMS development, the software integration compilation implementation is done by the developer manually writing the source file script. This step is quite large, it takes a long time, and the developer technical requirements are very high. . Once new features are available, developers must re-edit the script and spend a lot of time debugging, seriously affecting development efficiency.

Therefore, how to improve the software integration efficiency in the BMS development process has become a technical problem that needs to be solved urgently.

Summary of the invention

The embodiment of the present application provides a compiling method and a compiling system, which aims to solve the problem that the software integration efficiency in the BMS development process in the related art is too low, and can improve the software integration efficiency and reduce the compiling cost.

In a first aspect, an embodiment of the present application provides a compiling method, including: detecting, in real time, whether a source file is changed; traversing a dependency file corresponding to the source file by a regular matching to determine whether to recompile the source file.

In the above embodiment of the present application, the dependent text corresponding to the source file is traversed by regular matching. The step of: further comprising: obtaining a current system environment; reconfiguring the compiled configuration information according to the current system environment, for using the compiled configuration information when recompilation is required; and saving the compiled configuration information In the configuration file.

In the foregoing embodiment of the present application, the step of detecting whether the source file is changed in real time includes: acquiring the detection parameter, where the detection parameter includes a timestamp of the source file, a hash value of the source file content, and the original compilation configuration information. And detecting one or more of the detection parameters; and detecting whether the detection parameter changes to determine a real-time change state of the source file.

In the foregoing embodiment of the present application, the number of the source files is multiple, and the step of traversing the dependent files corresponding to the source file by regular matching includes: performing a test process of concurrently recompiling multiple files for The file is recompiled based on the source state when the source file needs to be recompiled.

In the foregoing embodiment of the present application, the step of concurrently running a test process of recompiling multiple files specifically includes: initializing a plurality of worker threads; and using the plurality of worker threads to poll the request queue to process a request for file recompilation; The processing result is placed in the result queue; the result processing function is called to process the result queue.

In a second aspect, the embodiment of the present application provides a compiling system, including: a source file detecting unit, detecting whether a source file is changed in real time; and relying on a matching unit to traverse the dependent file corresponding to the source file by using a regular matching to determine whether Recompile the source file.

In the foregoing embodiment of the present application, the method further includes: an environment acquiring unit, acquiring a current system environment before the dependency matching unit traverses the dependent file corresponding to the source file; and configuring a unit to reconfigure the compiler according to the current system environment Configuration information for use in compiling configuration information when recompilation is required; and a saving unit to save the compiled configuration information in a configuration file.

In the above embodiment of the present application, the source file detecting unit is specifically configured to: acquire a detection parameter, where the detection parameter includes a time stamp of the source file, a hash value of the source file content, and one of the original compilation configuration information. Item or items, and detecting whether the detected parameter has changed to determine The real-time change status of the source file.

In the foregoing embodiment of the present application, the number of the source files is multiple, and the dependency matching unit is specifically configured to: concurrently run a test process of recompiling multiple files, so that the source file needs to be re-required The file is recompiled based on the source state at compile time.

In the foregoing embodiment of the present application, the dependency matching unit is specifically configured to: initialize a plurality of worker threads, use the plurality of worker threads to poll the request queue, process the request for recompiling the file, and place the processing result in the result queue. And call the result handler to process the result queue.

Through the above technical solution, for the problem that the software integration efficiency in the BMS development process in the related art is too low, when the source file is changed, the dependency file corresponding to the source file is traversed by the regular matching to determine whether the source code state needs to be automatically determined. Execution files are recompiled so that when it is determined that recompilation is required, automatic recompilation of all files from the source file can be achieved without a lot of manual operations, which improves software integration efficiency and reduces compilation costs.

DRAWINGS

In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings used in the embodiments will be briefly described below. It is obvious that the drawings in the following description are only some embodiments of the present application. One of ordinary skill in the art can also obtain other drawings based on these drawings without paying for inventive labor.

FIG. 1 shows a flow chart of a compiling method according to an embodiment of the present application;

2 shows a block diagram of a compilation system in accordance with one embodiment of the present application;

3 shows a logical architecture diagram of an Emake subsystem in accordance with one embodiment of the present application;

4 shows a schematic diagram of a thread pool work model in accordance with one embodiment of the present application.

detailed description

For a better understanding of the technical solutions of the present application, the embodiments of the present application are described in detail below with reference to the accompanying drawings.

It should be understood that the described embodiments are only a part of the embodiments of the present application, and not all of the embodiments. All other embodiments obtained by a person of ordinary skill in the art based on the embodiments of the present application without departing from the inventive scope are the scope of the present application.

The terms used in the embodiments of the present application are for the purpose of describing particular embodiments only, and are not intended to limit the application. The singular forms "a", "the", and "the"

FIG. 1 shows a flow chart of a compiling method in accordance with one embodiment of the present application.

As shown in FIG. 1 , the compiling method provided by the embodiment of the present application includes:

In step 102, it is detected in real time whether the source file has changed.

Step 104: When it is determined that the source file is changed, traversing the dependency file corresponding to the source file by regular matching to determine whether to recompile the source file.

In the above technical solution, when it is detected that the source file is changed, it is necessary to further determine whether to recompile the source file. Specifically, the dependency file corresponding to the source file needs to be traversed by regular matching to determine whether the source code is needed. The state automatically performs file recompilation, so that when it is determined that recompilation is required, automatic recompilation of all files from the source file can be achieved without a lot of manual operations, which improves software integration efficiency and reduces compilation costs.

In this embodiment, the execution subject is an Emake system. Emake is the back-end subsystem of ECS. It is a console program developed with eey4.11. The console application is designed without a graphical user interface and compiled into a separate executable. Console applications typically run from the command line while exchanging input and output information between command prompts and running applications. Because the information can be written to and read from the console window, this makes the console application a great way for ECS to introduce a continuously integrated server compilation, regardless of the user interface.

In the foregoing embodiment of the present application, before step 104, the method further includes: acquiring a current system environment; reconfiguring the compiled configuration information according to the current system environment, so that the compiled configuration information is used when recompilation is required; and the configuration information is compiled. Save in the configuration file.

In this embodiment, the execution body is an Emake system, and the Emake system needs to know the current system environment before starting work, such as where the standard library is, where the compiler is installed, which components need to be installed, etc., by specifying the configuration information. The Emake system can flexibly adapt to the environment and compile configuration information such as machine code that can be run in various environments. These compiled configuration information is stored in a configuration file called project.ini, which is generated by the ESB (Embedded System Build). The Emake system reads the configuration file to learn the compiled configuration information.

In addition, the project.ini configuration file can take into account the differences between different systems, and gives default values for various compilation configuration information. If the user's compilation environment is special, or there are some specific requirements, you can also manually project.ini Provide parameters.

In the foregoing embodiment of the present application, the step 102 includes: acquiring a detection parameter, where the detection parameter includes one or more of a time stamp of the source file, a hash value of the source file content, and original compilation configuration information; and detecting Check if the parameters have changed to determine the real-time status of the source file.

The Emake system can determine whether the file needs to be recompiled by the timestamp of the file. After the file version is rolled back or the compilation parameters are changed, the Emake system will not compile the file again.

In addition, in addition to using the timestamp of the file, it is also possible to use the hash value of the file content and the compilation parameter as the criterion for the incremental compilation, so that the accuracy of the incremental compilation is higher.

In the above embodiment of the present application, the number of source files is multiple, and step 104 specifically includes: concurrently running a test process of recompiling multiple files for being based on the source state when the source file needs to be recompiled. The file is recompiled.

Compiling the program and dependent libraries from the source state resolves compatibility issues caused by c or C++ programs due to compilation options, operating system platforms, or library file versions.

In the foregoing embodiment of the present application, the step of concurrently running a test process of recompiling multiple files specifically includes: initializing a plurality of worker threads; and using a plurality of worker threads to poll the request queue to process a request for file recompilation; The result is placed in the result queue; the result handler is called to process the result queue.

Among them, Emake system uses easy language Queue (queue) to achieve thread synchronization.

2 shows a block diagram of a compilation system in accordance with one embodiment of the present application.

As shown in FIG. 2, the compiling system 200 provided by the embodiment of the present application includes: a source file detecting unit 202 and a dependency matching unit 204.

The source file detecting unit 202 is configured to detect, in real time, whether the source file is changed. The dependency matching unit 204 is configured to: when determining that the source file is changed, traverse the dependent file corresponding to the source file by regular matching to determine whether The source file is recompiled.

In the above embodiment of the present application, the method further includes: the environment obtaining unit 206: acquiring the current system environment before the dependent matching unit traverses the dependent file corresponding to the source file; and the configuring unit 208, reconfiguring the compiled configuration information according to the current system environment. For compiling configuration information when recompilation is required; and saving unit 210, saving the compiled configuration information in the configuration file.

Before starting the work, the Emake system needs to know the current system environment, such as where the standard library is, where the compiler is installed, what components need to be installed, etc. By specifying the compilation configuration information, the Emake system can flexibly adapt to the environment and compile it. Compile configuration information such as machine code that can be run in various environments. These compilation configuration information is saved in a configuration file called project.ini Among them, it is generated by the ESB, and the Emake system learns the compiled configuration information by reading this configuration file.

In the foregoing embodiment of the present application, the source file detecting unit 202 is specifically configured to: acquire a detection parameter, where the detection parameter includes one or more of a time stamp of the source file, a hash value of the source file content, and original compilation configuration information. Item, and detecting whether the detection parameter has changed to determine the real-time change status of the source file.

In addition, in addition to using the timestamp of the file, ECS can also be based on the hash value of the file content and the compilation parameters as the criterion for incremental compilation, so that the accuracy of incremental compilation will be higher.

In the foregoing embodiment of the present application, the number of source files is multiple, and the dependency matching unit 204 is specifically configured to: concurrently run a test process of recompiling multiple files for re-compiling when the source file needs to be recompiled. The source state is recompiled in the file.

In the foregoing embodiment of the present application, the dependency matching unit 204 is specifically configured to: initialize a plurality of worker threads, use multiple worker threads to poll the request queue, process the request for file recompilation, and place the processing result in the result queue, and The result handler is called to process the result queue.

FIG. 3 shows a logical architecture diagram of an Emake subsystem in accordance with one embodiment of the present application.

As shown in Figure 3, the Emake subsystem is the back-end subsystem of ECS. It is a console program developed with eey4.11. The console application is designed to have no graphical user interface and compiled into a separate executable.

At the application layer, the console application usually runs from the command line of the console command processing set. After the request is accessed, the command and protocol of the request are parsed, and the function processing module is called to perform control scheduling such as service positioning and resource scheduling. Finally, using application logic for application processing, get the system System output, where the system output includes the output of the process log and the output of the result report.

The function processing module has the functions of compilation management, target generation management, static detection processing, concurrency control, packaging processing, and unit test processing, wherein the compiler management module is connected to the dependency engine.

In summary, at the application level, the console application typically runs from the command line of the console command processing set, while exchanging input and output information between the command prompt and the running application. Because the information can be written to and read from the console window, this makes the console application a great way for ECS to introduce a continuously integrated server compilation, regardless of the user interface.

Among them, the memory processing mechanism of the Emake subsystem is summarized as follows:

The memory processing mechanism of the Emake subsystem uses an efficient, flexible, cross-platform memory pool implementation, in which memory is divided into nodes and slices, node is a large chunk of memory, and slice is a small piece on node. Memory, every memory requested from the memory pool belongs to a slice. The size of the slice in each memory pool instance is the same, so this memory pool is more like an object pool. Based on this memory pool, a more flexible memory pool from which different sizes of memory can be applied can be realized.

Specifically, the available nodes are linked into a linked list, and the available slices are also linked into a linked list. When requesting memory from the memory pool, first check if there is a free slice, if there is, then take one, if not, check if there are any unused tiles in the recently applied node.

If there is a slice in the recently applied node that has never been used, then take one. If not, add the node to the head of the node list, apply for a new node, and take a slice from it and return. Thus, when freeing up memory, you only need to insert the slice into the free slice list header.

The above memory pools are organized into a tree structure. When creating a memory pool, you can specify a parent memory pool for it, and use the pointer of the parent memory pool as the first parameter when calling elr_mpl_create (create function).

When a memory pool that is a parent memory pool is destroyed, its child memory pool is also destroyed. Place Therefore, when a memory pool as a parent memory pool and its child memory pool are no longer used, it is not necessary to destroy all the memory pools one by one, and only destroy the interface for the parent memory pool.

If you do not specify a parent memory pool when you create a memory pool, then a global memory pool is its parent memory pool. This global memory pool is created the first time you call elr_mpl_init (initialize the memory pool function), and the memory space occupied by all memory pool structures comes from this global memory pool. This global memory pool was destroyed the last time the elr_mpl_finalize (terminating function) memory pool was called. At the same time, it can be seen that all the memory pool instances are direct or indirect sub-memory pools of this global memory pool, then when the elr_mpl_finalize is called, all the memory pool instances will also be destroyed, thus the possibility of leaking memory. Dropped to a minimum.

The memory pool of the Emake subsystem also supports multithreading. If you need to use it in a multithreaded environment, you need to implement six interfaces and define the easy language constant ELR_USE_THREAD at compile time.

In the process of logic processing such as file processing, nested traversal processing, and log processing in the Emake subsystem, each interface may cross-use and modify resource data, which easily leads to concurrency problems, if for each resource. To consider how to ensure concurrent security issues, the entire analysis process becomes complicated, and complex logic is often overlooked.

The thread pool model shown in Figure 4 is used to shield the concurrency problem of a single compilation, that is, the compile thread does not need to consider its concurrent security problem when accessing its own resources (multiple compile access resources still need to be processed), specifically You can sort the compiled requests and call the threads in the thread pool in turn.

The thread pool model includes the following sections:

1, thread pool manager (ThreadPool), used to start, increase, disable, manage the thread pool.

2. The worker thread (WorkThread), which is a thread in the thread pool, can place the execution result into the result queue.

3, the request interface (WorkRequest), not shown in the figure, used to create the request object, For the worker thread to schedule the execution of the task.

4. A request queue (RequestQueue) for storing and extracting requests, and the thread pool manager adds a request to the request queue.

5. The result queue (ResultQueue) is used to store the result of the request execution, and the thread pool manager can obtain the execution result from the result queue.

The thread pool manager adds requests to the request queue by adding a request (putRequest). These requests need to implement the request interface by passing work functions, parameters, result handlers, and exception handlers, and then initialize a certain number of worker threads. These worker threads continuously look at the request queue by polling, and as long as a request exists, the request is fetched and executed.

Then, the thread pool manager calls the method (poll) to see if the result queue has a value. If there is a value, it is fetched and the result processing function is called.

According to the foregoing technical solution, the core resources of the Emake subsystem are the request queue and the result queue, and the worker thread obtains the task by polling the request queue, and the main thread obtains the execution result by viewing the result queue.

Therefore, queue design requires thread synchronization, certain blocking, and timeout mechanisms to prevent excessive CPU (Central Processing Unit) overhead due to constant polling.

In addition, the Emake subsystem needs to know the current system environment before starting work, such as where the standard library is, where the compiler is installed, which components need to be installed, etc. By specifying the compilation configuration information, the Emake subsystem can be flexibly adapted. The environment compiles configuration information such as machine code that can be run in various environments. These compiled configuration information is stored in a configuration file called proiect.ini, which is generated by the ESB. The Emake subsystem reads the configuration file to learn the compiled configuration information.

Further, the location of the standard library and header files needs to be determined.

The standard library and headers used by the source code can be stored in any directory on the system. The Emake subsystem can know the location of the standard library and header files from the configuration file. In general, the configuration file will give a list of several specific directories. When compiling, the compiler will go to these directories in order to find the target.

Further, the dependent file of the source file needs to be determined. In other words, the dependency relationship between the source files needs to be obtained, and the compiler can determine the order of compilation by the dependencies between the source files. Assuming the A file depends on the B file, the Emake subsystem should guarantee the following two points:

(1) The A file is only compiled after the B file is compiled.

(2) When the B file changes, the A file will be recompiled.

Dependencies are stored in a file called .d, which lists the dependencies of the source files. While determining the dependencies, the Emake subsystem also determines which header files are used at compile time.

Next, you need to precompile the header files.

Specifically, different source files may reference the same header file (such as stdio.h). When compiling, the header files must also be compiled together. Therefore, in order to save time, the Emake subsystem will compile the header file before compiling the source code, which ensures that the header file only needs to be compiled once.

However, not all of the contents of the header file are precompiled, and the #define command used to declare the macro will not be precompiled.

After the precompilation is complete, the compiler begins to replace the bash header files and macros in the source code.

Inserting the source code is the result of precompilation, and the compiler will remove the comment in this step.

This step is called pre-processing. After the pre-processing is completed, the Emake subsystem starts to generate machine code. For some compilers, there is an intermediate step, that is, first convert the source code into the assembly code, and then transfer the assembly code. For the machine code.

The transcoded file is called an object file. The object file cannot be run yet and must be further converted into an executable file. For the program to run properly, you must also have the code for the two functions stdout and fwrite, which are provided by the standard library of the C language.

The next step in the Emake subsystem is to put the code of the external function (usually the suffix name). Add the .1ib and .a files to the executable, the linking step, which is a way to add an external library to the executable by copying it, called static linking.

The technical solution of the present application is described in detail above with reference to the accompanying drawings. When the source file is changed, the dependency file corresponding to the source file needs to be traversed by regular matching to determine whether the file needs to be automatically executed based on the source code status. Recompile, so that when it is determined that recompilation is required, automatic recompilation of all files from the source file can be achieved without a lot of manual operations, which improves software integration efficiency and reduces compilation costs.

Depending on the context, the word "if" as used herein may be interpreted as "when" or "when" or "in response to a determination" or "in response to Detection". Similarly, depending on the context, the phrase "if determined" or "if detected (conditions or events stated)" may be interpreted as "when determined" or "in response to determination" or "when detected (stated condition or event) "Time" or "in response to a test (condition or event stated)".

In the several embodiments provided by the present application, it should be understood that the disclosed systems, devices, and methods may be implemented in other manners. For example, the device embodiments described above are merely illustrative. For example, the division of the unit is only a logical function division. In actual implementation, there may be another division manner. For example, multiple units or components may be combined. Or it can be integrated into another system, or some features can be ignored or not executed. In addition, the mutual coupling or direct coupling or communication connection shown or discussed may be an indirect coupling or communication connection through some interface, device or unit, and may be in an electrical, mechanical or other form.

In addition, each functional unit in each embodiment of the present application may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit. The above integrated unit can be implemented in the form of hardware or in the form of hardware plus software functional units.

The above-described integrated unit implemented in the form of a software functional unit can be stored in a computer readable storage medium. The above software functional unit is stored in a storage medium, including several fingers Some steps of a method for causing a computer device (which may be a personal computer, a server, or a network device, etc.) or a processor to perform the methods described in various embodiments of the present application. The foregoing storage medium includes: a U disk, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk, and the like, which can store program codes. .

The above is only the preferred embodiment of the present application, and is not intended to limit the present application. Any modifications, equivalent substitutions, improvements, etc., which are made within the spirit and principles of the present application, should be included in the present application. Within the scope of protection.

Claims

A compiling method, comprising:

Real-time detection of whether the source file has changed;

When it is determined that the source file is changed, the dependency file corresponding to the source file is traversed by regular matching to determine whether to recompile the source file.
The compiling method according to claim 1, wherein before the step of traversing the dependent file corresponding to the source file by regular matching, the method further comprises:

Get the current system environment;

Reconfiguring the compiled configuration information for use in the need to recompile the compiled configuration information according to the current system environment;

The compiled configuration information is saved in a configuration file.
The compiling method according to claim 2, wherein the step of detecting whether the source file is changed in real time comprises:

Obtaining a detection parameter, where the detection parameter includes one or more of a time stamp of the source file, a hash value of the source file content, and the original compilation configuration information;

A determination is made as to whether the detected parameter has changed to determine a real-time change status of the source file.
The compiling method according to any one of claims 1 to 3, wherein the number of the source files is plural, and

The step of traversing the dependency file corresponding to the source file by using a regular match includes:

A test process that runs multiple file recompilations concurrently for file recompilation based on source state when a recompilation of the source file is required.
The compiling method according to claim 4, wherein the step of concurrently running the test process of recompiling the plurality of files comprises:

Initialize multiple worker threads;

Using the plurality of worker threads to poll the request queue to process a request for file recompilation;

Place the processing result in the result queue;

The result handler is called to process the result queue.
A compilation system, comprising:

The source file detecting unit detects whether the source file has changed in real time;

Relying on the matching unit, when it is determined that the source file is changed, traversing the dependency file corresponding to the source file by regular matching to determine whether to recompile the source file.
The compiling system according to claim 6, further comprising:

The environment obtaining unit acquires a current system environment before the dependency matching unit traverses the dependent file corresponding to the source file;

a configuration unit that reconfigures the compiled configuration information for use in the need to recompile the compiled configuration information according to the current system environment;

The saving unit saves the compiled configuration information in a configuration file.
The compiling system according to claim 7, wherein the source file detecting unit is specifically configured to:

Obtaining a detection parameter, where the detection parameter includes one or more of a time stamp of the source file, a hash value of the source file content, and the original compilation configuration information, and detecting whether the detection parameter changes to determine The real-time change status of the source file.
The compiling system according to any one of claims 6 to 8, wherein the number of the source files is plural, and

The dependency matching unit is specifically configured to:

A test process that runs multiple file recompilations concurrently for file recompilation based on source state when a recompilation of the source file is required.
The compiling system according to any one of claims 6 to 8, wherein the dependency matching unit is specifically configured to:

Initializing a plurality of worker threads, using the plurality of worker threads to poll the request queue to process the file recompilation request, placing the processing result in the result queue, and calling the result processing function to process the result queue.