WO2018099292A1

WO2018099292A1 - Process management method and apparatus

Info

Publication number: WO2018099292A1
Application number: PCT/CN2017/111997
Authority: WO
Inventors: 关志俊
Original assignee: 阿里巴巴集团控股有限公司
Priority date: 2016-11-29
Filing date: 2017-11-21
Publication date: 2018-06-07
Also published as: CN108121594B; CN108121594A; TW201820131A

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

The present application claims priority to Chinese Patent Application Serial No. No. No. No. No. No. No. No. No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No No

Technical field

The present application relates to the field of computer technologies, and in particular, to a process management method and apparatus.

Background technique

A process is a running activity of a program on a computer on a data set. It is the basic unit of the system for resource allocation and scheduling, and is the basis of the operating system structure. A program is a description of instructions, data, and its organizational form. A process is an entity of a program.

In Linux systems, the init process is the parent of all processes in the Linux system. The init process is run 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 exclusive to the process, so that the parent and child processes can share. Memory pages with the same content do not interfere with each other.

Summary of the invention

The embodiment of the present application provides a process management method and apparatus.

The method provided by the embodiment of the present application includes: starting an agent process, where the agent process loads a dynamic link library linked by the agent process into a memory; the agent process creates a first child process, and the first child process invokes The entry function of the first program loads the first program; the proxy process creates a second child process, and the second child process loads the second program by calling an entry function of the second program; The first program and the second program share the memory occupied by the dynamic link library.

DRAWINGS

1 is a schematic diagram of a process of loading a program in a Linux system in the prior art;

2 is a schematic diagram of memory distribution after loading a program in a Linux system in the prior art;

3 is a schematic diagram of a process of loading a Linux system in the embodiment of the present application;

4 is a schematic diagram of memory distribution after a Linux system loading program in an embodiment of the present application;

FIG. 5 is a schematic diagram of a startup process of an application in an embodiment of the present application;

FIG. 6 is a schematic structural diagram of an apparatus according to an embodiment of the present disclosure;

FIG. 7 is a schematic structural diagram of an apparatus according to another embodiment of the present application.

detailed description

While the concept of the present application is susceptible to various modifications and alternatives, the specific embodiments thereof are illustrated by the examples in the drawings and will be described in detail herein. It should be understood, however, that the invention is not intended to be limited to the details of the invention.

References to "an embodiment", "an embodiment", "an illustrative embodiment" or the like in the specification are intended to mean that the described embodiments may include specific features, structures, or characteristics, but each embodiment may or may not necessarily include a particular Feature, structure or characteristic. Moreover, such phrases are not necessarily referring to the same embodiments. Further, it is to be understood that the specific features, structures, or characteristics may be combined with other embodiments, whether explicitly described or not, in conjunction with the embodiments. In addition, it should be understood that items 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, items listed in the form of "at least one of A, B or C" may represent (A); (B); (C); (A and B); (A and C); (B and C) or (A, B and C).

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

In the figures, some structural or method features may be shown in a particular arrangement and/or order. However, it should be understood that such specific arrangements and/or ordering may not be required. Rather, in some embodiments, these features may be arranged in a different and/or sequential manner than shown in the illustrative figures. In addition, the inclusion of structural or method features in a particular figure is not meant to imply that such a feature is required in all embodiments, and may not include or be combined with other features in some embodiments.

Referring to FIG. 1, 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 the 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 child process and the init process no longer have shared memory pages. At present, all init processes in the Linux system are created by calling the exec function when creating a new program. Figure 2 shows the memory distribution in the system after the program a and the program b are started. It can be seen that there is a copy in the two processes of the program a and the program b in the dynamic link library.

Among them, the dynamic link library is a way to implement the shared function library, so that the process can call functions that are not part of 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 the dynamic link library is a problem that needs to be solved currently.

Since the init process cannot link the dynamic link library in the Linux system, the proxy process (called the cinit process) is used to link the dynamic link library in the embodiment of the present application, and the child process is created by the agent process, and the child process created by the agent process is called. The entry function of the program loads 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 completely isolated; The agent process links the dynamic link library, and the dynamic link library is loaded into the memory when the agent process starts, so the multiple programs loaded by the above manner can share the memory of the dynamic link library loaded by the agent process, thereby Each program in the program needs to save a copy of the dynamic link library, reducing the memory overhead of the dynamic link library.

The principles provided by the embodiments of the present application can be programmed in a Linux system or in other systems with similar requirements.

The specific implementation process of the embodiment of the present application is described below by taking an embodiment of the present application in a Linux system as an example.

When the computer is powered on, the kernel (kernel) only creates an init process. The Linux kernel does not provide a system call to directly create a new process. 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. The process lives in memory, and each process is allocated its own address space in memory. When the fork function is called, Linux opens up new memory space in memory to the new process, and copies the contents of the old process memory space into the new space, after which the two processes run simultaneously.

Since the init process cannot link the dynamic link library, an agent process (referred to as a cinit process) is introduced in the embodiment of the present application. 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 generally used by the application runtime. During the startup process of the init process, the agent process is started, thereby loading the dynamic link library linked by the agent process into the memory. Other programs in the system Can be started by the agent process.

When a new program needs to be loaded (such as a user touching a screen through a mobile terminal, clicking an application's icon, or another action that triggers an application to load), a child process is created by the proxy process, and the child process is called. The program's entry function loads the program.

During this process, the agent process can still create child processes 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 opens up a new memory space in memory for the new process, which is used to store data and code, and the old process space. The content in the content is copied to the new space, where 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 the variables passed in when the fork function is called can be different, so that the new process and the old process can implement different functions.

The newly created process acts as a child of the agent process, gets the address of the application's entry function, calls the application's entry function, and loads the application. Among them, the application usually has a main function, which is the application's entry function, which is the function that is called first when the application is started, so that the application starts running. In other embodiments, when the application is launched, other functions may be executed before the main function of the application. For example, the __libc_start_main function exists in the executable compiled by the gcc compiler, and the function calls the main function. That is, the function is executed before the main function. In this case, after the agent process creates the child process, the child process can load the application by calling the application's __libc_start_main function.

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

By default, when the source code is compiled 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 application, the linker may be modified to export the address of the main function to the dynsym segment when the linker performs the link. The modification method is different for different linkers. Of course, any other method that can export the address of the main function can be used. The method of obtaining the address of the entry function is not limited in the embodiment of the present application.

Further, in some embodiments, the child process created by the proxy process calls the program's entry function before Modify the name of the child process to be the same as the name of the program. On Linux systems, 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. Specifically, you can modify the name of the process in the following ways:

Method 1: The child process calls the system call function that modifies the process name. In Linux systems, the prctl function is a system call function with higher privileges and can be used to set the name of the process. Therefore, the child process can request the operating system kernel to call the prctl function, and set the name of the child process by executing the prctl function.

Manner 2: The child process obtains the address of the memory area in the child process for storing the process name, and modifies the parameter value stored in the memory area corresponding to the address (ie, the process name is changed to the name of the application). In the embodiment of the present application, in the memory space of the child process, the name of the child process is stored in the area with the address argv[0], and if the value of the parameter stored in the area changes, the name of the child process also changes. Therefore, if you modify the parameter value stored in the area of the child process with the address argv[0] to the name of the application that needs to be started, you can make the name of the child process the same as the name of the application. Subsequently created child processes can modify the parameter values stored in the area with the address argv[0] in the child process, so that each child process can set its own name without interfering with 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 in the user interface for the current application), that is, the process name of the application is modified, It can also be modified in such a way that the application's process obtains the address of the memory area used to store the process name from the boot parameters stored in the process's unique memory (the address of the memory area is the variable argv[0] Value) and modify the parameter value stored in the memory area corresponding to the address (ie, modify the process name to the new name of the application).

Further, in some embodiments, some environment variables are process dependent, need to be reset when starting a new program, and specific environment variables need to be reset depending on the platform. In the embodiment of the present application, after the agent process creates the child process, the child process may reset the environment variable used by the program corresponding to the child process, and the operation of resetting the environment variable by the child process may be performed before the entry function is called or other needs to be modified. When the environment variable. For example, the value of an environment variable is the name of the file that the application stores in the system. Obviously, the file corresponding to each application is different, and the environment variable needs to be reset for each application.

Further, in some embodiments, it is contemplated that certain resources that cannot be inherited, if inherited by a child process, will generate an error, such as a resource such as a file descriptor. Therefore, in the embodiment of the present application, the agent process may close the resources that cannot be inherited by the child process before creating the child process. Among them, the agent process can determine which resources cannot be inherited by the child process. In specific implementations, in some examples, it may be pre-set which resources cannot be inherited by the child process, and the agent process is required to close or release the resources before creating the child process. In another example, the parent process of the child process can According to the preset rules to determine which resources can not be inherited by the child process, for example, when the parent process listens to a network port, it does not want the child process to also listen to the port, because two processes usually listen to the same port at the same time, usually an error occurs, then it The port needs to be closed. The time to close is after the parent process calls the fork function and before the child process is run.

It should be noted that if the program started by the agent process uses the exec function to start other programs (and all programs started afterwards), their memory cannot be shared. Therefore, any child process that wants a child process to share memory with its parent process needs to create a child process and loader as described above. Since the foregoing solution is universal, in order to allow other programs of the system to comply with the solution, the embodiment of the present application may provide a helper function to implement the above solution, so that other programs call the function, so that each of the solutions needs to save memory. This function can be used by processes without having to write code for implementing the above scheme for each process.

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

As shown in Figure 3 and Figure 4, when the Linux system starts, the Linux kernel allocates the memory space unique to the init process for the init process and boots the init process. After the init process starts, 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. Since the proxy process links the basic dynamic link library of the Linux system at compile time, the dynamic link library is loaded into memory.

The process of loading the application a, as shown in Figure 3, the proxy process (cinit) calls the fork function to create the child process a. In this process, as shown in Figure 4, Linux opens up a new memory space in memory to the child process a (that is, the unique memory shown in the figure), used to store data and code, and the proxy process The contents of the content are copied to the new space. As shown in FIG. 3, the child process a calls the dlopen function, and the input parameter includes the file name of the dynamic link library (the file name is the same as the file name of the dynamic link library to which the agent process is connected), thereby opening the file in the child process a. Dynamic link library. By calling the dlopen function, the dynamic link library handle returned by the dlopen function can be passed to the parameter in the dlsym function to obtain the address of the symbol in the dynamic link library. Using this address, a pointer to the corresponding function in the dynamic link library can be obtained. 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 b, as shown in Figure 3, the proxy process (cinit) calls the fork function to create the child process b. In this process, as shown in Figure 4, Linux opens up a new memory space in memory for child process b (the b-only memory shown in the figure) for storing data and code, and will proxy the process. The contents of the content are copied to the new space. As shown in Figure 3, the child process b calls the dlopen function, and the input parameter includes the text of the dynamic link library. The name of the file (the file name is the same as the file name of the dynamic link library to which the agent process is connected), thereby opening the dynamic link library in child process a. The child process b calls the main function of the application b, thereby starting the application b.

As can be seen from Figure 4, the child process a and the child process b start the application without using the exec function, but call the entry function, and the dynamic link library opened by the application a and the application b has been loaded into the memory by the proxy process. Therefore, application a and application b can share the memory of the dynamic link library without having to save a 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 (child process a) calls a method (function) in the dynamic link library, and the data needs to be modified during the execution of the method (such as modifying the value of the variable), the operating system stores the data. The unique memory space in application a (child process a); if application b (child process b) calls the method (function) in the dynamic link library, and needs to modify the same name during the execution of the method (function) The variable, the operating system will store the variable in the unique memory space of application b (child process b). In this way, application a and application b can share the dynamic link library, but the variables modified by calling the dynamic link library are stored in their own unique memory space to avoid data conflicts.

Referring to FIG. 5, the process uses the above application a as an example to describe the startup process of the application. The startup process for application b is similar. As shown in FIG. 5, when the application 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 the resources.

Block 502: The proxy process invokes the fork function to create the child process a. In the process, the system allocates a newly created child process with a memory space unique to the child process, and the memory space belongs to the child process.

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

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

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

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

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

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

For the specific implementation process of the foregoing process, refer to the foregoing embodiment, which is not repeated here.

As can be seen from the above description, in the above embodiment of the present application, the init process in the system starts the agent process when starting, and when the agent process starts, the dynamic link library linked by the agent process is loaded into the memory; when a program needs to be loaded When the agent process creates a child process, the child process loads the program by calling the entry function of the program, so that multiple programs loaded by the above manner can share the memory occupied by the dynamic link library loaded by the agent process, and It is not necessary for each program to save a copy of the dynamic link library, which reduces the memory overhead of the dynamic link library.

Based on the same technical concept, the embodiment of the present application further provides a device, which can implement the process described in the foregoing embodiment.

FIG. 6 is a schematic structural diagram of an apparatus according to an embodiment of the present application. The apparatus can include: a startup module 601, a process creation module 602, wherein:

The startup module 601 is configured to start a proxy process, where the proxy process loads the dynamic link library linked by the proxy process to the memory; the process creation module 602 is configured to create a first child process, where the first child process is invoked by An entry function of the first program, loading the first program; and, creating a second child process, the second child process loading the second program by calling an entry function of the second program; The first program and the second program share the memory occupied by the dynamic link library.

Optionally, the startup module 601 is the first process in the operating system, and the proxy process initiated by the startup module is used to proxy the first process to create a child process.

Optionally, the process creation module 602 is further configured to: before calling the entry function of the first program, open the dynamic link library in the first sub-process by calling a function for opening a dynamic link library, where The input parameter of the function includes a file name of the dynamic link library; and, before calling the entry function of the second program, opening in the second child process by calling a function for opening the dynamic link library The dynamic link library, wherein the 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 invokes the entry function of the first program, modify the name of the first sub-process to be the same as the name of the first program; Before the second sub-process created by the module 602 calls the entry function of the second program, the name of the second sub-process is modified to be the same as the name of the second program.

Optionally, the process creation module 602 is further configured to: before the first child process is created, shut down a resource that cannot be inherited by the first child process; and before the second child process is created, the shutdown cannot be performed. The resource inherited by the second child process.

Optionally, the environment variable used by the first program is reset before the first child process created by the process creation module 602 calls the entry function of the first program; the second created by the process creation module 602 Child process The environment variable used by the second program is reset before the entry function of the second program.

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 sub-process created by the process creation module Before invoking the entry function of the first program, acquiring an entry function address of the first program according to an executable file of the first program; and when the second program is compiled, an entry function of the second program The address is exported to the executable file of the second program; before the second child process created by the process creation module calls the entry function of the second program, according to the executable file of the second program The entry function address of the second program.

Optionally, the foregoing apparatus may further include a processing module (not shown in the figure), where the processing module is configured to: after loading the first program, the dynamic link library to be called by the first program The modified data of the function is stored in a memory space unique to the first sub-process; and, after loading the second program, a function in the dynamic link library to be called by the second program The modified data is stored in a memory space unique to the second subprocess.

Based on the same technical concept, the embodiment of the present application further provides one or more computer readable media having instructions stored thereon, when the instructions are executed by one or more processors, such that the user equipment performs the foregoing The process described in the examples.

Based on the same technical concept, the embodiment of the present application further provides a device 700, which can implement the process described in the foregoing embodiment.

FIG. 7 exemplarily illustrates an example apparatus 700 in accordance with various embodiments. Apparatus 700 can include one or more processors 702 coupled to at least one processor 702, non-volatile memory (non- A volatile memory (NMV)/memory 704 is coupled to system control logic 701, which is coupled to system control logic 701.

Processor 702 can include one or more single core processors or multi-core processors. Processor 702 can include any general purpose processor or combination of special purpose processors (eg, image processor, application processor baseband processor, etc.).

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

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

NVM/memory 704 can include one or more tangible, non-transitory computer readable media for storing data And / or instructions. For example, NVM/memory 704 can 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 more Digital versatile disk (DVD).

NVM/memory 704 can include a storage resource that is physically part of, but not necessarily part of, the device that the system is installed on or can be accessed. For example, NVM/memory 704 can be accessed by the network via network interface 706.

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

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

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

Device 700 can further include input/output device 705. Input/output device 705 can include a user interface intended to enable a user to interact with device 700, can include a peripheral component interface that is designed to enable peripheral components to interact with the system, and/or can include sensors for determining environmental conditions And/or location information about the device 700.

The present disclosure can include various example embodiments disclosed below.

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

In example embodiment 2, according to example embodiment 1, the agent process is initiated by a first process in an operating system, the agent process is used to proxy the first process to create a child process.

In example embodiment 3, according to example embodiment 1-2, further comprising: opening the dynamic link library in the first sub-process by calling a function for opening a dynamic link library, wherein input parameters of the function Include the file name of the dynamic link library; and/or, further comprising: opening the dynamic link library in the second child process by calling a function for opening the dynamic link library, wherein the function input The file name of the dynamic link library is included in the parameter.

In example embodiment 1-3, according to example embodiments 1-3, further comprising: modifying a name of the first sub-process to be the same as a name of the first program; and/or further comprising: 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 calling a system call function for modifying the process name; or the child process acquiring the name of the child process for storing the process name. The address of the memory area, and modify the parameter value stored in the memory area corresponding to the address.

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

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

In the example embodiment 8, according to the example embodiments 1-7, the method further includes: the first sub-process acquiring an address of a memory area for storing the first sub-process name, and modifying the memory area corresponding to the address a parameter value; and/or, further comprising: the second sub-process sending a request to the proxy process; the proxy process acquiring an address of a parameter for storing a second sub-process name according to the request, and modifying the The parameter value in the address.

In the example embodiment 9, according to the example embodiments 1-8, further comprising: storing data modified by a function in the dynamic link library called by the first program, which is unique to the first subprocess And a 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, an entry function address of the first program is exported to an executable file of the first program; Before a child process calls the entry function of the first program, acquiring 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 Entry function address is exported to the second program In the executable file, before the second sub-process calls the entry function of the second program, the entry function address of the second program is obtained according to the executable file of the second program.

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

In the example embodiment 1, the device may be merged, the device may include: a startup module, configured to start an agent process, the agent process loads a dynamic link library linked by the agent process to a memory; and a process creation module, configured to create 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 calling the second program The entry function loads the second program; wherein the first program and the second program share memory occupied by the dynamic link library.

In example embodiment 2, according to example embodiment 1, the startup module is a first process in an operating system, and the proxy process initiated by the startup module is used to proxy the first process to create a child process.

In the third embodiment, according to the example embodiment 1-2, the process creation module is further configured to: open the dynamic link library in the first sub-process by calling a function for opening a dynamic link library, where Entering a file name of the dynamic link library in an input parameter of the function; and/or opening the dynamic link library in the second child process by calling a function for opening the dynamic link library, where The file name of the dynamic link library is included in the input parameters of the function.

In example embodiment 4, according to example embodiments 1-3, 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 modifies the name of the second sub-process to be the same as the name of the second program.

In the example embodiment 5, according to the example embodiment 1-4, 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.

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 creates The second child process resets an environment variable used by the second program.

In the example embodiment 7, according to the example embodiments 1-6, further comprising: a processing module, configured to store data modified by a function in the dynamic link library called by the first program, in the first child a memory space unique to the process; and/or storing data modified by a function in the dynamic link library called by the second program in a memory space unique to the second child process.

In example embodiment 8, according to example embodiments 1-7, 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 process Create the module created by the first a child process acquires an entry function address of the first program according to an executable file of the first program; when the second program is compiled, an entry function address of the second program is exported to the second In the executable file of the program; and/or, the second sub-process created by the process creation module acquires an entry function address of the second program according to the executable file of the second program.

In the example embodiment 1, the computer readable medium may be combined, which may include: one or more computer readable media having instructions stored thereon, the instructions being executed by one or more processors, The communication device is caused to perform the method as described in any of the above embodiments.

In example embodiment 1, the apparatus may be combined, which may include: one or more processors; and one or more computer readable media having instructions stored thereon, the instructions being by the one When executed by a plurality of processors, the apparatus is caused to perform the method as described in any of the above embodiments.

Claims

A process management method, comprising:

Starting an agent process, the agent process loading a dynamic link library linked by the agent process into a memory;

The agent process creates a first child process, and the first child process loads the first program by calling an entry function of the first program;

The agent process creates a second child process, and the second child process loads the second program by calling an entry function of the second program;

The first program and the second program share the memory occupied by the dynamic link library.
The method of claim 1 wherein said proxy process is initiated by a first one of operating systems for proxying said first process to create a child process.
The method of claim 1 further comprising: opening said dynamic link library in said first child process by invoking a function for opening a dynamic link library, wherein input parameters of said function are Include the filename of the dynamic link library; and/or

The method further includes: opening the dynamic link library in the second child process by calling a function for opening a dynamic link library, wherein a file name of the dynamic link library is included in an input parameter of the function.
The method of claim 1 further comprising: modifying a name of said first sub-process to be the same as a name of said first program; and/or

The method further includes modifying the name of the second sub-process to be the same as the name of the second program.
The method of claim 4 wherein the name of the child process is modified in the following manner:

The child process calls the system call function that modifies the process name; or,

The child process acquires an address of the memory area in the child process for storing the process name, and modifies the parameter value stored in the memory area corresponding to the address.
The method of claim 1, wherein before the proxy process creates the first child process, the method further comprises: closing a resource that cannot be inherited by the first child process; and/or

Before the proxy process creates the second child process, the method further includes: closing a resource that cannot be inherited by the second child process.
The method of claim 1 further comprising: resetting an environment variable used by said first program; and/or

Also included is: resetting an environment variable used by the second program.
The method of claim 1 further comprising:

The first sub-process obtains an address of a memory area for storing a first sub-process name, and modifies a parameter value stored in a memory area corresponding to the address;

And/or, also includes:

The second sub-process sends a request to the proxy process;

The agent process acquires an address of a parameter for storing a name of the second child process according to the request, and modifies a parameter value in the address.
The method of claim 1 further comprising:

Storing data modified by a function in the dynamic link library called by the first program in a memory space unique to the first subprocess; and/or

The data modified by the 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, an entry function address of the first program is exported to an executable file of the first program Before the first sub-process calls the entry function of the first program, acquiring an entry function address of the first program according to the executable file of the first program;

When the second program is compiled, the entry function address of the second program is exported to the executable file of the second program; before the second child process calls the entry function of the second program, Obtaining an entry function address of the second program according to the executable file of the second program.
A process management device, comprising:

a startup module, configured to start an agent process, where the agent process loads a dynamic link library linked by the agent process into a memory;

a process creation module, configured to create a first child process, the first child process loading the first program by calling an entry function of the first program;

Creating a second child process, the second child process loading the second program by calling an entry function of the second program;

The first program and the second program share the memory occupied by the dynamic link library.
The apparatus according to claim 11, wherein said startup module is a first process in an operating system, and said proxy process initiated by said startup module is configured to proxy said first process to create a child process .
The device according to claim 11, wherein the process creation module is further configured to: open the dynamic link library in the first sub-process by calling a function for opening a dynamic link library, where The function The input parameter includes the file name of the dynamic link library; and/or

The dynamic link library is opened in the second child process by calling a function for opening a dynamic link library, wherein a file name of the dynamic link library is included in an input parameter of the function.
The apparatus according to claim 11, wherein said first sub-process created by said process creation module modifies a name of said first sub-process to be the same as a name of said first program; and/or

The second sub-process created by the process creation module modifies the name of the second sub-process to be the same as the name of the second program.
The device according to claim 11, wherein the process creation module is further configured to: before creating the first child process, shut down resources that cannot be inherited by the first child process;

Before the second child process is created, resources that cannot be inherited by the second child process are closed.
The device according to claim 11, wherein the environment variable used by the first program is reset before the first child process created by the process creation module calls the entry function of the first program; and / or

The environment variable used by the second program is reset before the second child process created by the process creation module calls the entry function of the second program.
The device of claim 11 further comprising:

a processing module, configured to store data modified by a function in the dynamic link library called by the first program, in a memory space unique to the first sub-process; and/or, to be The data modified by the function in the dynamic link library called by the second program is stored in a memory space unique to the second sub-process.
The apparatus according to any one of claims 11 to 17, wherein 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 sub-process created by the process creation module acquires an entry function address of the first program according to an executable file of the first program;

When the second program is compiled, the entry function address 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 according to the The executable file of the second program acquires the entry function address of the second program.
One or more computer readable mediums having stored thereon instructions that, when executed by one or more processors, cause the communication device to perform the method of any of claims 1-10 .
A process management device comprising:

One or more processors;

One or more computer readable media having instructions stored thereon, the instructions being by the one or The plurality of processors, when executed, cause the apparatus to perform the method of any of claims 1-10.