CN113608742A

CN113608742A - Detection method, code packet processing method, operation control method and computing device

Info

Publication number: CN113608742A
Application number: CN202110773402.5A
Authority: CN
Inventors: 朱凯迪
Original assignee: Alibaba Singapore Holdings Pte Ltd
Current assignee: Alibaba Innovation Co
Priority date: 2021-07-08
Filing date: 2021-07-08
Publication date: 2021-11-05

Abstract

The embodiment of the application provides a detection method, a code packet processing method, an operation control method and a computing device, wherein a target program is operated, and a module identifier of a second module, which is requested to be loaded by a first module of the target program, is detected; determining a second file path of the second module according to the addressing result of the module identifier; establishing a corresponding relation among a first file path, a second file path and the module identifier of the first module, and storing the corresponding relation to a target file of the target program; the target file is used for searching the target file based on the first file path and the module identifier to determine the corresponding second file path under the condition that the first module requests to load the second module. Based on the second file path, the file source code can be obtained and compiled and executed, and the technical scheme provided by the embodiment of the application improves the program running speed.

Description

Detection method, code packet processing method, operation control method and computing device

Technical Field

The embodiment of the application relates to the technical field of computers, in particular to a detection method, a code packet processing method, an operation control method and computing equipment.

Background

How to optimize the program running speed is one of the technical problems that the skilled person needs to solve.

However, in the process of implementing the present invention, the inventor finds that a program developed or run by a Runtime system (Runtime system), such as a java program developed or run by a java Runtime environment, a JavaScript program developed or run by a node.js (node.javascript, a JavaScript Runtime environment), and the like, often involves mutual invocation between modules, that is, a module requests another module to be loaded to introduce and use another module.

Modules are used to provide corresponding functionality as a basic component of a program. Module loading mainly comprises the following operations: firstly, addressing is carried out based on the module identification of the module requesting for loading, whether the module requesting for loading exists or not is searched, and the absolute path of the module requesting for loading is determined; then, searching a cache based on the absolute path to determine whether the module is loaded, if so, reading the stored file source code from the cache, otherwise, reading the file source code from the position of the absolute path index file and storing the file source code to the cache; and finally, compiling and executing the file source code to finish module loading.

Because module loading needs to go through operations of addressing, looking up cache, compiling and executing, the inventor finds that the operations take longer time and are one of the reasons for influencing the running speed of the program.

Disclosure of Invention

The embodiment of the application provides a detection method, a code packet processing method, an operation control method and computing equipment, which are used for solving the technical problem that the operation speed of a program is influenced in the prior art.

In a first aspect, an embodiment of the present application provides a detection method, including:

determining a second file path of the second module according to the addressing result of the module identifier;

establishing a corresponding relation among a first file path, a second file path and the module identifier of the first module, and storing the corresponding relation to a target file of the target program;

the target file is used for searching the target file based on the first file path and the module identifier to determine the corresponding second file path under the condition that the first module requests to load the second module.

In a second aspect, an embodiment of the present application provides a method for processing a code packet, including:

acquiring an initial code packet of a target program;

executing the code packet to run the target program, and detecting a module identifier of a second module, which is requested to be loaded by a first module of the target program;

and updating the code package according to the target file.

In a third aspect, an embodiment of the present application provides an operation control method, including:

under the condition that a first module of a target program requests to load a second module, determining a module identifier of the second module and a first file path of the first module;

searching a corresponding second file path from a target file according to the module identifier and the first file path; the target file stores the corresponding relation of the first file path, the module identification and the second file path; the second file path is obtained by addressing in advance;

acquiring a file source code according to the second file path;

compiling and executing the file source code.

In a fourth aspect, embodiments of the present application provide a computing device, comprising a processing component and a storage component;

the storage component stores one or more computer instructions; the one or more computer instructions are adapted to be invoked and executed by the processing component to implement the detection method according to the first aspect, or to implement the code processing method according to the second aspect, or to implement the operation control method according to the third aspect.

In the embodiment of the application, a target program is operated, a module identifier of a second module, which is requested to be loaded by a first module in the target program, is detected, and a second file path of the second module is obtained according to an addressing result of the module identifier; then establishing a corresponding relation among a first file path of a first module, the second file path and the module identifier, and storing the corresponding relation into a target file of the target program; therefore, when the first module in the target program requests to load the second module, the target file can be searched first, the second file path of the second module is determined from the corresponding relation stored in the target file, the file source code can be obtained based on the second file path and compiled and executed, and by storing the corresponding relation in the target file, the file path can be determined and the file source code can be obtained without performing addressing operation when the target program runs, so that the module addressing time is optimized, the running speed of the target program can be improved, only the corresponding relation hit when the target program runs is stored, and the storage capacity of the target file can be reduced.

These and other aspects of the present application will be more readily apparent from the following description of the embodiments.

Drawings

In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the drawings needed to be used in the description of the embodiments or the prior art will be briefly described below, and it is obvious that the drawings in the following description are some embodiments of the present application, and other drawings can be obtained by those skilled in the art without creative efforts.

FIG. 1 is a flow chart illustrating one embodiment of a detection method provided herein;

FIG. 2 is a signaling diagram illustrating yet another embodiment of a detection method provided herein;

FIG. 3 is a flow diagram illustrating one embodiment of a method for processing code packets provided herein;

FIG. 4 is a flow chart illustrating one embodiment of an operation control method provided herein;

FIG. 5 is a schematic diagram illustrating an application scene interaction in a practical application according to an embodiment of the present application;

FIG. 6 is a schematic diagram illustrating an embodiment of a detection device provided herein;

FIG. 7 illustrates a schematic structural diagram of one embodiment of a computing device provided herein;

FIG. 8 is a block diagram illustrating an embodiment of a code packet processing apparatus provided herein;

FIG. 9 illustrates a schematic structural diagram of yet another embodiment of a computing device provided herein;

FIG. 10 is a schematic diagram illustrating an embodiment of an operation control apparatus provided in the present application;

FIG. 11 is a block diagram illustrating an embodiment of an object program provided herein;

fig. 12 is a schematic structural diagram illustrating a further embodiment of a computing device provided by the present application.

Detailed Description

In order to make the technical solutions better understood by those skilled in the art, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application.

In some of the flows described in the specification and claims of this application and in the above-described figures, a number of operations are included that occur in a particular order, but it should be clearly understood that these operations may be performed out of order or in parallel as they occur herein, the number of operations, e.g., 101, 102, etc., merely being used to distinguish between various operations, and the number itself does not represent any order of performance. Additionally, the flows may include more or fewer operations, and the operations may be performed sequentially or in parallel. It should be noted that, the descriptions of "first", "second", etc. in this document are used for distinguishing different messages, devices, modules, etc., and do not represent a sequential order, nor limit the types of "first" and "second" to be different.

The technical scheme of the embodiment of the application can be applied to programs developed or operated by a runtime system, and is applied to a use scene that one module requests to load another module.

To facilitate understanding of the technical solutions of the present application, the following first explains technical terms that may be involved in the embodiments of the present application:

runtime system (Runtime system): the Runtime system encapsulates the resource interface of the operating system downward, provides Runtime support of the programming framework upward, and performs program development or Runtime by first installing the Runtime system, which includes, for example, a common Java Runtime environment, node.

Js: a JavaScript execution environment based on a Chrome V8 (also referred to as V8 for short, an open source JavaScript engine) engine.

A module: basic components of the program for providing corresponding functions. In node.js, a module refers to a node.js file, which may be JavaScript code, JSON, or a compiled C/C + + extension.

A core module: the official supply module is arranged in the runtime system, and the core module is loaded by directly using the module name.

A file module: the system comprises a user-defined module and a third-party module provided by a third party. The user-defined module loads by using a path, wherein the path can be a file absolute path or a file relative path based on the current module, and is usually a character string starting with "/", "/" or "./", the file absolute path starts with "/", and the file relative path starts with "./" or "./", wherein "/" denotes an upper directory and "./" denotes an upper directory; the third-party module is provided by a third party and needs to be downloaded and installed. In node.js, for example, an NPM (node package manager node) manages a third-party module, and the third-party module downloads and installs the third-party module in the node _ modules (folder for storing packages downloaded and installed by the package manager tool). And the third-party module loads by using the module name, firstly searching whether the module exists in the node _ modules directory of the current file directory during loading, if not, continuously searching from the node _ modules directory of the superior directory of the current file directory, and if not, continuously searching from the superior file directory until the corresponding module is found or the root directory is reached.

required (): js to introduce and use one module in another.

As can be seen from the description of the background art, when a module is loaded, operations of addressing, searching for a cache, compiling, and executing need to be performed, which takes a long time, and thus affects the running speed of the program. How to optimize the module loading process is called to solve the main technical problem of the program running speed. The inventor researches in the process of implementing the application to discover that although a native cache mechanism caches a file source code loaded by a module, the file source code is not necessarily read again each time, each module loading still needs to address first to determine an absolute path of a module to be loaded, so that the module can be searched in the cache based on the absolute path, and therefore, one reason that the module loading takes a long time is that the addressing time is long, particularly for the loading of a third-party module, the module needs to be searched and judged whether the module exists or not from different directories in a recursion manner continuously, and each judgment on whether the module exists or not needs to be called by a kernel of an operating system, so that the time consumed for one module loading is long.

The inventors have further found that when loading one module with another, such as for requesting loading of a C-module in the a-module and loading of a C-module in the B-module, the absolute paths of the C-modules resulting from the final addressing are different.

Accordingly, through a series of researches, the technical scheme of the application is provided, and in the embodiment of the application, the target program is operated to detect the module identifier of the second module, which is requested to be loaded by the first module in the target program; according to the addressing result corresponding to the module identification, a second file path of a second module can be determined; establishing a corresponding relation of a first file path, a second file path and a module identifier of a first module, and storing the corresponding relation into a target file of a target program; therefore, in the running process of the object program, when the first module requests to load the second module, the object file can be searched to determine the corresponding second file path based on the first file path of the first module and the module identifier of the second module, the file source code can be obtained and compiled for execution based on the second file path, therefore, the second file path of the second module can be obtained without addressing, the file source code can be obtained and compiled and executed based on the second file path, the file path can be determined without executing addressing operation when the target program runs by storing the corresponding relation in the target file, the module addressing time is optimized, the running speed of the target program can be improved, the corresponding relation is obtained by running the target program, only the corresponding relation hit by program running can be saved, and the storage capacity of the target file is reduced.

The technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application, and it is obvious that the described embodiments are only a part of the embodiments of the present application, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present application.

Fig. 1 is a flowchart of an embodiment of a detection method provided in an embodiment of the present application, where the method may include the following steps:

101: and detecting the module identification of the second module which is requested to be loaded by the first module of the target program.

The first module may refer to any one of the target programs, and any one of the modules requesting to load the module may be executed according to the technical solution of the present application.

Optionally, in practical application, the requirement on the program starting speed is often high, and the technical scheme of the present application may be specifically used for optimizing the program starting speed, so that the first module may refer to any one module operated in the target program starting stage.

The target program may refer to a program developed and run depending on a runtime system, which may refer to a client program or a server program, and the like.

The identity of the module that the first module requests to load may be determined from the request parameters of the load function that the first module calls. The module identification may include a module name, a file absolute path, or a file relative path.

The module identification which is determined to be requested to be loaded by the first module in the target program can be determined by analyzing the code packet of the target program.

In addition, since not all modules are loaded during the running of the object program, optionally, the object program may be run, and the module identifier requested to be loaded by the first module is obtained by detecting the module loading operation involved in the running process of the object program, so that only the module that needs to be loaded during the running of the object program may be processed, and the storage capacity of the object file may be reduced. Therefore, optionally, the module identification of the second module that the first module of the detection target program requests to load may be:

and running the target program, and detecting the module identification of the second module, which is requested to be loaded by the first module of the target program.

The technical solution of this embodiment may be executed when the target program is executed in an actual execution environment, specifically, the target program may be executed when the target program is executed in the actual execution environment for the first time, and the actual execution environment may refer to an online environment after the target program is released. Of course, the technical solution of this embodiment may also be executed in a case where the target program is run in advance in the simulation running environment, and the simulation running environment may be a pre-launch environment, a test environment, and the like which are separately built or are the target program.

102: and determining a second file path of a second module according to the addressing result of the module identifier.

In the native module loading operation, the addressing operation is executed based on the module identifier to obtain the addressing result of the module identifier, so that the second file path of the second module corresponding to the module identifier can be determined according to the addressing result of the module identifier. The second module is the module which the first module requests to load, and the first module is the current module relative to the second module.

103: and establishing a corresponding relation among a first file path, a second file path and a module identifier of the first module, and storing the corresponding relation to a target file of the target program.

The module loading is performed in the first module, so that the first file path of the first module can be determined, and after the second file path is obtained, the first file path, the second file path and the module identifier can be correspondingly stored in the target folder.

The correspondence may be expressed as follows: and requesting the loading module to identify the loading result of the corresponding module as a second file path in the first file path. So that the second file path can be uniquely determined by the module identification and the first file path.

The target file is used for searching the target file based on the first file path and the module identifier of the second module to determine the corresponding second file path under the condition that the first module in the target program requests to load the second module. Therefore, the file source code can be obtained based on the second file path, and the loading of the execution completion module is compiled.

The target file is loaded firstly when the target program is started, so that the file path of the module requesting to be loaded is only required to be inquired from the target file every time the module is loaded, the file path of the module requesting to be loaded can be determined without addressing operation, the module loading time can be saved, and the program running speed is improved.

In addition, the inventor further finds that, since each reading of the source code of the file also takes a long time, in order to reduce IO (Input/Output) operations for reading the file, as another embodiment, the method may further include:

acquiring a file source code corresponding to the second module;

and saving the file source code to the target file corresponding to the second file path.

The target file is further used for obtaining the correspondingly stored file source code according to the second file path after the second file path is determined from the target file, so that the file source code does not need to be read from the file storage position, and the IO operation of the reading file can be reduced.

The file reading times in the running process of the target program can be reduced by saving the file source code, so that the time consumption is further reduced, and the running speed of the target program is improved.

In addition, since the file source code needs to be compiled and executed, in order to further increase the program running speed, in some embodiments, after the file source code is acquired based on the second file path, the method may further include:

acquiring Byte codes (Byte-codes) generated by compiling file source codes;

saving the byte code to a target file corresponding to the second file path; the target file is also used for acquiring the corresponding saved byte codes according to the second file path.

The source code of the file is also the source code of the second module; the byte code is obtained by compiling the source code by using a compiler, and is a binary code of an intermediate state.

The byte codes generated by compiling the source codes of the files are stored in the target file, so that when the target program runs, the source codes and the corresponding byte codes can be obtained from the target file, and the source codes and the byte codes are analyzed into machine codes based on the source codes, thereby saving the compiling time of compiling the source codes into the byte codes and further improving the running speed of the program.

Alternatively, a stateless bytecode generated by compiling a file source code may be saved to a target file, where the stateless bytecode specifically refers to a method (i.e., a function) in the bytecode being a stateless method.

In the embodiment of the application, the module loading process in the target program can be analyzed, the second file path of the second module requested to be loaded by the first module in the target program can be determined according to the addressing result, and the corresponding file source code can be read, and the file source code can be compiled into byte codes, so as to construct the corresponding relation of the first file path, the module identification and the second file path, and generate a target file based on the corresponding relation, the file source code and the byte code of the second module, and the target file is saved in the target program, so that when the target program carries out module loading each time, the target file may be queried first, looking up the second file path for the second module requested to be loaded, and furthermore, the second file path can be determined without addressing, so that the module loading time is saved, and the program running speed is favorably improved.

In an alternative implementation manner, the first file path and the second file path may refer to an absolute file path of the corresponding module.

In practical applications, multiple backups may exist for the same file, and some modules are independent from the file system of the target program, so that the directory structure is complex, for example, a certain file is located in/code/app.js, or may be located in/runtime/code/app.js, and absolute paths of files obtained when different files are loaded may be different. In addition, the directory structure of the target program running on different machines may also change, for example, the app. js file may be located at/home/admin/release/lib/app. js on machine 1, and may be located at/home/bdmin/release/lib/app. js on machine 2, and the directory entry changes.

In summary, if the file path is in an absolute path form, an error may occur, and the file path of the second module cannot be obtained from the target file.

Therefore, in the case that the directory structure is complex or changed, in some embodiments, a matching relationship between the directory identifier and the file directory entry may be preconfigured, and in the case that the file directory entry is changed, the matching relationship is updated correspondingly, and the method may further include:

determining a first absolute path of a first module;

replacing a first file directory entry in the first absolute path with a corresponding first directory identifier according to the matching relationship between the file directory entry and the directory identifier, and obtaining a first file path based on the first directory identifier;

if the module identifier is a file absolute path, replacing a third file directory entry in the file absolute path with a corresponding third directory identifier according to the matching relation so as to update the module identifier;

determining a second file path of a corresponding second module according to the addressing result of the module identifier includes:

obtaining a second absolute path of a corresponding second module according to the addressing result of the module identifier;

replacing a second file directory entry in the second absolute path with a corresponding second directory identifier according to the matching relation, and obtaining a second file path based on the second directory identifier;

the first absolute path is a file absolute path of the first module, the second absolute path is a file absolute path of the second module, and the first absolute path and the second absolute path are named for descriptive distinction.

Through path conversion, the method in the embodiment of the present application may adopt conversion from an absolute path of a file to a relative path based on directory identification. If the module identification is the absolute path of the file, the module identification is correspondingly updated to be the relative path based on the directory identification.

To facilitate understanding of the path conversion relationship, it is now exemplified that, in a case where the directory structure is complex, for example, a b.js file is located in/root/code/b.js, and is also located in/root/code/c/b.js, then the directory identifier corresponding to the directory item "/root/code/" may be defined as "entry 2", for example, then the/root/code/b.js may be represented as/entry 2/b.js, and the directory identifier corresponding to the "/root/code/c/" may be defined as "entry 3", and then the/root/code/c/b.js may be represented as/entry 3/b.js.

Under the condition of the change of the directory structure on different machines, a first file is taken as an example, for example, a target program runs on the machine 1, and the absolute path of the first file on the machine 1 is "/home/admin/release/lib/app.js"; if the directory entry "/home/admin/release/" corresponds to the directory identifier "entry 1", the first file path is "entry/lib/app. js", and if the target program runs on the machine 2, the directory entry "/home/admin/release/" is updated to "/home/bdmin/release/", the directory entry corresponding to the directory identifier "entry 1" in the matching relationship is updated to "/home/bdmin/release/", and the absolute path of the first file on the machine 2 is "/home/bdmin/release/lib/app. js". The absolute path of the file is also converted according to the module identification as the absolute path of the file and the absolute path of the file of the second file in the addressing result.

The first file path, the second file path and the module identification are all represented by relative paths based on the directory identification, and in the running process of the target program, when the target file is inquired, the corresponding file paths are also converted into the representation of the relative paths based on the directory identification for inquiry, so that the problem of inquiry error caused by inconsistent paths under the condition of complex directory structures or changed directory structures can be solved.

As can be seen from the foregoing description, determining that the module identifier requested to be loaded by the first module in the target program is obtained by detection when the target program runs, and thus, in some embodiments, the running the target program, detecting that the module identifier requested to be loaded by the first module in the target program may include:

running a target program and starting a detection mode;

in a detection mode, detecting a module identifier which is requested to be loaded by a first module in a target program;

the method further comprises the following steps:

when a termination event is detected, the detection mode is ended.

The termination event may be set in combination with an actual application, for example, in a case where the target program start speed needs to be increased, the termination event may be generated by detecting that the target program is initialized. Or, a detection duration may be set, and a termination event may be generated when the running duration of the target program reaches the detection duration, where the detection duration may be made, for example, by combining the start duration of the current target program, so that the target file stores the corresponding relationship, the corresponding code file, and the like corresponding to the module that needs to be loaded at the start stage of the target program.

After the detection mode is finished, the module loading process in the target program is not detected any more.

The detection method of the embodiment of the present application may be executed when the target program is run for the first time in an actual running environment, specifically, the detection method may be executed by a detection program independent from the target program on a machine on which the target program is run, or certainly, the detection method may also be executed by the target program. When the target program is operated for the first time, the native module loading operation, namely, the operations of addressing, searching for cache, compiling, executing and the like, can be executed according to a native mode, and when the target program is operated again and the module loading is required to be carried out, the target file can be firstly inquired, and the native module loading operation can be executed again under the condition that the target file is not hit.

Of course, in order to better guarantee the running speed of the target program, the target program can be run in the simulation running environment to generate the target file before the target program is released in the actual running environment. In some embodiments, the operation of running the object program and generating the object file may be performed by a file generation end, and the code of the object program may be submitted to the file generation end after the code is constructed, and the file generation end generates the object file, so that the operation of running the object program and detecting the module identifier of the second module, which is requested to be loaded by the first module in the object program, may include:

acquiring an initial code packet of a target program from a code construction end;

executing the code packet to run the target program, and detecting a module identifier of a second module which is requested to be loaded by a first module in the target program;

the method may further comprise:

and transmitting the target file to a code construction end so that the code construction end can add the target file to a code package of the target program.

For ease of understanding, as shown in fig. 2, a signaling flow diagram of another embodiment of a detection method provided in an embodiment of the present application is shown, where the method may include the following steps:

201: and the code building end sends the built code package of the target program to the file generating end.

202: and the file generation end executes the code packet to run the target program.

The file generation end can build a simulation operation environment of the target program and operate the target program in the simulation operation environment.

203: the file generation end determines a module identification of a second module which is requested to be loaded by a first module in the target program, an addressing result based on the module identification, a source code of the second module obtained according to the addressing result, and a byte code generated by compiling the source code.

By detecting the loading operation of the native module in the running process of the target program, the module identification, the addressing result, the source code and the byte code generated by compiling the source code related to the module loading process can be obtained and recorded. Of course, the bytecode can also be compiled after the source code is obtained.

The file generation side may execute the detection method in this embodiment by a detection program independent from the target program.

204: and the file generating end determines a second file path according to the addressing result and establishes a corresponding relation between the first file path and the second file path of the first module and the module identifier.

205: and the file generating end generates a target file according to the corresponding relation, the source code and the byte code of the second module.

206: and the file generation end provides the target file to the code construction end.

The file generating end can immediately feed back the target file to the code constructing end after generating the target file, or the code constructing end can request to obtain the target file and the like from the file server end in a polling mode, and the file server end feeds back the target file after receiving the request of the code constructing end.

207: and the code building end writes the target file into a code package of the target program so as to update the code package.

The updated code package can be released.

In addition, the update operation of the code package may also be completed by a code building end or a separate processing end, such as a file generating end, so as to be described in fig. 3, an embodiment of the present application further provides a code package processing method, which may include the following steps:

301: and acquiring an initial code packet of the target program.

302: and executing the code packet to run the target program, and detecting the module identification of the second module which is requested to be loaded by the first module of the target program.

303: and determining a second file path of a second module according to the addressing result of the module identifier.

304: and establishing a corresponding relation among a first file path, a second file path and a module identifier of the first module, and storing the corresponding relation to the target file of the target program.

305: and updating the code package according to the target file.

In some embodiments, the obtaining of the initial code package of the target program may specifically be obtaining the initial code package of the target program from a code building end.

In practical application, the updating of the code package according to the target file may be realized by transmitting the target file to the code building end, and writing the target file into the code package by the code building end to update the code package.

The same or similar operations in the embodiment shown in fig. 3 as those in any of the above embodiments can be detailed as described above, and are not repeated herein.

Fig. 4 is a flowchart of an embodiment of an operation control method provided in the embodiment of the present application, where the embodiment introduces the technical solution of the present application from the viewpoint of program operation, and the technical solution of the embodiment may be executed by a target program, and the method may include the following steps:

401: and under the condition that a first module of the target program requests to load a second module, determining a module identifier of the second module and a first file path of the first module.

402: and searching a corresponding second file path from the target file according to the module identifier and the first file path.

Alternatively, the target program may first load the target file into the currently running machine, so that the target file only needs to be loaded once, and the subsequent module loading operation may first perform an operation of searching for the target file.

The target file stores the corresponding relation of the first file path, the module identification and the second file path; the second file path is obtained by pre-addressing.

The file content in the target file can be obtained by analyzing a code package of the target program, and is generated by analyzing and processing the calling relationship among modules involved in the code package.

Of course, the generation may also be performed during the running process of the target program, and the specific generation manner may be described in detail in the foregoing corresponding embodiment, which is not described repeatedly herein.

Optionally, the module loading operation related to any stage of the target program running may be executed according to the technical scheme of this embodiment, or the module loading operation related to the target program starting stage may be executed according to the technical scheme of this embodiment, before step 402, the running stage of the target program may be determined first, and if the target program is in the starting stage, the operation of step 402 may be executed, and if the target program is in the non-starting stage, the native module loading operation may also be executed.

403: and acquiring the file source code according to the second file path.

404: the file source code is compiled and executed.

In addition, in some embodiments, if the second file path is obtained from the target file without searching according to the module identifier and the first file path, the method may further include:

a native module load operation is performed based on the module identification. The native module loading operation may include addressing, looking up a cache, compiling, and executing.

As an alternative, obtaining the file source code according to the second file path may include: and reading the file source code from the file position of the second file path index.

Of course, the cache may also be searched based on the second file path, if the second module is loaded in the cache, the corresponding file source code may be directly obtained, otherwise, the file source code may be read from the file position indexed by the second file path.

If the second file path is a relative path based on the directory identifier, the second file path may be first converted into an absolute file path, and then an operation of searching for a cache or reading a file may be performed.

As another optional mode, the target file may further pre-store a file source code corresponding to the second file path, and therefore, obtaining the file source code according to the second file path may be: and searching a file source code corresponding to the second file path from the target file.

In some embodiments, the method may further comprise:

and searching the byte code corresponding to the second file path from the target file.

Compiling and executing the file source code may include:

compiling to obtain a corresponding machine instruction according to the file source code and the byte code;

the machine instructions are executed.

Therefore, the compiling is carried out by combining byte codes, the compiling time can be reduced, and the program running speed is further improved.

Further, in some embodiments, the file path in the target file may be a relative path based on the directory identification, and the method may further include:

determining the matching relation between the file directory entry and the directory identifier of the target program in the current operating environment;

determining the module identification of the second module and the first text path of the first module comprises:

determining a module identifier in the request parameter;

if the module identifier is the file absolute path, replacing the file directory entry in the file absolute path with the corresponding directory identifier according to the matching relation so as to update the module identifier;

and determining a first absolute path of the first module, and replacing the file directory entry in the first absolute path with the corresponding directory identifier according to the matching relation to obtain a first file path.

Further, in some embodiments, the method may further comprise:

replacing the directory identifier in the second file path with the corresponding second file directory according to the matching relation so as to obtain a second absolute path of the second module; a respective native operation is performed based on the second absolute path.

That is, in the case that the second file path in the target file is a relative path based on the directory identifier, the second file path needs to be converted into a file absolute path, that is, a second absolute path. Corresponding native operations, such as cache operations, etc., are performed based on the second absolute path, and the source code of the second module is cached corresponding to the second absolute path.

The file path generation manner in the target file may be described in the corresponding embodiments, and is not described herein again.

In one practical application, the target program may be a JavaScript program developed depending on node.js or depending on a runtime system based on node.js secondary development, such as node.js Serverless, and the like, and may be a server program or a client program, for example. Js, a require () function is specifically adopted for module loading, the corresponding relationship stored in the target file is determined according to the module loading process of the require () function, for example, a first module in "/root/code/app.js" and a second module requesting the require module with the name "lodash", and the absolute path of the file corresponding to the second module is "/root/code/node _ modules/lodash/lodash.js", then "/root/code/app.js", "lodash" and "/root/code/node _ modules/lodash/lodash.js" can establish the corresponding relationship. Js ' and ' lodash ' can uniquely determine the corresponding '/root/code/node _ modules/lodash/lodash.js '.

In order to avoid the accuracy of the target file under the condition of complex directory structure or target structure update, the absolute path of the file can be converted into a relative path based on directory identification, and the relative path is stored into the target file after the corresponding relationship is established. As in the above example, "/root/code/" may be represented as directory identifier "a", the corresponding relationship is: js, "/a/app", "lodash", and "/a/node _ modules/lodash/lodash.j". When "/root/code/" is updated to "/root/runtime/", the directory entry corresponding to the updated directory identifier "a" is/root/runtime/". The file absolute path corresponding to "/a/app.js" is updated to "/root/running im/app.js", and the file absolute path corresponding to "/a/node _ modules/lodash/lodash.j" is updated to "// root/running im/node _ modules/lodash/lodash.j".

In addition, the object file can save the corresponding relation and also can save the file source code and the corresponding byte code of the module loaded in the running process of the object program, so that the file source code and the byte code can be directly obtained from the object file, file reading operation and compiling operation can be reduced, and the running speed of the program is further improved. Under the condition that the target file only corresponds to the module loaded in the starting stage of the target program, the starting speed of the target program can be effectively improved.

In addition, as can be seen from the foregoing description, in an actual application, after a code building end builds a code package of a target program, an object file may be generated by a file generation server, as shown in fig. 5, which is an interaction diagram of an application scenario in an actual application according to an embodiment of the present application, a code building end 501 sends the completely built code package to a file generating end 502, the file generating end 502 executes the code package to execute the target program, according to a result of model loading and addressing, a corresponding relationship between a first file path of a first module, a module identifier of a second module, and a second file path of the second module may be first determined, a file source code of the second module may be further obtained, a bytecode generated by compiling the file source code may be further obtained, an object file is generated based on the corresponding relationship, the file source code, and the bytecode, a specific object file generation process may be detailed in the embodiment shown in fig. 2, and will not be described in detail herein. The file generating end 502 may provide the generated object file to the code building end 501, the code building end 501 writes the object file into the code package to update the code package, and then the updated code package may be issued, assuming that the object program is a server program, the code package may be issued to the server 503, and the server 503 may provide corresponding services when running the object program, and the module loading operation involved in the running process may be executed according to the technical scheme of the embodiment shown in fig. 4, so as to ensure the program running speed. Under the condition that the target file is generated in the starting stage of the target program, the starting speed of the target program can be effectively improved.

Fig. 6 is a schematic structural diagram of an embodiment of a detection apparatus provided in the embodiment of the present application, where the apparatus may include:

a detecting unit 601, configured to run a target program and detect a module identifier of a second module, which is requested to be loaded by a first module in the target program;

a determining unit 602, configured to determine a second file path of a second module according to the addressing result of the module identifier;

a relationship establishing unit 603, configured to establish a corresponding relationship between a first file path and a second file path of the first module and the module identifier, and store the corresponding relationship in a target file of the target program;

the target file is used for searching the target file based on the first file path and the module identifier of the second module to determine the corresponding second file path under the condition that the first module in the target program requests to load the second module.

In some embodiments, the apparatus may further comprise:

the source code storage unit is used for acquiring a file source code corresponding to the second file path; storing the file source code to a target file corresponding to the second file path; the target file is also used for acquiring the correspondingly stored file source code according to the second file path.

In some embodiments, the apparatus may further comprise:

the byte code storage unit is used for acquiring byte codes generated by compiling the file source codes; saving the byte code to a target file corresponding to the second file path; the target file is also used for acquiring the corresponding saved byte codes according to the second file path.

In some embodiments, the apparatus may further comprise:

a path correction unit for determining a first absolute path of a first module;

if the file identifier is the file absolute path, replacing a third file directory entry in the file absolute path with a corresponding third directory identifier according to the matching relation so as to update the file identifier;

the determining unit may specifically be configured to obtain a second absolute path of the second module from the addressing result of the module identifier; replacing a second file directory entry in the second absolute path with a corresponding second directory identifier according to the matching relation, and obtaining a second file path based on the second directory identifier;

and updating the file directory entry corresponding to the directory identifier in the matching relationship under the condition that the file directory structure of the target program in the current operating environment is updated.

In some embodiments, the detection unit may be specifically configured to run the target program and start the detection mode; in the detection mode, detecting a module identifier of a second module which is requested to be loaded by a first module in a target program;

furthermore, the apparatus may further include:

and the termination unit is used for ending the detection mode when a termination event is detected.

In some embodiments, the detection unit may be specifically configured to obtain a code packet of the target program transmitted by the code building end; executing the code packet to run the target program, and determining a module identifier of a second module which is requested to be loaded by a first module in the target program;

furthermore, the apparatus may further include:

and the sending unit is used for transmitting the target file to the code constructing end so that the code constructing end can write the target file into the code packet of the target program.

The detection apparatus shown in fig. 6 may perform the detection method shown in the embodiment shown in fig. 1, and the implementation principle and the technical effect are not repeated. The specific manner in which the detection apparatus in the above-described embodiments performs the operations of the respective units has been described in detail in the embodiments related to the method, and will not be described in detail herein.

In one possible design, the detection apparatus of the embodiment shown in fig. 6 may be implemented as a computing device, which may include a storage component 701 and a processing component 702 as shown in fig. 7;

storage component 701 stores one or more computer instructions for execution by processing component 702 to implement the detection method of the embodiment shown in fig. 1.

Of course, a computing device may also necessarily include other components, such as input/output interfaces, communication components, and so forth. The input/output interface provides an interface between the processing components and peripheral interface modules, which may be output devices, input devices, etc. The communication component is configured to facilitate wired or wireless communication between the computing device and other devices, and the like.

The computing device may be a physical device or an elastic computing host provided by a cloud computing platform, and the computing device may be a cloud server, and the processing component, the storage component, and the like may be a basic server resource rented or purchased from the cloud computing platform.

In practical applications, the computing device may be implemented as a single physical machine, or may be implemented as a distributed cluster formed by a plurality of physical machines, and the like, which is not specifically limited herein.

Fig. 8 is a schematic structural diagram of an embodiment of a code packet processing apparatus according to an embodiment of the present application, where the apparatus may include:

a first acquisition unit 801 configured to acquire an initial code packet of a target program;

an execution unit 802, configured to execute the code package to run the target program, and detect a module identifier of a second module, which is requested to be loaded by a first module of the target program;

a determining unit 803, configured to determine a second file path of the second module according to the addressing result of the module identifier;

a relationship establishing unit 804, configured to establish a corresponding relationship between the first file path of the first module, the second file path, and the module identifier, and store the corresponding relationship to a target file of the target program;

an updating unit 805, configured to update the code package according to the target file.

Alternatively, the obtaining unit may obtain an initial code packet of the target program from the code building end;

alternatively, the updating unit may be configured to transmit the target file to the code building end, and the code building end writes the target file into the code package to update the code package.

The code packet processing apparatus shown in fig. 8 may execute the code packet processing method shown in the embodiment shown in fig. 3, and the implementation principle and the technical effect are not described again. The specific manner in which the detection apparatus in the above-described embodiments performs the operations of the respective units has been described in detail in the embodiments related to the method, and will not be described in detail herein.

In one possible design, the code packet processing apparatus of the embodiment shown in fig. 8 may be implemented as a computing device, which may include a storage component 901 and a processing component 902, as shown in fig. 9;

storage component 901 stores one or more computer instructions for execution by processing component 902 to implement the code packet processing method of the embodiment shown in fig. 3.

Fig. 10 is a schematic structural diagram of an embodiment of an operation control device according to an embodiment of the present application, where the operation control device may include:

an operation unit 1001, configured to determine a module identifier of a second module and a first file path of a first module when a target program is operated and the first module requests to load the second module;

the searching unit 1002 is configured to search a corresponding second file path from the target file according to the module identifier and the first file path; the target file stores the corresponding relation of the first file path, the module identification and the second file path; the second file path is obtained by addressing in advance;

a second obtaining unit 1003, configured to obtain a file source code according to a second file path;

and a compiling unit 1004 for compiling and executing the file source code.

In some embodiments, the file path in the target file is a relative path based on the directory identification, and the apparatus may further include:

the path conversion unit is used for determining the matching relationship between the file directory entry and the directory identifier of the target program in the current operating environment; determining the module identification of the second module and the first text path of the first module comprises: determining a module identifier in the request parameter; if the module identifier is the file absolute path, replacing the file directory entry in the file absolute path with the corresponding directory identifier according to the matching relation so as to update the module identifier; determining a first absolute path of the first module, and replacing a file directory entry in the first absolute path with a corresponding directory identifier according to a matching relation to obtain a first file path;

in addition, the path conversion unit is further configured to replace the directory identifier in the second file path with the corresponding second file directory according to the matching relationship, so as to obtain a second absolute path of the second module; a respective native operation is performed based on the second absolute path.

In some embodiments, the apparatus may further comprise:

and the native operation unit is used for obtaining a second file path from the target file without searching according to the module identifier and the first file path, and executing native module loading operation based on the module identifier.

The detection apparatus shown in fig. 10 may execute the operation control method shown in the embodiment shown in fig. 4, and the implementation principle and the technical effect are not described again. The specific manner in which the detection apparatus in the above-described embodiments performs the operations of the respective units has been described in detail in the embodiments related to the method, and will not be described in detail herein.

In addition, an embodiment of the present application further provides an object program, and as shown in fig. 11, the object program may include:

a storage control 1101 for providing a plurality of modules and target files;

the starting control 1102 is used for switching to a running state when a starting instruction is received;

a loading control 1103, configured to determine, when the first module requests to load the second module, a module identifier of the second module and a first file path of the first module;

the query control 1104 is configured to search a corresponding second file path from the target file according to the module identifier and the first file path; acquiring a file source code according to the second file path; the target file stores the corresponding relation of the first file path, the module identification and the second file path; the second file path is obtained by addressing in advance;

and an execution control 1105 for compiling and executing the file source code.

The target program may execute the operation control method shown in fig. 4, and the implementation principle and the technical effect thereof are not described in detail.

In one possible design, the present application further provides a computing device, as shown in fig. 12, which may include a storage component 1201 and a processing component 1202;

the storage component 1201 stores one or more computer instructions for the processing component 1202 to invoke for execution to implement the execution control method of the embodiment shown in fig. 4.

The processing components involved in the respective embodiments described above may include one or more processors executing computer instructions to perform all or part of the steps of the methods described above. Of course, the processing elements may also be implemented as one or more Application Specific Integrated Circuits (ASICs), Digital Signal Processors (DSPs), Digital Signal Processing Devices (DSPDs), Programmable Logic Devices (PLDs), Field Programmable Gate Arrays (FPGAs), controllers, micro-controllers, microprocessors or other electronic components configured to perform the above-described methods.

The storage component is configured to store various types of data to support operations at the terminal. The memory components may be implemented by any type or combination of volatile or non-volatile memory devices such as Static Random Access Memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, magnetic or optical disks.

In addition, an embodiment of the present application further provides a computer-readable storage medium, which stores a computer program, and when the computer program is executed by a computer, the detection method of the embodiment shown in fig. 1 may be implemented.

In addition, an embodiment of the present application further provides a computer-readable storage medium, which stores a computer program, and when the computer program is executed by a computer, the computer program can implement the code packet processing method according to the embodiment shown in fig. 3.

In addition, an embodiment of the present application further provides a computer-readable storage medium, which stores a computer program, and when the computer program is executed by a computer, the computer program may implement the operation control method in the embodiment shown in fig. 4.

It is clear to those skilled in the art that, for convenience and brevity of description, the specific working processes of the above-described systems, apparatuses and units may refer to the corresponding processes in the foregoing method embodiments, and are not described herein again.

The above-described embodiments of the apparatus are merely illustrative, and the units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the modules may be selected according to actual needs to achieve the purpose of the solution of the present embodiment. One of ordinary skill in the art can understand and implement it without inventive effort.

Through the above description of the embodiments, those skilled in the art will clearly understand that each embodiment can be implemented by software plus a necessary general hardware platform, and certainly can also be implemented by hardware. With this understanding in mind, the above-described technical solutions may be embodied in the form of a software product, which can be stored in a computer-readable storage medium such as ROM/RAM, magnetic disk, optical disk, etc., and includes instructions for causing a computer device (which may be a personal computer, a server, or a network device, etc.) to execute the methods described in the embodiments or some parts of the embodiments.

Finally, it should be noted that: the above embodiments are only used to illustrate the technical solutions of the present application, and not to limit the same; although the present application has been described in detail with reference to the foregoing embodiments, it should be understood by those of ordinary skill in the art that: the technical solutions described in the foregoing embodiments may still be modified, or some technical features may be equivalently replaced; and such modifications or substitutions do not depart from the spirit and scope of the corresponding technical solutions in the embodiments of the present application.

Claims

1. A method of detection, comprising:

running a target program, and detecting a module identifier of a second module which is requested to be loaded by a first module of the target program;

2. The method of claim 1, further comprising:

acquiring a file source code of the second module;

storing the file source code to the target file corresponding to the second file path; and the target file is also used for acquiring the correspondingly stored file source code according to the second file path.

3. The method of claim 2, further comprising:

acquiring a byte code generated by compiling the file source code;

saving the byte codes to the target file corresponding to the second file path; and the target file is also used for acquiring the corresponding saved byte codes according to the second file path.

4. The method of claim 1, further comprising:

determining a first absolute path of the first module;

if the file identifier is a file absolute path, replacing a third file directory entry in the file absolute path with a corresponding third directory identifier according to the matching relation so as to update the file identifier;

the determining a second file path of the second module according to the addressing result of the module identifier includes:

obtaining a second absolute path of the second module from the addressing result of the module identification;

replacing a second file directory entry in the second absolute path with a corresponding second directory identifier according to the matching relationship to obtain a second file path based on the second directory identifier;

5. The method of claim 1, wherein the running of the target program, detecting a module identification of a second module requested to be loaded by a first module in the target program comprises:

running the target program and starting a detection mode;

in the detection mode, detecting a module identification of a second module which is requested to be loaded by a first module in the target program;

the method further comprises the following steps:

when a termination event is detected, the detection mode is ended.

6. A method for processing a code packet, comprising:

acquiring an initial code packet of a target program;

and updating the code package according to the target file.

7. The method of claim 6, wherein obtaining the initial code package of the target program comprises:

the updating the code package according to the target file comprises:

and transmitting the target file to the code building end, and writing the target file into the code package by the code building end so as to update the code package.

8. An operation control method characterized by comprising:

acquiring a file source code according to the second file path;

compiling and executing the file source code.

9. The method of claim 8, wherein the file path in the target file is a relative path based on a directory identification, the method further comprising:

the determining the module identification of the second module and the first text path of the first module comprises:

determining a module identifier in the request parameter;

if the module identifier is a file absolute path, replacing a file directory entry in the file absolute path with a corresponding directory identifier according to the matching relation so as to update the module identifier;

determining a first absolute path of the first module, and replacing a file directory entry in the first absolute path with a corresponding directory identifier according to the matching relation to obtain a first file path;

the method further comprises the following steps:

replacing the directory identifier in the second file path with a corresponding second file directory according to the matching relation to obtain a second absolute path of the second module;

performing respective native operations based on the second absolute path.

10. A computing device comprising a processing component and a storage component;

the storage component stores one or more computer instructions; the one or more computer instructions are for execution by the processing component to invoke the detection method of any one of claims 1 to 5, or the code packet processing method of any one of claims 6 to 7, or the execution control method of any one of claims 8 to 9.