TW201820131A - Process management method and apparatus - Google Patents

Abstract

Disclosed in the present application are a method and apparatus for process management, comprising: initiating an agent process, said agent process loading a dynamic link library linked by the agent process to a memory; said agent process creating a first sub-process, said first sub-process loading a first program by means of invoking an entry function of said program; said agent process creating a second sub-process, said second sub-process loading a second program by means of invoking an entry function of said second program. Said first and second programs share the memory occupied by said dynamic link library.

Description

   Process management method and device   

This case relates to the field of computer technology, and in particular, to a method and device for process management.

Process (Process) is an execution activity of a program in a computer about a certain data collection. It is the basic unit for resource allocation and scheduling of the system and the basis of the operating system structure. A program is a description of instructions, data, and its organizational form, and a process is the entity of a program.

In a Linux system, the init process is the parent process of all processes in the Linux system. The init process is guided by the Linux kernel and is the first process in the system. The init process generates a child process. At this time, the child process shares the memory space of the parent process. Once the parent process or the child process modifies a page of memory, the Linux kernel creates a copy of the page memory that is exclusive to the process. You can share pages with the same content without disturbing each other.

The embodiment of the present case provides a method and a device for process management.

The method provided by the embodiment of the present case includes: starting an agent process, the agent process loading a dynamic link library linked to the agent process into memory; the agent process creating a first child process, the first child process The first program is loaded by calling the entry function of the first program; the proxy process creates a second sub-process, and the second sub-process is loaded by calling the entry function of the second program The second program; wherein the first program and the second program share a memory occupied by the dynamic link library.

601‧‧‧Activation module

602‧‧‧Process Creation Module

700‧‧‧ device

701‧‧‧system control logic

702‧‧‧ processor

703‧‧‧system memory

704‧‧‧NVM / Memory

705‧‧‧input / output device

706‧‧‧Interface

710‧‧‧Instruction

FIG. 1 is a schematic diagram of a process of loading a program in a Linux system in the prior art; FIG. 2 is a schematic diagram of a memory distribution after a program is loaded in a Linux system in the prior art; 4 is a schematic diagram of the memory distribution after the Linux system loads a program in the embodiment of the present case; FIG. 5 is a schematic diagram of the startup process of the application in the embodiment of the present case; FIG. 6 is a schematic structural diagram of the device provided by the embodiment of the present case; The structure diagram of the device provided by the embodiment.

Although the concept of this case is susceptible to various modifications and alternative forms, specific embodiments thereof have been shown by way of example in the drawings and will be described in detail herein. It should be understood, however, that there is no intention to limit the concept of the present case to the particular form disclosed, but to the contrary, the intention is to cover all modifications, equivalents, and alternatives consistent with the scope of this case and the appended patent applications.

References in the specification to "one embodiment", "an embodiment", "illustrative embodiment", etc. indicate that the described embodiments may include specific features, structures, or characteristics, but each embodiment may or may not necessarily include a specific feature A feature, structure, or characteristic. Moreover, such phrases are not necessarily referring to the same embodiment. Further, it is believed that, within the knowledge of those skilled in the art, when a specific feature, structure or characteristic is described in conjunction with an embodiment, such a feature, structure or characteristic is affected in conjunction with other embodiments whether explicitly described or not. In addition, it should be understood that projects included in the list in the form of "at least one of A, B, and C" may represent (A); (B); (C); (A and B); (A and C) ; (B and C); or (A, B and C). Similarly, projects listed in the form of "at least one of A, B, or C" can represent (A); (B); (C); (A and B); (A and C); (B and C) or (A, B and C).

In some cases, the disclosed embodiments may be implemented in hardware, firmware, software, or any combination thereof. The disclosed embodiments may also be implemented as instructions carried or stored by one or more temporary or non-transitory machine-readable (e.g., computer-readable) storage media, which may be read by one or more processors And execute. A machine-readable storage medium may be implemented as any storage device, mechanism, or other physical structure for storing or transmitting information in a machine-readable form (for example, volatile or nonvolatile memory, diskette, or other media). device).

In the drawings, some structural or method features may be shown in a specific arrangement and / or order. It should be understood, however, that such a specific arrangement and / or ordering may not be required. Rather, in some embodiments these features may be arranged in a different manner and / or order than that shown in the illustrative figures. In addition, including a structural or method feature in a particular figure does not imply that such a feature is required in all embodiments, and in some embodiments may not be included or may be combined with other features.

Refer to FIG. 1, which is a schematic diagram of a program a and a program b started by an init process in a current Linux system. As shown in the figure, the system first starts the init process. The init process calls the fork function to generate the child process a, and the child process a calls the exec function to load the program a. The loading process of program b is similar.

When a child process calls the exec function to load a new program, the memory space of the child process is completely cleared and rebuilt, that is, the memory page shared by the child process and the init process no longer exists. The init process in all current Linux systems creates a new program by calling the exec function. Figure 2 shows a schematic diagram of the memory distribution in the system after program a and program b are started. It can be seen that the dynamic link library memory has a copy in two sub-processes of program a and program b.

Among them, the dynamic link library is a way to implement a shared function library, so that a process can call a function that does not belong to its executable code. There are a large number of dynamic link libraries in the system, and most executable programs use dynamic link libraries. These dynamic link libraries take up a lot of memory. Therefore, how to reduce the memory overhead of dynamic link libraries is a problem that needs to be solved at present.

In the Linux system, the init process cannot link the dynamic link library. Therefore, in the embodiment of this case, a proxy process (called a cinit process) is used to link the dynamic link library. The proxy process creates a child process, and the child process creates a child process. Call the program's entry function to load the program. Since the child process created by the agent process loads the program by calling the program's entry function instead of calling the exec () function to load the program, the memory of different programs is avoided Is completely isolated; and because the agent process is linked to the dynamic link library, the dynamic link library is loaded into memory when the agent process starts, so multiple programs loaded by the above method can share the load of the agent process The memory of the dynamic link library is reduced, compared with the prior art, where each program needs to save a copy of the dynamic link library, the memory overhead of the dynamic link library is reduced.

The principle provided by the embodiment of the present case can be programmed in a Linux system, and can also be programmed in other systems having similar requirements.

The following uses the embodiment of the present case as an example to describe the specific implementation process of the embodiment of the present case.

When the computer was turned on, the system kernel created only one init process. The Linux kernel does not provide system calls to create new processes directly. All other processes are created by the init process through the fork mechanism. Fork is a system call. By calling the fork function, the old process (parent process) can get the new process (child process) by copying itself. Processes live in memory, and each process allocates its own address space in memory. When the fork function is called, Linux creates a new memory space in the memory for the new process, and copies the contents of the memory space of the old process to the new space, after which the two processes execute simultaneously.

Since the init process cannot link the dynamic link library, an agent process (called a cinit process) is introduced in the embodiment of the present case. The agent process links the dynamic link library at compile time. The dynamic link library can include the basic dynamic link library provided by the Linux system, which is usually used when the application is executed. During the startup process of the init process, the agent process is started, so that the dynamic link library linked by the agent process is loaded into the memory. Other programs in the system can be started by this agent process.

When a new program needs to be loaded (for example, the user touches the screen of a mobile terminal, clicks an application icon, or another operation that triggers the loading of an application occurs), the child process is created by the proxy process. The child process loads the program by calling its entry function.

In this process, the agent process can still create a child process by calling the fork function. When the agent process calls the fork function, the system allocates resources to the new process (child process). For example, Linux creates a new memory space in the memory for the new process, which is used to store data and code. The content in the process space is copied into the new space, of which only a few parameters are different from the parameters of the old process, so that the new process and the old process can achieve basically the same function. Of course, the initial parameters or variables passed in when the fork function is called can also be different. In this way, the new process and the old process can implement different functions.

The newly created process is a child process of the proxy process, obtains the address of the entry function of the application program, calls the entry function of the application program, and loads the application program. Among them, an application usually has a main function, which is an entry function of the application, and is a function that is called first when the application is started, thereby starting the execution of the application. In other embodiments, when the application is started, other functions can be executed before the main function of the application. For example, the __libc_start_main function exists in the executable program compiled by the gcc compiler. This function calls the main function. That is, the function is executed before the main function. In this case, after the agent process creates a child process, the child process can load the application by calling the application's __libc_start_main function.

The address of the entry function can be obtained from the compiled and linked executable program. The source code of an application program needs to be compiled by a compiler and linked by a linker to form an executable program. The executable program is usually stored in an executable and linkable format (ELF) file. The ELF file includes compiled machine instruction code, data, symbol tables, debugging information, strings, and so on. General ELF files store these file information in the form of "segments" or "sections" according to different attributes. Among them, the dynsym section in the ELF file is mainly used to store information related to the operating system, such as variable names and function names. The main function address in the dynsym section of the ELF file can be obtained by calling the dlsym function.

By default, when compiling the source code into an executable file, the address of the main function is not exported to the dynsym section, that is, the address of the main function cannot be obtained by calling the dlsym function. In the embodiment of the present case, the linker may be modified to export the address of the main function to the dynsym segment when the linker performs linking. The modification methods are different for different linkers. Of course, any other method that can export the address of the main function can also be used. The embodiment of this case does not limit the method for obtaining the address of the entry function.

Further, in some embodiments, before the child process created by the agent process calls the entry function of the program, the name of the child process is modified to be the same as the name of the program. In the Linux system, by default, the name of the child process is the same as the name of the parent process (here, the agent process cinit), otherwise the process name will display an error. You can modify the name of the process in the following ways:

Method 1: The child process calls a system call function for modifying the process name. In the Linux system, the prctl function is a system call function, which has higher authority and can be used to set the name of the process. Therefore, the child process may request the prctl function from the operating system kernel, and set the name of the child process by executing the prctl function.

Method 2: The child process obtains the address of the memory area used to store the process name in the child process, and modifies the parameter value stored in the memory area corresponding to the address (ie, changes the process name to the name of the application). In the embodiment of the present case, in the memory space of the sub-process, the name of the sub-process is stored in the area with the address argv [0]. If the parameter value stored in the area changes, the name of the sub-process will also change. Therefore, if the parameter value stored in the area with the address argv [0] in the child process is modified to the name of the application to be started, the name of the child process can be made the same as the name of the application. Subsequent created child processes can modify the parameter values stored in the area with the address argv [0] in this child process, so that each child process can set its own name without disturbing other child processes.

Further, in some embodiments, after the application is started, if the application name needs to be modified (for example, when a special name needs to be displayed for the current application in the user interface), the process name of the application is modified. It can also be modified in the following way: The process of the application obtains the address of the memory area (the address of the memory area) for storing the process name from the startup parameters stored in the memory unique to the process. Is the value of the variable argv [0]), and modify the parameter value stored in the memory area corresponding to the address (that is, change the process name to the new name of the application).

Further, in some embodiments, some environment variables are related to a process and need to be reset when a new program is started. The specific environment variables that need to be reset may depend on the platform. In the embodiment of the present case, after the agent process creates a child process, the child process can reset the environment variables used by the program corresponding to the child process. The operation of resetting the environment variable of the child process can be performed before the entry function is called or other environments need to be modified. Variable. For example, there is an environment variable whose value is the file name stored by the application in the system. Obviously, the file corresponding to each application is different. You need to reset the environment variable for each application.

Further, in some embodiments, it is considered that if some resources that cannot be inherited are inherited by the child process, errors will occur, such as resources such as file descriptors. Therefore, in the embodiment of the present case, before the proxy process creates the child process, it can close the resources that cannot be inherited by the child process. Among them, the agent process can determine which resources cannot be inherited by the child process. In specific implementation, in some examples, it is possible to set in advance which resources cannot be inherited by the child process, and the agent process is required to close or release these resources before creating the child process. In another example, the parent process of the child process can determine which resources cannot be inherited by the child process according to the preset rules. For example, when the parent process listens on a network port, it does not want the child process to listen to that port because two processes At the same time, an error usually occurs when listening on the same port, so it needs to close the port. The closing time is after the parent process calls the fork function and before the child process is executed.

It should be noted that if the program started by the agent process starts other programs (and all programs started thereafter) using the exec function, their memory cannot be shared. Therefore, anyone who wants a child process to share memory with its parent process needs to create a child process and load a program as described above. Since the above scheme is universal, in order to allow other programs of the system to comply with the scheme, the embodiment of the present case can provide an auxiliary function to implement the above scheme for other programs to call the function. In this way, each need to use the above scheme to save memory. This function can be used by processes without the need to write code to implement the above scheme for each process.

The following describes the specific implementation process of the foregoing embodiment by taking the loading process of the application a and the application b as an example in conjunction with FIG. 3 and FIG. 4.

As shown in Figure 3 and Figure 4, when the Linux system starts, the Linux kernel allocates memory space unique to the init process and guides the execution of the init process. After the init process is started, the agent process (cinit) is started. The agent process has its own unique memory space, which is allocated by the Linux kernel when the init process starts the agent process. Because the proxy process links the basic dynamic link library of the Linux system at compile time, the dynamic link library is loaded into the memory.

The process of loading the application program a, as shown in FIG. 3, the proxy process (cinit) calls the fork function to create a child process a. In this process, as shown in Figure 4, Linux opens up a new memory space in the memory for the child process a (that is, the unique memory of a shown in the figure) for storing data and code, and Copy the contents of the agent process into the new space. As shown in Figure 3, the child process a calls the dlopen function, and the input parameters include the file name of the dynamic link library (the file name is the same as the file name of the dynamic link library connected to the agent process), so that in the child process a Open the dynamic link library. By calling the dlopen function, the dynamic link library control code returned by the dlopen function can be passed into the parameter in the dlsym function to obtain the address of the symbol in the dynamic link library. Using this address, the dynamic link can be obtained. An indicator of the corresponding function in the library, and call the corresponding function in the dynamic link library. The child process a calls the main function of the application a to start the application a.

The process of loading the application program b, as shown in Figure 3, the agent process (cinit) calls the fork function to create a child process b. During this process, as shown in Figure 4, Linux created a new memory space in the memory for the child process b (that is, the unique memory of b shown in the figure) for storing data and code, and Copy the contents of the agent process into the new space. As shown in Figure 3, the child process b calls the dlopen function, and the input parameters include the file name of the dynamic link library (the file name is the same as the file name of the dynamic link library connected to the agent process), so that in the child process a Open the dynamic link library. Child process b calls application b's main function to start application b.

As can be seen from Figure 4, child process a and child process b start the application without using the exec function, but call the entry function, and the dynamic link libraries opened by application a and application b have been loaded into the proxy process. Memory, so application a and application b can share the memory of the dynamic link library without having to keep a separate copy of the dynamic link library.

When an application calls a function in a dynamic link library loaded by a proxy process, the data modified by the function can be stored in a memory space unique to the application (or the process corresponding to the application). For example, if application a (subprocess a) calls a method (function) in a dynamic link library and the method (function) needs to modify data (such as modifying the value of a variable) during execution, the operating system will use the data Stored in the unique memory space of application a (child process a); if application b (child process b) calls the method (function) in the dynamic link library, and it is required during the execution of the method (function) Modify the variable with the same name, the operating system will store the variable in the unique memory space of application b (child process b). In this way, the application a and the application b can share the dynamic link library, but the variables modified by calling the dynamic link library will be stored in their own unique memory space to avoid data conflicts.

Referring to FIG. 5, the process uses the above-mentioned application a as an example to describe the startup process of the application. The startup process of application b is similar. As shown in FIG. 5, when the application program a needs to be started, the process may include:

Block 501: The agent process determines resources that cannot be inherited by the child process, and closes these resources.

Block 502: The proxy process calls the fork function to create a child process a. In the process, the newly allocated child process allocates a memory space unique to the child process, and the memory space is exclusive to the child process.

Block 503: The child process a calls the prctl function, and the name of the child process a is changed to the name of the application a by executing the function.

Block 504: The child process a resets some environment variables, such as resetting the value of a variable used to store a file name stored in the system.

Block 505: The child process a calls the dlopen function, and uses the name of the dynamic link library loaded into the memory by the proxy process as an input parameter of the function, thereby executing the function to open the dynamic in the child process a Link the library.

Block 506: The child process a calls the dlsym function to obtain the address of the main function of the application a.

Block 507: The child process a calls the main function of the application a according to the address of the main function of the application a, thereby loading the application a.

In the above process, the order of blocks 503 to 506 may be adjusted, and this embodiment of the present invention does not limit this.

For the specific implementation process of the foregoing process, reference may be made to the foregoing embodiment, which is not repeated here.

As can be seen from the above description, in the above-mentioned embodiment of the present case, the init process in the system starts the agent process when it is started, and when the agent process starts, it loads the dynamic link library linked by the agent process into memory; When entering a program, the agent process creates a child process, and the child process loads the program by calling the program's entry function. In this way, multiple programs loaded in the above manner can share the load of the agent process. The memory occupied by the dynamic link library, instead of having to keep a copy of the dynamic link library for each program, reducing the memory overhead of the dynamic link library.

Based on the same technical concept, this embodiment of the present invention further provides a device that can implement the processes described in the foregoing embodiments.

6 is a schematic structural diagram of a device according to an embodiment of the present application. The device may include a startup module 601 and a process creation module 602, wherein the startup module 601 is used to start an agent process, and the agent process loads a dynamic link library linked to the agent process into memory; The process creation module 602 is configured to create a first sub-process, the first sub-process loads the first program by calling an entry function of the first program; and creates a second sub-process, the The second sub-process loads the second program by calling an entry function of the second program; wherein the first program and the second program share a memory occupied by the dynamic link library.

Optionally, the startup module 601 is the first process in the operating system, and the agent process started by the startup module is used to create a child process on behalf of the first process.

Optionally, the process creation module 602 is further configured to: before calling the entry function of the first program, open the dynamic link in the first subprocess by calling a function for opening a dynamic link library. A library, wherein the input parameters of the function include the file name of the dynamic link library; and before calling the entry function of the second program, by calling a function for opening the dynamic link library, The dynamic link library is opened in the second sub-process, wherein an input parameter of the function includes a file name of the dynamic link library.

Optionally, before the first sub-process created by the process creation module 602 calls the entry function of the first program, the name of the first sub-process is modified to be the same as the name of the first program; the process; Before the second sub-process created by the creation module 602 calls the entry function of the second program, the name of the second sub-process is changed to be the same as the name of the second program.

Optionally, the process creation module 602 is further configured to: before creating the first child process, close resources that cannot be inherited by the first child process; and before creating the second child process, close the resources that cannot be inherited. Describes the resources inherited by the second child process.

Optionally, before the first sub-process created by the process creation module 602 calls the entry function of the first program, the environment variables used by the first program are reset; Before the second child process calls the entry function of the second program, the environment variables used by the second program are reset.

Optionally, when the first program is compiled, an entry function address of the first program is exported to an executable file of the first program; the first program created by the process creation module is Before a child process calls the entry function of the first program, the entry function address of the first program is obtained according to the executable file of the first program; when the second program is compiled, the second program The address of the entry function of the program is exported to the executable file of the second program; before the second sub-process created by the process creation module calls the entry function of the second program, according to the first The executable file of the second program obtains an entry function address of the second program.

Optionally, the above device may further include a processing module (not shown in the figure), which may be used for the dynamics to be called by the first program after the first program is loaded. The data modified by the functions in the linked library are stored in a memory space unique to the first sub-process; and after loading the second program, the dynamics to be called by the second program The data modified by the functions in the link library are stored in a memory space unique to the second sub-process.

Based on the same technical concept, this embodiment of the present invention also provides one or more computer-readable media, where the readable medium stores instructions, and when the instructions are executed by one or more processors, the user equipment executes the foregoing Example describes the process.

Based on the same technical concept, this embodiment of the present invention further provides a device 700, which can implement the processes described in the foregoing embodiments.

FIG. 7 exemplarily illustrates an example apparatus 700 according to various embodiments. The device 700 may include one or more processors 702, the system control logic 701 is coupled to at least one processor 702, and a non-volatile memory (NMV) / memory 704 is coupled to the system control logic 701. The road interface 706 is coupled to the system control logic 701.

The processor 702 may include one or more single-core processors or multi-core processors. The processor 702 may include any combination of general-purpose processors or special-purpose processors (such as an image processor, an application processor baseband processor, etc.).

The system control logic 701 in one embodiment may include any suitable interface controller to provide any suitable interface to at least one of the processors 702 and / or any suitable interface to communicate with the system control logic 701 Any suitable interface for the device or component.

The system control logic 701 in one embodiment may include one or more memory controllers to provide an interface to the system memory 703. The system memory 703 is used to load and store data and / or instructions. For example, corresponding to the device 700, in one embodiment, the system memory 703 may include any suitable volatile memory.

NVM / memory 704 may include one or more tangible, non-transitory computer-readable media for storing data and / or instructions. For example, the NVM / memory 704 may include any suitable non-volatile storage device, such as one or more hard disk devices (HDDs), one or more compact disks (CDs), and / or one Or multiple digital versatile disks (DVDs).

The NVM / memory 704 may include storage resources that are physically part of a device installed in or accessible to the system, but not necessarily part of the device. For example, the NVM / memory 704 can be accessed by the network via the network interface 706.

The system memory 703 and the NVM / memory 704 may include temporary or persistent copies of the instructions 710, respectively. The instructions 710 may include instructions that, when executed by at least one of the processors 702, cause the device 700 to implement one or a combination of the methods described in FIGS. 2-5. In various embodiments, the instructions 710 or hardware, firmware, and / or software components may be additionally / alternatively placed in the system control logic 701, the network interface 706, and / or the processor 702.

The network interface 706 may include a receiver to provide the device 700 with a wireless interface to communicate with one or more networks and / or any suitable device. The network interface 706 may include any suitable hardware and / or firmware. The network interface 706 may include multiple antennas to provide a multiple-input multiple-output wireless interface. In one embodiment, the network interface 706 may include a network interface card, a wireless network interface card, a telephone modem, and / or a wireless modem.

In one embodiment, at least one of the processors 702 may be packaged with logic for one or more controllers for system control logic. In one embodiment, at least one of the processors may be packaged with the logic of one or more controllers for system control logic to form a system-level package. In one embodiment, at least one of the processors may be on the same die as the logic accumulation of one or more controllers for system control logic. In one embodiment, at least one of the processors may be on the same die as the logic accumulation of one or more controllers for system control logic to form a system chip.

The device 700 may further include an input / output device 705. The input / output device 705 may include a user interface designed to allow a user to interact with the device 700, and may include a peripheral component interface, which is designed to enable peripheral components to interact with the system, and / or may include a sensor, which In determining environmental conditions and / or location information about the device 700.

The present disclosure may include various example embodiments disclosed below.

In example embodiment 1, the method adopted may be merged: starting an agent process, the agent process loading a dynamic link library linked to the agent process into memory; the agent process creating a first child process, the The first sub-process loads the first program by calling the entry function of the first program; the proxy process creates a second sub-process, and the second sub-process calls the entry of the second program Function to load the second program; wherein the first program and the second program share a memory occupied by the dynamic link library.

In example embodiment 2, according to example embodiment 1, the agent process is started by a first process in an operating system, and the agent process is used to create a child process on behalf of the first process.

In the exemplary embodiment 3, according to the exemplary embodiments 1-2, the method further includes: opening the dynamic link library in the first sub-process by calling a function for opening the dynamic link library, wherein the function The input parameters of include the file name of the dynamic link library; and / or, further include: opening the dynamic link library in the second subprocess by calling a function for opening the dynamic link library , Wherein the input parameters of the function include the file name of the dynamic link library.

In example embodiment 4, according to example embodiments 1-3, it further includes: modifying the name of the first sub-process to be the same as the name of the first program; and / or, further including: modifying the second sub-process The name of the child process is modified to be the same as the name of the second program.

In the exemplary embodiment 5, according to the exemplary embodiment 4, the name of the child process is modified by: the child process calls a system call function for modifying the process name; or, the child process obtains the process name for storing the process name in the child process An address of a memory area of the memory, and modify a parameter value stored in the memory area corresponding to the address.

In example embodiment 6, according to example embodiments 1-5, before the agent process creates the first child process, the method further includes: closing a resource that cannot be inherited by the first child process; the agent process creates the Before the second child process, the method further includes: closing a resource that cannot be inherited by the second child process.

In example embodiment 7, according to example embodiments 1-6, it further includes: resetting the environment variables used by the first program; and / or, further includes: resetting the environment variables used by the second program.

In example embodiment 8, according to example embodiments 1-7, the method further includes: obtaining, by the first child process, an address of a memory area for storing the name of the first child process, and modifying the memory corresponding to the address. Parameter values stored in the area; and / or, further comprising: the second child process sends a request to the proxy process; the proxy process obtains a bit for storing a parameter of the name of the second child process according to the request And modify the parameter value in the address.

In example embodiment 9, according to example embodiments 1-8, the method further includes: storing data modified by a function in the dynamic link library called by the first program, unique to the first sub-process. Memory space; and / or, further comprising: storing data modified by a function in the dynamic link library called by the second program in a memory space unique to the second sub-process.

In example embodiment 10, according to example embodiments 1-9, when the first program is compiled, the address of the entry function of the first program is exported to the executable file of the first program; Before the first sub-process calls the entry function of the first program, obtain the entry function address of the first program according to the executable file of the first program; when the second program is compiled, the The address of the entry function of the second program is exported to the executable file of the second program; before the second subprocess calls the entry function of the second program, according to the executable file of the second program Obtaining an entry function address of the second program.

The present disclosure may also include various example embodiments disclosed below.

In the exemplary embodiment 1, the device may be merged. The device may include a startup module for starting an agent process, and the agent process loads a dynamic link library linked to the agent process into a memory; the process creates a module. Group for creating a first child process, the first child process loading the first program by calling an entry function of the first program; and creating a second child process, the second child process The second program is loaded by calling an entry function of the second program; wherein the first program and the second program share a memory occupied by the dynamic link library.

In example embodiment 2, according to example embodiment 1, the startup module is the first process in the operating system, and the agent process started by the startup module is used to proxy the first process creator. process.

In example embodiment 3, according to example embodiments 1-2, the process creation module is further configured to: open the dynamic link in the first sub-process by calling a function for opening a dynamic link library A library, wherein input parameters of the function include a file name of the dynamic link library; and / or, opening the second sub-process by calling a function for opening the dynamic link library The dynamic link library, wherein the input parameters of the function include the file name of the dynamic link library.

In example embodiment 4, according to example embodiments 1-3, the first sub-process created by the process creation module changes the name of the first sub-process to the same name as the first program; and / Or, the second sub-process created by the process creation module changes the name of the second sub-process to be the same as the name of the second program.

In example embodiment 5, according to example embodiments 1-4, the process creation module is further configured to: before creating the first child process, close a resource that cannot be inherited by the first child process; and, Before the second child process is described, a resource that cannot be inherited by the second child process is closed.

In example embodiment 6, according to example embodiments 1-5, the first sub-process created by the process creation module resets an environment variable used by the first program; and / or, the process creation module The second sub-process created by the group resets an environment variable used by the second program.

In example embodiment 7, according to example embodiments 1-6, it further includes a processing module for storing data modified by a function in the dynamic link library called by the first program in the first embodiment. A memory space unique to a sub-process; and / or, data modified by a function in the dynamic link library called by the second program is stored in a memory unique to the second sub-process space.

In example embodiment 8, according to example embodiments 1-7, when the first program is compiled, the address of the entry function of the first program is exported to the executable file of the first program; The first sub-process created by the process creation module obtains an entry function address of the first program according to an executable file of the first program; when the second program is compiled, the second program The address of the entry function is exported to the executable file of the second program; and / or, the second sub-process created by the process creation module obtains all the files according to the executable file of the second program. The address of the entry function of the second program is described.

The present disclosure may also include various example embodiments disclosed below.

In example embodiment 1, the computer-readable media may be combined, which may include one or more computer-readable media, where the readable medium stores instructions, and when the instructions are executed by one or more processors, The communication device is caused to perform the method according to any one of claims 1-10.

The present disclosure may also include various example embodiments disclosed below.

In example embodiment 1, the device may be merged, which may include: one or more processors; and one or more computer-readable media, where instructions are stored on the readable medium, and the instructions are When executed by one or more processors, the apparatus is caused to execute the method according to any one of claims 1-10 of the scope of patent application.

Claims (20)

    A method, comprising: starting an agent process, the agent process loading a dynamic link library linked to the agent process into a memory; the agent process creating a first child process, the first child process The first program is loaded by calling the entry function of the first program; the proxy process creates a second sub-process, and the second sub-process is loaded by calling the entry function of the second program The second program; wherein the first program and the second program share a memory occupied by the dynamic link library.         The method according to item 1 of the scope of patent application, wherein the agent process is started by a first process in an operating system, and the agent process is used to create a child process on behalf of the first process.         The method according to item 1 of the patent application scope, further comprising: opening the dynamic link library in the first sub-process by calling a function for opening the dynamic link library, wherein the function The input parameters of include the file name of the dynamic link library; and / or further include: opening the dynamic link library in the second sub-process by calling a function for opening the dynamic link library, The input parameters of the function include the file name of the dynamic link library.         The method according to item 1 of the patent application scope, further comprising: modifying the name of the first sub-process to the same name as the first program; and / or further comprising: modifying the second sub-process The name of the process is modified to be the same as the name of the second program.         The method according to item 4 of the scope of patent application, wherein the name of the child process is modified by: the child process calls a system call function for modifying the process name; or the child process acquires the child process for storage An address of a memory area of the process name, and modifying a parameter value stored in the memory area corresponding to the address.         The method according to item 1 of the scope of patent application, wherein before the agent process creates the first child process, the method further comprises: closing a resource that cannot be inherited by the first child process; and / or the agent process Before creating the second child process, the method further includes: closing a resource that cannot be inherited by the second child process.         The method according to item 1 of the scope of patent application, further comprising: resetting an environment variable used by the first program; and / or further comprising: resetting an environment variable used by the second program.         The method according to item 1 of the patent application scope, further comprising: obtaining, by the first sub-process, an address of a memory area for storing the name of the first sub-process, and modifying the memory corresponding to the address Parameter values stored in the area; and / or, further comprising: the second child process sends a request to the proxy process; the proxy process obtains a bit for storing a parameter of the name of the second child process according to the request And modify the parameter value in the address.         The method according to item 1 of the scope of patent application, further comprising: storing data modified by a function in the dynamic link library called by the first program in a unique manner of the first sub-process Memory space; and / or data modified by a function in the dynamic link library called by the second program is stored in a memory space unique to the second sub-process.         The method according to any one of claims 1 to 9, wherein when the first program is compiled, the address of the entry function of the first program is exported to the first program. In the executable file; before the first sub-process calls the entry function of the first program, obtain the entry function address of the first program according to the executable file of the first program; the second program is in When compiled, the address of the entry function of the second program is exported to the executable file of the second program; before the second subprocess calls the entry function of the second program, according to the first The executable file of the second program obtains an entry function address of the second program.         A device, comprising: a startup module for starting an agent process, the agent process loading a dynamic link library linked to the agent process into a memory; a process creation module for creating a first A sub-process, the first sub-process loading the first program by calling an entry function of the first program; and creating a second sub-process, the second sub-process by calling the second program The entry function loads the second program; wherein the first program and the second program share a memory occupied by the dynamic link library.         The device according to item 11 of the scope of patent application, wherein the startup module is the first process in the operating system, and the agent process started by the startup module is used to proxy the first process Create a child process.         The device according to item 11 of the patent application scope, wherein the process creation module is further configured to: open the dynamic link in the first sub-process by calling a function for opening a dynamic link library A library, wherein the input parameters of the function include the file name of the dynamic link library; and / or the dynamic opening of the dynamic link library by calling the function to open the dynamic in the second sub-process The link library, wherein the input parameter of the function includes the file name of the dynamic link library.         The device according to item 11 of the scope of patent application, wherein the first sub-process created by the process creation module modifies the name of the first sub-process to be the same as the name of the first program; and / Or the second sub-process created by the process creation module changes the name of the second sub-process to the same name as the second program.         The device according to item 11 of the scope of patent application, wherein the process creation module is further configured to: before creating the first sub-process, close a resource that cannot be inherited by the first sub-process; and create the Before the second child process, the resources that cannot be inherited by the second child process are closed.         The device according to item 11 of the scope of patent application, wherein before the first sub-process created by the process creation module calls the entry function of the first program, reset the environment used by the first program Variables; and / or before the second child process created by the process creation module calls the entry function of the second program, resetting the environment variables used by the second program.         The device according to item 11 of the scope of patent application, further comprising: a processing module for storing data modified by a function in the dynamic link library called by the first program, in the device. Memory space unique to the first sub process; and / or, data modified by a function in the dynamic link library called by the second program is stored in the memory unique to the second sub process Body space.         The device according to any one of claims 11 to 17, wherein when the first program is compiled, the address of the entry function of the first program is exported to the first program. In the executable file; the first sub-process created by the process creation module obtains the entry function address of the first program according to the executable file of the first program; when the second program is compiled The address of the entry function of the second program is exported to the executable file of the second program; the second sub-process created by the process creation module is based on the executable file of the second program Obtaining an entry function address of the second program.         One or more computer-readable media having instructions stored on the readable medium. When the instructions are executed by one or more processors, the communication device executes the instructions as described in any one of claims 1-10 of the scope of patent application. Methods.         An apparatus includes: one or more processors; and one or more computer-readable media, where instructions are stored on the readable medium, and the instructions, when executed by the one or more processors, cause the The device executes the method according to any one of claims 1-10 of the scope of patent application.