WO2022237624A1

WO2022237624A1 - Memory allocation method, apparatus and system

Info

Publication number: WO2022237624A1
Application number: PCT/CN2022/091040
Authority: WO
Inventors: 黄强; 李�雨
Original assignee: 华为技术有限公司
Priority date: 2021-05-14
Filing date: 2022-05-05
Publication date: 2022-11-17
Also published as: CN115344507A

Abstract

Provided in the present application are a memory allocation method, apparatus and system. By means of the method, a kernel can execute first-level memory space management to grant part of a physical memory space to a user state process, such that the user state process can allocate the granted physical memory space according to requirements, thereby realizing second-level memory space management. By using a two-level physical memory space management mode, when a kernel is responsible for completing a small amount of work, frequent communications between user state processes are reduced, and the energy consumption and memory allocation time overheads can be reduced, so as to improve the memory allocation efficiency.

Description

Memory allocation method, device and system

This application claims the priority of a Chinese patent application filed with the State Intellectual Property Office of China on May 14, 2021, with application number 202110527267.6 and application title "memory allocation method, device and system", the entire contents of which are incorporated herein by reference Applying.

technical field

The present application relates to the field of computer technology, and more specifically, to a memory allocation method, device and system.

Background technique

When running the operating system, the processor can be divided into two operating modes, kernel mode and user mode, according to the function. When the processor is in the kernel mode, it mainly executes some key tasks of the operating system and controls the hardware resources of the computer. Compared with the kernel mode, the user mode has lower execution authority. When the processor is in the user mode, it mainly executes the application-related processes. By dividing the user mode and the kernel mode, the processor can realize the isolation of system key data and application data and improve security. sex and reliability.

Memory management is an important function of the operating system. It is mainly used for the allocation and use of memory resources, such as allocating the memory space required for the process to run. Memory management can be implemented by the processor in kernel mode or in user mode. When memory management is implemented in user mode, it can reduce the complexity of kernel mode, but the problem is that the memory required by the system service process also needs to apply to the user mode memory management process through inter-process communication (IPC). When the required memory is large, frequent IPC will bring a large overhead. When memory management is implemented in the kernel state, due to the complex data structures and algorithms used in memory management, it will make the formal verification of the kernel and pass high-level security certification very difficult, and increase the probability of being attacked. The memory management method of the current operating system has yet to be optimized.

Contents of the invention

The present application provides a memory allocation method, device and system to improve the working efficiency of memory allocation.

In the first aspect, a memory allocation method is provided, the method includes:

The first user state process receives the task request of the second user state process, and the task request is used to request memory space allocation; the first user state process allocates the first physical memory for the second user state process from the first physical memory space interval, wherein the first physical memory space is the physical memory space authorized by the kernel to the first user mode process.

According to the above scheme, the kernel can perform the first-level memory space management, that is, authorize part of the physical memory space for the first user-mode process, so that the user-mode process can allocate the authorized physical memory space according to the demand, that is, the second-level memory space management, By adopting a two-level physical memory space management method, when the kernel is responsible for completing a small amount of work, frequent communication between user-mode processes is reduced, energy consumption and memory allocation time overhead can be reduced, and memory allocation can be improved. s efficiency.

With reference to the first aspect, in some implementation manners of the first aspect, before the first user-mode process allocates the first physical memory range to the second user-mode process, the method further includes: when the first user-mode process When the size of the free memory space in the second physical memory space authorized by the process does not meet the size of the memory space required by the task request, the process in the first user state applies for physical memory space to the kernel; The process authorizes the third physical memory space, wherein the first physical memory space includes the second physical memory space and the third physical memory space.

According to the above solution, in the case that the authorized physical memory space of the first user state process does not meet the requirements, the first user state process can further apply for physical memory space from the kernel to obtain enough authorized physical memory space, avoiding the Insufficient physical memory space authorized by a user state process causes the second user state process to fail to request memory, which improves the flexibility of physical memory space management.

With reference to the first aspect, in some implementations of the first aspect, the method further includes: allocating a corresponding first virtual memory interval for the first physical memory interval in the first user mode process; The process sends a memory mapping request to the kernel, and the memory mapping request is used for requesting establishment of a mapping relationship between the first physical memory range and the first virtual memory range.

According to the above scheme, after allocating the first physical memory interval, the first user mode process allocates the corresponding first virtual memory interval, and requests the kernel to perform memory mapping to complete the connection between the first physical memory interval and the first virtual memory interval. mapping.

With reference to the first aspect, in some implementation manners of the first aspect, the method further includes: the first user mode process authorizes a physical memory space allocation permission for the third user mode process.

According to the above scheme, the first user state process also has the function of authorizing physical memory space allocation permissions for other user processes (such as the third user state process), so that after the third user state process obtains the allocation authority, it can request the kernel for physical memory space , so that the third user state process can allocate the authorized physical memory space according to the demand, which can prevent the third user state process from requesting physical memory through inter-process communication, reduce the overhead caused by inter-process communication, and improve the efficiency of memory allocation .

Exemplarily, the first user mode process may be a user mode main memory management process, and the third user mode process may be a related process that provides system services.

With reference to the first aspect, in some implementations of the first aspect, the task request is a file mapping request, the first user state process is a file system process or a virtual file system process, and the method further includes: the first user process In response to the file mapping request, the file requested by the file mapping request is mapped to the first physical memory range; the first user process sends the first physical memory range to the second user process.

According to the above scheme, after the first user process receives the task request for file mapping, it allocates the first physical memory interval for the file mapping task, maps the requested file to the first physical memory interval, and then notifies the second user mode process , the first physical memory range allocated by the first user mode process to the file mapping task. This enables the first user state process to allocate a physical memory range for the file mapping task and complete the file mapping, avoiding requesting physical memory through inter-process communication, reducing the overhead caused by inter-process communication, and improving the efficiency of memory allocation.

Exemplarily, the first user mode process may be a user mode virtual file system (VFS) process, and the second user mode process may be a main service process. The main service process obtains the first physical memory interval allocated by the VFS process for the file mapping task through the file mapping request, and then allocates the corresponding virtual address interval for the first physical memory interval, so as to request the kernel to complete the first physical memory interval and the virtual address interval mapping between.

With reference to the first aspect, in some implementations of the first aspect, the task request is a file read/write request, the first user state process is a file system process or a virtual file system process, and the method further includes: the first The user process executes the read/write operation requested by the file read/write request on the first physical memory range.

According to the above scheme, after receiving the file read/write task request, the first user process allocates a first physical memory range for the file read/write task, and will perform read and write operations on the first physical memory range. This enables the first user-mode process to allocate physical memory ranges for file read/write tasks and complete file read/write, avoiding requesting physical memory through inter-process communication, reducing the overhead caused by inter-process communication, and improving the efficiency of memory allocation.

With reference to the first aspect, in some implementations of the first aspect, the method further includes: authorizing the physical memory space allocation authority for the first user-mode process in the second user-mode process.

According to the above scheme, the user state process also has the function of authorizing physical memory space allocation permissions for other user processes (such as the first user state process), which can avoid the need for the user state process to request physical memory through inter-process communication, and reduce the inter-process communication bandwidth. to improve the efficiency of memory allocation.

In a second aspect, a memory allocation device is provided, including: a request unit, configured to send a task request to a first user-mode process in a second user-mode process; The task requests to allocate a first physical memory range, and the first physical memory range belongs to a first physical memory space, and the first physical memory space is a physical memory space authorized by the kernel for the first user mode process.

With reference to the second aspect, in some implementation manners of the second aspect, before the processing unit allocates the first physical memory range to the task request of the second user-mode process by the first user-mode process, the processing unit further uses It is determined that the size of the free memory space in the authorized physical memory space of the first user mode process does not meet the size of the memory space required by the task request; the request unit is also used to apply to the kernel for physical memory in the first user mode process. memory space; the processing unit is further configured to authorize the first physical memory space for the first user mode process in the kernel.

With reference to the second aspect, in some implementation manners of the second aspect, the processing unit is further configured to request allocation of a first virtual memory interval for the task in the first user state process; A user mode process sends a memory mapping request to the kernel, and the memory mapping request is used to request establishment of a mapping relationship between the first physical memory range and the first virtual memory range.

With reference to the second aspect, in some implementation manners of the second aspect, the processing unit is further configured to authorize the physical memory space allocation permission for the third user-mode process in the first user-mode process.

With reference to the second aspect, in some implementations of the second aspect, the task request is a file mapping request, the first user state process is a file system process or a virtual file system process, and the processing unit is further configured to The process responds to the file mapping request, and maps the file requested by the file mapping request to the first physical memory range; and, the device further includes: a transceiver unit, configured to send the second user to the second user in the first user process The process sends the first physical memory range.

With reference to the second aspect, in some implementations of the second aspect, the task request is a file read and write request, the first user mode process is a file system process or a virtual file system process, and the processing unit is further configured to A user process executes the read and write operations requested by the file read and write request on the first physical memory range.

With reference to the second aspect, in some implementation manners of the second aspect, the processing unit is further configured to authorize the physical memory space allocation permission for the first user-mode process in the second user-mode process.

In a third aspect, a communication device is provided, including a processor. The processor may implement the first aspect and the method in any possible implementation manner of the first aspect.

Optionally, the communication device further includes a memory, and the processor is coupled to the memory, and can be used to execute instructions in the memory, so as to implement the above first aspect and the method in any possible implementation manner of the first aspect.

Optionally, the communication device further includes a communication interface, and the processor is coupled to the communication interface.

In this embodiment of the present application, the communication interface may be a transceiver, a pin, a circuit, a bus, a module or other types of communication interfaces, without limitation.

In a fourth aspect, there is provided an operating system, including computer programs and computer program codes. When the computer program codes are invoked, the computer operating system executes the method in the first aspect and any possible implementation manner of the first aspect .

In a fifth aspect, a processor is provided, including: an input circuit, an output circuit, and a processing circuit. The processing circuit is configured to receive a signal through the input circuit and transmit a signal through the output circuit, so that the processor executes the method in the first aspect and any possible implementation manner of the first aspect.

In the specific implementation process, the above-mentioned processor can be one or more chips, the input circuit can be an input pin, the output circuit can be an output pin, and the processing circuit can be a transistor, a gate circuit, a flip-flop and various logic circuits, etc. . The input signal received by the input circuit may be received and input by, for example but not limited to, the receiver, the output signal of the output circuit may be, for example but not limited to, output to the transmitter and transmitted by the transmitter, and the input circuit and the output The circuit may be the same circuit, which is used as an input circuit and an output circuit respectively at different times. The embodiment of the present application does not limit the specific implementation manners of the processor and various circuits.

In a sixth aspect, a computer program product is provided, and the computer program product includes: a computer program (also referred to as code, or an instruction), when the computer program is executed, the computer executes the above-mentioned first aspect and the first aspect A method in any of the possible implementations.

In a seventh aspect, a computer-readable medium is provided, and the computer-readable medium stores a computer program (also referred to as code, or an instruction) which, when running on a computer, causes the computer to execute the above-mentioned first aspect and the first A method in any one of the possible implementations of the aspect.

Description of drawings

FIG. 1 is a schematic diagram of an operating system architecture applicable to the present application;

FIG. 2 is a schematic flowchart of a memory allocation method provided by an embodiment of the present application;

FIG. 3 is a schematic flowchart of Embodiment 1 of the memory allocation method provided by the present application;

FIG. 4 is a schematic flowchart of Embodiment 2 of the memory allocation method provided by the present application;

FIG. 5 is a schematic flowchart of Embodiment 3 of the memory allocation method provided by the present application;

FIG. 6 is a schematic flowchart of Embodiment 4 of the memory allocation method provided by the present application;

FIG. 7 is a schematic block diagram of an example of a communication device provided by the present application;

Fig. 8 is a schematic structural diagram of an example of a communication device provided by the present application.

Detailed ways

The technical solution in this application will be described below with reference to the accompanying drawings.

In order to make the purposes, technical solutions and advantages of the embodiments of the present application clearer, the technical solutions in the embodiments of the present application will be clearly and completely described below in conjunction with the drawings in the embodiments of the present application. Obviously, the described embodiments It is a part of the embodiments of this application, not all of them. Based on the embodiments in this application, all other embodiments obtained by persons of ordinary skill in the art without making creative efforts belong to the scope of protection of this application.

The terms "first", "second" and the like in the description, claims, and above-mentioned drawings of the embodiments of the present application are used to distinguish similar objects, and are not necessarily used to describe a specific sequence or sequence. It is to be understood that the data so used are interchangeable under appropriate circumstances such that the embodiments of the application described herein, for example, can be practiced in sequences other than those illustrated or described herein. Furthermore, the terms "comprising" and "having", as well as any variations thereof, are intended to cover a non-exclusive inclusion, for example, a process, method, system, product or device comprising a sequence of steps or elements is not necessarily limited to the expressly listed instead, may include other steps or elements not explicitly listed or inherent to the process, method, product or apparatus.

First, the relevant technologies and terms involved in this application are introduced.

1. Microkernel architecture

In the microkernel architecture, the functions of the processor running the operating system are divided into the kernel state (in some contexts, it can also be referred to as the kernel for short) and the user state. The kernel state is only responsible for some key business functions, and most of the operating system functions are released. In the user mode, this can ensure the "miniaturization" of the kernel mode. At the same time, different functional modules are managed separately and run in different processes. A problem with one module will not affect other modules, achieving better security and reliability. Typical microkernel architecture operating systems include SeL4, QNX, MINIX, Fuchsia, etc.

2. Macro kernel architecture

In the macro-kernel architecture, all the functions of the processor running the operating system run in the kernel mode to realize a "grand" kernel, because all modules run in one address space and can directly access each other, the macro-kernel architecture can achieve very high efficiency performance, but there are also safety and reliability issues that a module failure will cause the entire kernel to crash. A typical macro-kernel architecture operating system is Linux.

It should be noted that the solutions provided in the present application may be applicable to operating systems with a microkernel architecture and also applicable to operating systems with a macrokernel architecture, which is not limited in this application.

3. System service (system service) process

A system service process can be referred to as a system service or a service process for short. A system service process is a process that performs specified system functions, and usually provides users with some system function services locally and through the network. For example, a system service process can include but is not limited to a file system process (file system, FS), client/server process, Web server process, etc.

The system service process generally runs in the background, and no program window or dialog box will appear to the user application process. You can find the started system service process in the task manager.

FIG. 1 is a schematic diagram of an operating system architecture applicable to this application.

As shown in FIG. 1 , the operating system can be divided into a kernel mode and a user mode according to functional rights. In other words, when the processing device runs an operating system, the working mode of the processing device can include a kernel mode or a user mode. Wherein, the user state mode includes at least one user state process, such as the user state mode may include a system manager (system manager, SYSMGR) process, which is responsible for starting and managing system components and system services, and providing user application (user application, UAPP) requests. Corresponding system services, the user mode can also include a virtual file system process (virtual file system, VFS), which is responsible for managing and storing file information. The user state mode may also include other system service processes, and the present application is not limited thereto. The kernel-mode mode includes at least one kernel-mode process, which is responsible for key business functions. It should be understood that FIG. 1 is only a schematic diagram of a system architecture applicable to an operating system of the present application, but the present application is not limited thereto, and the solutions of the present application may also be applied to operating systems of other system architectures.

At present, there are mainly two ways to implement memory management when the processor runs an operating system: implementation in user mode and implementation in kernel mode.

For example, memory management in an embedded real-time operating system (quick unix, QNX) is completely implemented in user mode, and the kernel is responsible for filling the page table during address space mapping. Taking file reading as an example, the specific process steps are as follows:

Step 1: UAPP sends a file read request to the FS process (hereinafter referred to as FS);

Step 2: FS judges whether the file has been read, and returns after reading, otherwise continue;

Step 3: FS applies for content as a cache memory (cache) to the memory management process;

Step 4: FS reads the file and writes it into the cache;

Step 5: FS copies the content in the cache to the address specified by UAPP;

Step 6: Go back to Step 2.

Among them, in the above step 3, FS needs to apply for cache from the memory management process through inter-process communication (IPC). When the content of the read file is large, the cache allocation in units of pages (page) will be very frequent. Longer and frequent IPCs will affect the performance of file read and write.

For another example, the memory management in the Fuchsia operating system is completely implemented in the kernel mode. The memory allocation operation of the user mode system service process can directly apply to the kernel through system calls. Although it can improve performance, the memory management module in the kernel mode It is relatively large, which makes Fuchsia's kernel larger and more complex than traditional microkernels, and the difficulty and workload of passing various security certifications will be greater.

In view of the above-mentioned problems existing in the memory management methods in the current operating system, this application proposes that the kernel can perform the first-level memory space management, authorize part of the physical memory space for the first user-mode process, and let the user-mode process perform the second-level memory space management , allocate authorized physical memory space according to task requirements, which can prevent user-mode processes from requesting physical memory space from other user-mode processes through inter-process communication (IPC) after receiving task requests, or requesting physical memory space from the kernel through system calls . By adopting a two-level physical memory space management method, when the kernel is responsible for completing a small amount of work, frequent communication between user-mode processes can be reduced, system energy consumption and overhead can be reduced, and the work efficiency of memory allocation can be improved.

The memory allocation method provided by the present application will be described below with reference to the accompanying drawings.

FIG. 2 is a schematic flowchart of the memory allocation method provided by the present application. The memory allocation method may be executed by an operating system, or the memory allocation method may be executed when the processing device runs an operating system, and the operating system includes multiple user state process programs and kernel programs (which may be called kernels). The following uses the memory allocation method of the operating system as an example for illustration, but the present application is not limited thereto.

S210. The kernel authorizes the first physical memory space for the first user mode process.

The processing device runs an operating system whose kernel is used to manage the physical memory space of the operating system. The kernel may be used to authorize part of the physical memory space in the physical memory space of the system for the first user state process, for example, the kernel authorizes the first physical memory space for the first user state process. The first user mode process may allocate the authorized first physical memory space.

As an example without limitation, the first user mode process is a system service process.

It should be noted that the operation of the kernel or the operation of the user-mode process (such as execution, authorization, sending, receiving, determination, management, etc.) involved in this application can be understood as the process that the processing device runs into the operating system. What to do when the process is run, or when the operating system runs into the process.

In one implementation manner, after the operating system creates the first user-mode process, the first user-mode process applies to the kernel for physical memory space. The kernel allocates the first physical memory space for the first user process in response to the application of the first user state process.

In another embodiment, when the authorized physical memory space of the first user mode process is insufficient, as in the authorized physical memory space of the first user mode process, free physical memory (free physical memory can also be referred to as physical memory to be allocated) memory or physical memory to be used) does not meet the size of physical memory requested by other processes, the first user mode process can apply for physical memory space from the kernel. The kernel allocates the first physical memory space for the first user process in response to the application of the first user process.

S220. The first user mode process allocates the first physical memory range in the first physical memory space to the second user mode process.

The first user mode process receives a task request from the second user mode process. For example, the task request may be a file mapping request, a file read and write request, etc. from an application process. The first user state process can determine the memory space size required by the task request, and determine the first physical memory address interval in the first physical memory space authorized by the first user state process, then allocate the first physical memory address interval for the task request A range of memory addresses.

Specifically, the first user mode process judges whether the size of the physical memory space to be allocated in the authorized physical memory space of the first user mode process meets the required size of the task request based on the size of the memory space required by the task request. The size of the memory space. If satisfied, then in the physical memory space to be allocated, allocate a physical memory address interval for the task request; if not satisfied, the first user mode process applies for a physical memory space to the kernel, and the kernel is the authorized part of the first user process In the physical memory space, the first user state process requests to allocate the first physical memory range for the task in the authorized physical memory space.

Optionally, the first user mode process may be the main service process of memory management in the user mode process, or may be called the main memory management process, and the main service process may authorize physical memory space allocation rights for other system service processes.

For example, other system service processes may include a file system process. The main service process authorizes the file system process to allocate physical memory space. After the file system process is authorized to allocate physical memory space, it can apply for physical memory space from the kernel. After the process authorizes part of the physical memory space, the file system process can allocate a physical memory range in the part of the physical memory space for task requests of other processes. But the present application is not limited thereto.

Optionally, after the kernel obtains the request of the user state process to apply for the physical memory space, based on the size of the physical memory space required by the request, it is determined whether the size of the physical memory space to be allocated in the physical memory space managed by the kernel satisfies the request The size of the required memory space. If it is satisfied, part of the physical memory space is authorized for the user-mode process. If it is not satisfied, the kernel can initiate physical memory space recovery, such as initiating a physical memory space request to a user-mode process with physical memory space allocation permissions, thereby reclaiming part of the physical memory space After that, the physical memory space is authorized for the user mode process.

According to the above solution of the present application, the two-level physical memory space management method can reduce frequent communication between user mode processes when the kernel is responsible for completing a small amount of work, and can reduce system energy consumption and overhead.

FIG. 3 is a flow chart of Embodiment 1 of the memory allocation method provided by the present application. FIG. 3 shows a schematic flow chart of memory allocation using the memory allocation method provided by the present application at the startup initialization stage of the operating system.

The process of initializing the processing device to start the operating system includes but is not limited to the following steps:

1. Start the kernel;

2. During the kernel startup process, first create and use a boot allocator (boot allocator) for the memory usage requirements during the kernel startup phase. When the memory usage is completed during the kernel startup process, the life cycle of the boot allocator is ended ;

3. Complete the initialization of metadata for the remaining physical memory space during the kernel startup process;

4. After the initialization of the kernel startup is completed, create a user mode memory management main service process, for example, the memory management main service process can be the system manager SYSMGR process;

5. In the main service process, apply to the kernel for the physical memory space of the main service process;

For example, the main service process (i.e. an example of the first user mode process) may include a first physical memory management algorithm (physical memory management algorithm, PHYMGR), the kernel may include a global PHYMGR (global PHYMGR), and the main service process manages The algorithm applies for a physical memory space to the kernel, and the kernel responds to the application by authorizing part of the physical memory space (that is, an example of the first physical memory space) to the main service process through the global PHYMGR.

6. Complete the initialization of metadata in the physical memory space authorized by the main service process to the main service process;

7. After the initialization of the main service process is completed, create an initialization (initialization, INIT) process;

8. Create other system service processes in the INIT process, for example, create file system processes, etc.;

9. Optionally, the main service process may authorize one or more system service processes to manage physical memory space.

For example, a virtual file system (VFS) process has a higher allocation requirement for physical memory, and the main service process can authorize the physical memory management authority of the VFS process, but the application is not limited thereto. Process physical memory management permissions for processes with high allocation requirements.

10. In step 9, the system service process (that is, another example of the first user mode process) authorized to manage the physical memory applies to the kernel for physical memory space.

11. The system service process authorized with the physical management authority completes the initialization of the metadata of the authorized physical memory space (that is, another example of the first physical memory space). System services that are granted physical management rights have allocation rights to the authorized physical memory space.

12. After performing other remaining operating system start-up processes, complete the start-up of the operating system.

During the initialization phase of the operating system, the kernel authorizes part of the physical memory space for the main service process, so that the main service process can allocate the authorized physical memory space according to the requirements during the running phase of the operating system. Through the polarization management of the physical memory space, the miniaturization of the kernel can be realized, the workload of the kernel can be reduced, and the security of the system can be improved.

FIG. 4 is a schematic flowchart of Embodiment 2 of the memory allocation method provided by the present application. FIG. 4 shows a schematic flow of memory allocation in response to the anonymous memory mapping request of the UAPP after the processing device obtains the anonymous memory mapping request while running the main service process. Wherein, the VFS process can be, for example, as shown in FIG. 3 , authorized by the main service process to manage the physical memory space in the initialization phase, and authorized by the kernel, and the VFS process has a part of the physical memory space allocated with the authority, but the application is not limited thereto.

The process of the processing device responding to UAPP's anonymous memory mapping request includes but is not limited to the following steps:

1. Obtain UAPP's anonymous memory mapping (UAPP anon map with populate) request in the main service process;

Anonymous memory mapping means that the mapped area is not associated with a file.

2. Allocate the corresponding virtual memory interval for the anonymous memory mapping task (or the process that initiates the anonymous memory mapping request) in the main service process;

Wherein, the virtual memory range may be a virtual memory address range, or called a virtual memory address segment, and the physical memory range may be a physical memory address range, or called a physical memory address segment.

3. Determine whether the physical memory space to be allocated in the authorized physical memory space of the main service process is sufficient;

The processing device first needs to determine whether the physical memory space to be allocated in the authorized physical memory space of the main service process can satisfy the size of the memory space required by the memory mapping request. If not satisfied, apply for physical memory space from the kernel in step 4; if satisfied, perform step 8 to allocate a physical memory range for the anonymous memory mapping request in the authorized physical memory space of the main service process;

4. Apply for physical memory space from the kernel in the main service process;

5. The kernel judges whether the physical memory space to be allocated in the global physical memory space is enough;

After the kernel obtains the application of the main service process, the processing device judges whether the size of the physical memory space to be allocated in the global physical memory space satisfies the size of the physical memory space applied by the main service process. If it is satisfied, the kernel authorizes part of the physical memory space for the main service process, and then returns to step 3; if not, initiates memory recovery in step 6.

6. The kernel initiates a memory reclamation request to reclaim part of the physical memory space;

7. When the global physical memory space is sufficient, the kernel authorizes part of the physical memory space for the main service process, and performs metadata initialization on the authorized part of the physical memory space in the main service process, and returns to step 3;

8. In the main service process, allocate a physical memory interval in the authorized physical memory space of the main service process for the anonymous memory mapping task;

9. Initiate a mapping request to the kernel in the main service process, and send the virtual memory interval and physical memory interval allocated for the anonymous memory mapping request to the kernel to initiate a mapping request;

10. The processing unit completes the rest of the process.

FIG. 5 is a schematic flowchart of Embodiment 3 of the memory allocation method provided by the present application. FIG. 5 shows a schematic flow chart of executing a memory allocation process in response to the file mapping request after the processing device acquires a file mapping request from the UAPP while running the main service process. Wherein, the VFS process can be, for example, as shown in FIG. 3 , authorized by the main service process to manage the physical memory space in the initialization phase, and authorized by the kernel, and the VFS process has a part of the physical memory space with the assigned authority, but the application is not limited thereto.

The process of the processing device responding to the file mapping request of UAPP includes but not limited to the following steps:

1. Obtain the UAPP file map (UAPP file map with populate) request in the main service process;

For example, the file mapping request may be that the mmap file mapping function carries a populated flag (with populated flag), but the application is not limited thereto.

2. Allocate a corresponding virtual memory interval for the file mapping task (or the process that initiates the file mapping task) in the main service process;

3. The main service process requests the page cache (page cache) corresponding to the UAPP from the VFS process, and requests the VFS process to provide the physical memory (interval) of the file page corresponding to the UAPP;

4. Determine whether the VFS process has a page cache corresponding to the UAPP, if not, then perform step 5; if so, perform step 11, and return the page cache corresponding to the UAPP to the main service process;

5. Determine whether the authorized physical memory space of the VFS is sufficient;

The processing device first needs to judge whether the physical memory space to be allocated in the authorized physical memory space of the VFS process can satisfy the size of the memory space required by the file mapping request. If not satisfied, apply for physical memory space to the kernel in step 6; if satisfied, perform step 10, in the authorized physical memory space of the VFS process, allocate a physical memory interval as a page cache for the file mapping task.

6. Apply for physical memory space from the kernel in the VFS process;

7. The kernel judges whether the physical memory space to be allocated in the global physical memory space is enough;

After the kernel obtains the application of the VFS process, it judges whether the size of the physical memory space to be allocated in the global physical memory space satisfies the size of the physical memory space applied by the VFS process. If not, initiate memory reclamation in step 8; if satisfied, return to step 5 after the kernel authorizes part of the physical memory space for the VFS process in step 9.

8. The kernel initiates a memory reclamation request to reclaim part of the physical memory space;

9. When the global physical memory space is sufficient, the kernel authorizes part of the physical memory space for the VFS process, and performs metadata initialization on the authorized physical memory space in the VFS process, and returns to step 5;

10. Allocate the physical memory interval of the VFS process as the page cache for the file mapping task in the authorized physical memory space of the VFS process;

Optionally, in the VFS process, a physical memory range is allocated for the file mapping task from authorized physical memory space through a physical memory management algorithm (phymgr) corresponding to the VFS process.

11. Write the file content to the page cache in the VFS process;

12. The VFS process returns the page cache corresponding to the UAPP to the VFS process;

13. Initiate a mapping request to the kernel in the main service process, that is, send the virtual memory interval and physical memory interval allocated for the file mapping request to the kernel to initiate a mapping request;

14. The processing unit completes the remaining process.

It should be understood that, according to the above processing flow, this application allocates and uses physical memory of system services (such as VFS processes, etc.) with clear authority management and operation boundaries, and the physical memory managed by system services is only used to meet its own functions and logic implementation. Needs (such as file mapping tasks, etc.), cannot be used to satisfy the physical memory allocation of the application, and the physical memory allocation of the application is still the responsibility of the main memory management process. This can reduce the frequent interaction between processes, and does not increase the overall memory management complexity. The access control of physical memory is still handled in the main memory management process.

In the current micro-kernel operating system, the file reading and writing performance has obvious disadvantages compared with the macro-kernel operating system. After using the memory allocation method provided by this application, the file reading and writing performance can be equal to or surpass the typical macro-kernel operating system Linux. In the test experiment, the memory allocation method provided by the present application was compared with the read ability and write ability of the Linux operating system in the prior art. For files of the same size, when the same number of bytes is read each time, no matter in the way of sequential reading or random reading, the memory allocation method provided by this application can improve the processing efficiency by more than 35% compared with the Linux operating system . For files of the same size, when the same number of bytes is written each time, no matter in the way of sequential writing or random writing, the memory allocation method provided by this application can improve the processing efficiency by more than 15% compared with the Linux operating system . Especially when a large amount of bytes is written per second, the processing efficiency of the memory allocation method provided by the present application is significantly improved. For example, when 2 megabytes are written per second, the processing efficiency can be increased by 60%.

FIG. 6 is a schematic flowchart of Embodiment 4 of the memory allocation method provided by the present application. FIG. 6 shows a schematic flow chart of executing a memory allocation process in response to the file mapping request after the processing device obtains a file read and write request from UAPP while running a VFS process, wherein the VFS process can be, for example, as shown in FIG. In the initial stage, the main service process is authorized to manage the physical memory space, and is authorized by the kernel, and the VFS process has a part of the physical memory space with the allocation authority, but the application is not limited thereto.

The process of the processing device responding to the file read and write request of UAPP includes but not limited to the following steps:

1. Obtain the file read and write request of UAPP in the VFS process;

The file reading and writing request of UAPP is directly sent to the VFS process, and in response to the file reading and writing request in the VFS process, according to the file indicator fd, call the corresponding read (read) function or write (write) function to find the corresponding file location.

2. Determine whether there is a page cache corresponding to the file; if it does not exist, the processing device executes step 3; if it exists, executes step 9, and performs the corresponding read and write operations of the UAPP request on the page cache;

3. Determine whether the authorized physical memory space of the VFS process is sufficient;

The processing device judges whether the size of the physical memory space to be allocated in the authorized physical memory space satisfies the size of the page cache required by the read-write task. If it is not satisfied, execute step 4 to apply to the kernel for authorization of part of the physical memory space of the VFS process; if satisfied, execute step 8 to allocate a physical memory range for the read and write task as the page cache for the read and write task.

4. Apply for physical memory space from the kernel in the VFS process;

5. The kernel judges whether the global physical memory space is sufficient;

The kernel judges whether the size of the physical memory space to be allocated in the global physical memory space can satisfy the memory space requested by the VFS process. If it is enough, then execute step 7. The kernel authorizes part of the physical memory space for the VFS process; if not, execute step 6. The kernel initiates the memory space space reclamation request;

6. The kernel initiates a memory space reclamation request to reclaim part of the physical memory space that has not been authorized by the VFS process;

7. The kernel authorizes part of the physical memory space for the VFS process, and performs metadata initialization on the authorized physical memory space in the VFS process, and returns to step 3;

8. In the VFS process, allocate the corresponding physical memory range as the page cache for the file reading and writing task;

9. Perform read and write operations on the corresponding page cache of the file in the VFS process;

10. The process ends.

When processing the file reading and writing task shown in Figure 6, the processing device receives the file reading and writing request in the VFS process, and if there is no corresponding page cache, it can read and write the file in the physical memory space authorized by the VFS process Allocate the corresponding page cache. With the permission to allocate physical memory space in the VFS process, it can reduce the inter-process communication overhead caused by the VFS process requesting the physical memory range from the memory management process, and improve the processing efficiency.

The memory allocation method provided by the present application has been described above with reference to FIG. 2 to FIG. 6 . The communication device provided by the present application will be described below with reference to FIG. 7 .

FIG. 7 is a schematic structural diagram of a memory allocation device provided by the present application. As shown in FIG. 7 , the memory allocation device includes a request unit 710 and a processing unit 720 .

The request unit is used to send a task request to the first user mode process in the second user mode process, and the task request is used to request memory space allocation;

A processing unit, configured to allocate a first physical memory range to the task request in the first user state process, the first physical memory range belongs to the first physical memory space, and the first physical memory space is the kernel for the first user The physical memory space authorized by the state process.

Optionally, before the processing unit requests allocation of the first physical memory range for the task of the second user-mode process by the first user-mode process, the processing unit is further configured to determine the authorized first user-mode process 2. The size of the free memory space in the physical memory space does not meet the size of the memory space required by the task request;

The request unit is also used to apply for physical memory space from the kernel in the first user state process;

The processing unit is further configured to authorize a third physical memory space for the first user mode process in the kernel, wherein the first physical memory space includes the second physical memory space and the third physical memory space.

Optionally, the processing unit is further configured to allocate a corresponding first virtual memory interval to the first physical memory interval in the first user mode process;

The request unit is also used to send a memory mapping request to the kernel in the first user mode process, and the memory mapping request is used to request the kernel to establish a mapping relationship between the first physical memory interval and the first virtual memory interval .

Optionally, the processing unit is further configured to authorize the allocation permission of the physical memory space for the third user-mode process in the first user-mode process.

Optionally, the task request is a file mapping request, and the first user mode process is a file system process or a virtual file system process,

The processing unit is further configured to respond to the file mapping request in the first user process, and map the file requested by the file mapping request to the first physical memory interval; and, the device further includes:

A transceiver unit, configured to send the first physical memory range to the second user process in the first user process.

Optionally, the task request is a file read/write request, the first user mode process is a file system process or a virtual file system process, and the processing unit is further configured to perform a process on the first physical memory range in the first user process. Performs the read/write operation requested by the file read/write request.

Optionally, the processing unit is further configured to authorize the physical memory space allocation permission for the first user-mode process in the second user-mode process.

FIG. 8 is a schematic structural diagram of a communication device 800 provided by an embodiment of the present application. The communication device 800 may be configured with an operating system as shown in FIG. 1 . The communication device 800 includes a bus 840 and a processor 810 connected to the bus 840 , and the communication device 800 may also include a communication interface 820 and a memory 830 .

It should be understood that the communication device 800 shown in FIG. 8 can implement each process of the memory allocation method in any method embodiment. The operations and/or functions of the various modules in the communication device 800 are respectively for implementing the corresponding procedures in the foregoing method embodiments. For details, reference may be made to the descriptions in the foregoing method embodiments, and detailed descriptions are appropriately omitted here to avoid repetition.

Optionally, the communication device may be a terminal, and may also be called user equipment (user equipment, UE), and the communication device may be a mobile phone, a tablet computer, or a computer device.

The embodiment of the present application also provides a computer operating system, including: computer program code, which causes the computer operating system to execute the method in any one of the above method embodiments when the computer program code is invoked.

The embodiment of the present application also provides a processing device, including a processor and an interface; the processor is configured to execute the method in any one of the above method embodiments.

The present application also provides a computer program product, the computer program product including: computer program code, when the computer program code is executed by one or more processors, the device including the processor executes any one of the above method embodiments Methods.

The present application also provides a computer-readable storage medium, the computer-readable storage medium stores program code, and when the program code is run by one or more processors, the device including the processor executes any one of the above methods. method in the example.

In the embodiments of the present application, on the premise that there is no logical contradiction, the various embodiments may refer to each other, for example, the methods and/or terms between the method embodiments may refer to each other, such as the functions and/or terms between the device embodiments Or terms may refer to each other, for example, functions and/or terms between the apparatus embodiment and the method embodiment may refer to each other.

The above is only a specific implementation of the application, but the scope of protection of the application is not limited thereto. Anyone familiar with the technical field can easily think of changes or substitutions within the technical scope disclosed in the application. Should be covered within the protection scope of this application. Therefore, the protection scope of the present application should be determined by the protection scope of the claims.

Claims

A memory allocation method, characterized in that, comprising:

The first user mode process receives the task request of the second user mode process, and the task request is used to request memory space allocation;

The first user-mode process allocates a first physical memory range to the second user-mode process from the first physical memory space, wherein the first physical memory space is a physical space authorized by the kernel to the first user-mode process. memory space.
The method according to claim 1, wherein, before the first user mode process allocates the first physical memory interval for the second user mode process from the first physical memory space, the method further comprises include:

When the size of the free memory space in the second physical memory space authorized by the first user mode process does not meet the size of the memory space required by the task request, the first user mode process applies to the kernel for physical memory space ;

The kernel authorizes a third physical memory space for the first user mode process, wherein the first physical memory space includes the second physical memory space and the third physical memory space.
The method according to claim 1 or 2, characterized in that the method further comprises:

The first user state process allocates a corresponding first virtual memory interval for the first physical memory interval;

The first user state process sends a memory mapping request to the kernel, where the memory mapping request is used to request the kernel to establish a mapping relationship between the first physical memory interval and the first virtual memory interval.
The method according to any one of claims 1 to 3, wherein the method further comprises:

The first user mode process authorizes the allocation authority of the physical memory space for the third user mode process.
The method according to claim 1 or 2, wherein the task request is a file mapping request, and the first user state process is a file system process or a virtual file system process, and the method further comprises:

The first user mode process responds to the file mapping request, and maps the file requested by the file mapping request to the first physical memory interval;

The first user mode process sends the first physical memory range to the second user process.
The method according to claim 1 or 2, wherein the task request is a file read/write request, and the first user mode process is a file system process or a virtual file system process, and the method further comprises:

The first user state process executes the read/write operation requested by the file read/write request on the first physical memory range.
The method according to claim 1, 2, 5 or 6, wherein the method further comprises:

The second user mode process authorizes the physical memory space allocation permission for the first user mode process.
A memory allocation device, characterized in that it comprises:

A request unit, configured to send a task request to the first user mode process in the second user mode process, and the task request is used to request memory space allocation;

A processing unit, configured to allocate a first physical memory interval to the task request in the first user state process, the first physical memory interval belongs to a first physical memory space, and the first physical memory space is a kernel of The physical memory space authorized by the first user mode process.
The device according to claim 8, characterized in that

Before the processing unit requests allocation of the first physical memory range for the task request of the second user state process by the first user state process, the processing unit is further configured to determine the authorization of the first user state process The size of the free memory space in the second physical memory space does not meet the size of the memory space required by the task request;

The request unit is further configured to apply for physical memory space from the kernel in the first user state process;

The processing unit is further configured to authorize a third physical memory space for the first user mode process in the kernel, wherein the first physical memory space includes the second physical memory space and the third physical memory space memory space.
A device according to claim 8 or 9, characterized in that

The processing unit is further configured to allocate a corresponding first virtual memory interval to the first physical memory interval in the first user mode process;

The request unit is further configured to send a memory mapping request to the kernel in the first user state process, and the memory mapping request is used to request the kernel to establish the first physical memory interval and the first virtual The mapping relationship between memory ranges.
The device according to any one of claims 8 to 10, wherein the processing unit is further configured to authorize, in the first user mode process, an allocation authority of physical memory space for a third user mode process.
The device according to claim 8 or 9, wherein the task request is a file mapping request, and the first user state process is a file system process or a virtual file system process,

The processing unit is further configured to respond to the file mapping request in the first user process, and map the file requested by the file mapping request to the first physical memory interval; and, the device further includes:

A transceiver unit, configured to send the first physical memory range to the second user process in the first user process.
The device according to claim 8 or 9, wherein the task request is a file read/write request, and the first user state process is a file system process or a virtual file system process,

The processing unit is further configured to perform the read/write operation requested by the file read/write request on the first physical memory range in the first user process.
The device according to claim 8, 9, 12 or 13, wherein the processing unit is further configured to authorize the physical memory space allocation permission for the first user state process in the second user state process.
A memory allocation device, characterized in that it includes at least one processor coupled to the memory;

The memory is used to store programs or instructions;

The at least one processor is configured to execute the program or instructions, so that the device implements the method according to any one of claims 1-7.
A computer-readable storage medium comprising a computer program which, when executed by one or more processors, causes an apparatus comprising said processors to perform the method as claimed in any one of claims 1 to 7.
A computer program product, characterized in that the computer program product includes computer instructions, and the computer instructions instruct a computing device to perform the method according to any one of claims 1 to 7.
A chip, characterized in that it includes at least one processor and a communication interface;

The communication interface is used to receive a signal input to the chip or a signal output from the chip, and the processor communicates with the communication interface and executes a code instruction through a logic circuit or to implement the process described in claims 1 to 7. any one of the methods described.