A shared memory pool implementation method and system
By dividing the shared memory pool into different regions, the problem of low memory pool management efficiency in existing technologies is solved, achieving more efficient memory allocation and reducing system interactions, thereby improving performance.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- 上海沄熹科技有限公司
- Filing Date
- 2022-09-30
- Publication Date
- 2026-04-21
AI Technical Summary
In existing technologies, memory pool settings are relatively simple, which cannot effectively manage memory allocation, resulting in low memory utilization efficiency and the inability to optimize for different types of memory requests.
The shared memory pool is divided into different heap areas, including Header Heap, Data Heap, Common Heap, Free Heap, and System Heap areas, which are used to store database header information, database data, temporary data, and metadata, respectively. Memory blocks are dynamically allocated to other areas through the Free Heap area to meet different memory requirements.
It improves the utilization efficiency of the memory pool, reduces the number of interactions with the operating system, and optimizes the memory allocation method, especially with a significant performance improvement for a large number of threads.
Smart Images
Figure CN115599542B_ABST
Abstract
Description
Technical Field
[0001] This invention discloses a method and system, relating to the field of shared memory management technology, specifically a method and system for implementing a shared memory pool. Background Technology
[0002] Memory pools are a memory management technique. They are typically used in server-side backend development to avoid frequent memory allocation and deallocation from the heap. This trade-off between space and time improves operational efficiency and the reliability of the backend system. However, current memory pool configurations are relatively simplistic. There are no effective management mechanisms for memory allocation from the pool, no way to allocate memory based on allocation type, and no dynamic management of memory pool allocation, thus hindering further improvements in memory pool utilization efficiency. Summary of the Invention
[0003] This invention addresses the problems of existing technologies by providing a shared memory pool implementation method and system. It constructs a shared memory pool, requests memory using the shared memory pool, and allocates memory according to the internal structure of each region of the shared memory pool. This method is fast and greatly reduces interaction with the operating system, thereby reducing unnecessary consumption.
[0004] The specific solution proposed in this invention is as follows:
[0005] This invention provides a method for implementing a shared memory pool. It requests memory from the operating system to form a shared memory pool, divides the shared memory pool into different heap regions, and utilizes memory blocks of different sizes in different heap regions for memory storage and use.
[0006] The heap areas include, in sequence, the Header Heap area, the Data Heap area, the Free Heap area, the Common Heap area, and the System Heap area.
[0007] The header information for the database and shared memory is stored in the Header Heap area.
[0008] Database data is stored in the Data Heap area, and the memory block size of the Data Heap area is fixed.
[0009] The Common Heap area is used for temporary data processing or communication; the memory block size of the Common Heap area is not fixed.
[0010] Metadata is stored in the System Heap area.
[0011] The memory blocks in the Free Heap area are dynamically allocated to other heap areas that do not have free memory, so that other heap areas can provide memory storage and use.
[0012] Furthermore, in the shared memory pool implementation method described above, receiving thread requests through the Free Heap area indicates that the thread has requested memory from other heap areas and that the corresponding other heap areas have no free memory.
[0013] The system searches for the smallest memory block within the Free Heap region that matches the memory requested by the thread. If a matching smallest memory block is found, it is provided to other Heap regions so that the thread can obtain the corresponding memory. If no matching smallest memory block is found, the system triggers the GC process in other Heap regions through the shared memory pool, storing the free memory released by the GC process in other Heap regions into the Free Heap region in order to obtain a matching smallest memory block.
[0014] Furthermore, the search in the shared memory pool implementation method includes: using a prefix tree that reflects the mapping relationship between memory blocks and pages to find the smallest memory block in the Free Heap region that meets the memory request of the thread, where the page is the smallest memory request unit in the heap region of the shared memory pool.
[0015] Furthermore, the method for implementing a shared memory pool, which involves providing a minimum memory block to other Heap regions so that threads can acquire the requested memory, includes:
[0016] Obtain the minimum memory block, divide the minimum memory block to obtain the corresponding memory requested by the thread, and provide it to the corresponding other Heap areas.
[0017] Furthermore, the method for implementing a shared memory pool, which involves storing free memory released by the GC process in other Heap regions into the Free Heap region, includes:
[0018] Obtain the free memory, determine whether there is a free memory block among adjacent pages in the Free Heap area according to the prefix tree, if there is, merge the free memory and the free memory block to form a new memory block, and store the mapping relationship between the new page and the memory block in the prefix tree.
[0019] Furthermore, the specific steps in the shared memory pool implementation method are as follows:
[0020] Requests are received through the Free Heap region;
[0021] Use a prefix tree to find the smallest memory block in the Free Heap region that matches the memory requested by the thread. If a matching smallest memory block is found, then cut out the corresponding memory requested by the thread from the smallest memory block.
[0022] If no matching minimum memory block is found, the GC process in other Heap regions is triggered through the shared memory pool. Free memory released by the GC process in other Heap regions is stored in the Free Heap region. A prefix tree is used to determine if there is a free memory block between adjacent pages in the Free Heap region. If so, the free memory and the free memory block are merged to form a new memory block, and the mapping relationship between the new page and the memory block is stored in the prefix tree. If no matching memory block is found, the free memory is directly stored in the memory block of the Free Heap region.
[0023] Re-search the Free Heap region for the smallest memory block that matches the memory requested by the thread. If a matching smallest memory block is found, the corresponding memory requested by the thread is allocated from the smallest memory block. If no matching smallest memory block is found, an error is returned.
[0024] Furthermore, in the shared memory pool implementation method described above, thread requests are received through the System Heap area, and the size of the requested memory is determined. If it exceeds a set value, an error is reported.
[0025] If the value is less than the set value, the system searches for a memory block in the System Heap region that matches the thread's memory request size. This memory block is the Central cache, which is shared by the threads. If a matching memory block is found in the Central cache, it is returned to the thread. If no matching memory block is found in the Central cache, the system checks the Free Heap region for any free memory blocks to provide to the thread.
[0026] Furthermore, the method for implementing a shared memory pool, which involves checking the Free Heap region for free memory blocks, includes:
[0027] Check if there is a memory block in the Free Heap region that matches the thread's request. If not, return an error. Otherwise, round up the size of the memory requested by the thread to get the corresponding page number, put the memory block corresponding to the page into the central cache, and provide it to the thread for the requested memory.
[0028] This invention also provides a shared memory pool implementation system, including a shared memory pool management module.
[0029] The shared memory pool management module requests memory from the operating system to form a shared memory pool, divides the shared memory pool into different heap regions, and utilizes memory blocks of different sizes in different heap regions for memory storage and use.
[0030] The heap areas include, in sequence, the Header Heap area, the Data Heap area, the Free Heap area, the Common Heap area, and the System Heap area.
[0031] The header information for the database and shared memory is stored in the Header Heap area.
[0032] Database data is stored in the Data Heap area, and the memory block size of the Data Heap area is fixed.
[0033] The Common Heap area is used for temporary data processing or communication; the memory block size of the Common Heap area is not fixed.
[0034] Metadata is stored in the System Heap area.
[0035] The Free Heap region dynamically allocates memory blocks to replace other heap regions with no free memory to provide memory storage and use.
[0036] The present invention also provides a shared memory pool implementation apparatus, including at least one memory and at least one processor;
[0037] The at least one memory is used to store a machine-readable program;
[0038] The at least one processor is used to call the machine-readable program to execute the shared memory pool implementation method.
[0039] The advantages of this invention are:
[0040] This invention provides a shared memory pool implementation method, which divides the heap into different regions and utilizes memory blocks of different sizes in each heap region for memory storage and use. For static data, the Header heap region stores header information; for database data, the Data heap region stores it; for temporary data, the Common heap region stores it; and for metadata information, the System heap region stores it. The Free heap region holds the free memory of the memory pool, and memory blocks from this region are allocated to other heap regions without free memory, so that other heap regions can provide memory storage and use. This invention not only reduces the number of times threads request memory from the operating system, significantly improving performance in scenarios with a large number of threads, but also reduces memory allocation time by using specific memory allocation methods for specific data. Attached Figure Description
[0041] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.
[0042] Figure 1 This is a schematic diagram of the shared memory pool structure in the method of the present invention.
[0043] Figure 2 This is a schematic diagram of the prefix tree mapping structure involved in the method of this invention.
[0044] Figure 3 This is a schematic diagram illustrating the process of a thread requesting memory from the Free Heap region in the method of this invention.
[0045] Figure 4 This is a schematic diagram of the process of a thread requesting memory from the System Heap region in the method of this invention. Detailed Implementation
[0046] The terms involved in this invention are:
[0047] Memory (RAM) is a crucial component of a computer, also known as internal memory or main memory. It temporarily stores data used for CPU operations, as well as data exchanged with external storage devices such as hard drives. It acts as a bridge between external storage and the CPU. All programs in a computer run within RAM, and the performance of RAM directly impacts the overall performance of the computer. Once the computer starts running, the operating system retrieves the necessary data from RAM to the CPU for processing. After the processing is complete, the CPU sends the result back to the CPU.
[0048] A shared memory pool requests memory from the operating system and divides this memory into different regions. When subsequent threads request memory, they can directly request it from the memory pool without interacting with the operating system. This approach can reduce the system overhead of interacting with the operating system.
[0049] Free Heap: Because the shared memory pool requests the maximum available shared memory from the operating system at a time, there is a portion of memory within the shared memory pool that is not used by any thread or process. This type of memory is called free memory and is placed in an area called the Free Heap.
[0050] The System Heap is used to store metadata information of the system or platform, such as data about devices and collection points. It is a Heap area with low data modification frequency.
[0051] For other terms involved, please refer to the explanations in the existing technology.
[0052] The present invention will be further described below with reference to the accompanying drawings and specific embodiments, so that those skilled in the art can better understand and implement the present invention. However, the embodiments described are not intended to limit the present invention.
[0053] This invention provides a method for implementing a shared memory pool. It requests memory from the operating system to form a shared memory pool, divides the shared memory pool into different heap regions, and utilizes memory blocks of different sizes in different heap regions for memory storage and use.
[0054] The heap areas include, in sequence, the Header Heap area, the Data Heap area, the Free Heap area, the Common Heap area, and the System Heap area.
[0055] The header information for the database and shared memory is stored in the Header Heap area.
[0056] Database data is stored in the Data Heap area, and the memory block size of the Data Heap area is fixed.
[0057] The Common Heap area is used for temporary data processing or communication; the memory block size of the Common Heap area is not fixed.
[0058] Metadata is stored in the System Heap area.
[0059] The memory blocks in the Free Heap area are dynamically allocated to other heap areas that do not have free memory, so that other heap areas can provide memory storage and use.
[0060] The method of this invention utilizes different shared memory pool Heap regions to handle massive amounts of data storage for different memory requests. This reduces the number of memory requests and the time spent by the database, greatly reducing interaction with the operating system and thus reducing unnecessary overhead. In addition, different objects request different types of memory, and the methods for requesting different types of memory are also different. For specific objects, different data structures can be used to minimize the burden of memory requests and greatly improve efficiency.
[0061] In specific applications, in some embodiments of the method of the present invention, memory is requested from the operating system as a shared memory pool, and the shared memory pool is divided into different heap regions, as shown in the reference. Figure 1 ,
[0062] The header heap area is a static memory area that stores header information for the database and shared memory. This information is loaded into memory after boot and remains almost unchanged.
[0063] The Data heap area, as shown in the figure, is the TimeSeries Data of the time-series database. It stores time-series data and indexes, and mainly stores the collected time-series data on the T end. The memory block size is generally fixed.
[0064] The system heap area stores metadata information such as platform or system data, including device and data collection points, and the data is modified infrequently.
[0065] The Common heap area stores data of varying sizes and is primarily used for temporary data, such as for computations or communication. It may be frequently allocated, released, or modified.
[0066] The Free Heap region dynamically allocates memory blocks from this region to other heap regions that do not have free memory, so that other heap regions can provide memory storage and use.
[0067] To further explain, when the shared memory pool is created, initialization is performed first. Shared memory is requested from the operating system according to preset parameters and the size is fixed. Then, the initialization of different memory regions of the memory pool is completed. Specifically, the header heap region is initialized by extracting a fixed-size portion of the shared memory pool from the beginning to the end. The data heap region is initialized by initializing a minimum required TS data memory region after the header, creating a fixed-size memory management data structure based on the memory block size predefined by the storage engine. The system heap region is located at the end of the shared memory pool.
[0068] The process of a thread requesting memory in the shared memory pool is mainly explained using the Free Heap area and the System heap area.
[0069] The Free Heap region is the memory within the Free Space of the shared memory pool. The Free Heap region uses a prefix tree to represent the mapping relationship between memory block spans and pages. (See reference...) Figure 2 A page is the smallest unit of memory allocation in a shared memory pool, such as 4K or 8K.
[0070] In the workflow of the Free Heap area, when a thread request is received through the Free Heap area, it indicates that the thread has requested memory from other heap areas and those other heap areas do not have free memory.
[0071] The system searches for the smallest memory block within the Free Heap region that matches the thread's memory request. If a matching block is found, it is provided to other Heap regions so the thread can acquire the requested memory. If no matching block is found, the system triggers garbage collection (GC) processes in other Heap regions via a shared memory pool. Free memory released by GC in other Heap regions is then stored in the Free Heap region to obtain the matching block. Further details can be found in [reference needed]. Figure 3 The specific steps are as follows:
[0072] Requests are received through the Free Heap region;
[0073] Use a prefix tree to find the smallest memory block in the Free Heap region that matches the memory requested by the thread. If a matching smallest memory block is found, then cut out the corresponding memory requested by the thread from the smallest memory block.
[0074] If no matching minimum memory block is found, the GC process in other Heap regions is triggered through the shared memory pool. Free memory released by the GC process in other Heap regions is stored in the Free Heap region. A prefix tree is used to determine if there is a free memory block between adjacent pages in the Free Heap region. If so, the free memory and the free memory block are merged to form a new memory block, and the mapping relationship between the new page and the memory block is stored in the prefix tree. If no matching memory block is found, the free memory is directly stored in the memory block of the Free Heap region.
[0075] Re-search the Free Heap region for the smallest memory block that matches the memory requested by the thread. If a matching smallest memory block is found, the corresponding memory requested by the thread is allocated from the smallest memory block. If no matching smallest memory block is found, an error is returned.
[0076] The System heap area primarily stores metadata information such as platform or system metadata. This includes system module metadata, system configuration parameters, connection information, error stack, log / trace, etc. The System heap area is a memory allocation and deallocation area with an indefinite size but an upper limit. Compared to the ordinary data in the Common Heap area, the metadata is modified less frequently, and the number of memory block allocations and deallocations in the System Heap is also lower.
[0077] The System Heap memory blocks adopt a Central cache structure, in which each thread has its own thread cache, and all threads share a central cache. The central cache structure is mainly an array of several fixed-size linked lists (freelists), with a maximum size of 256K and a minimum size of 8 bytes. The freelists in the Central cache use a lock-free approach to ensure thread safety and improve concurrency efficiency.
[0078] In the System Heap area's workflow, thread requests are received through the System Heap area. The size of the requested memory is then determined, and an error is reported if it exceeds a set value of 256K.
[0079] If the memory size is less than the set value of 256K, the thread searches the Central cache for a freelist that matches its memory size requirement. If a matching freelist is found in the Central cache, the corresponding memory is returned to the thread. If no matching freelist is found in the Central cache, the thread is checked in the Free Heap region for available memory blocks. Further, checking the Free Heap region for available memory blocks includes:
[0080] Check if there is a memory block in the Free Heap region that matches the thread's request. If not, return an error. Otherwise, round up the size of the memory requested by the thread to get the corresponding number of pages, put the memory block corresponding to the number of pages into the central cache, and the thread will request the memory block from the central cache, thus completing the memory request.
[0081] This invention also provides a shared memory pool implementation system, including a shared memory pool management module.
[0082] The shared memory pool management module requests memory from the operating system to form a shared memory pool, divides the shared memory pool into different heap regions, and utilizes memory blocks of different sizes in different heap regions for memory storage and use.
[0083] The heap areas include, in sequence, the Header Heap area, the Data Heap area, the Free Heap area, the Common Heap area, and the System Heap area.
[0084] The header information for the database and shared memory is stored in the Header Heap area.
[0085] Database data is stored in the Data Heap area, and the memory block size of the Data Heap area is fixed.
[0086] The Common Heap area is used for temporary data processing or communication; the memory block size of the Common Heap area is not fixed.
[0087] Metadata is stored in the System Heap area.
[0088] The Free Heap region dynamically allocates memory blocks to replace other heap regions with no free memory to provide memory storage and use.
[0089] The information interaction and execution process between the modules in the above system are based on the same concept as the method embodiment of the present invention, and the specific details can be found in the description in the method embodiment of the present invention, and will not be repeated here.
[0090] Similarly, this invention divides the shared memory pool into different heap regions, using different heap regions to provide memory blocks of different sizes for memory storage and use. For static data, the Header heap region stores header information; for database data, the Data heap region stores it; for temporary data, the Common heap region stores it; and for metadata information, the System heap region stores it. The Free Heap region holds free memory from the memory pool, allocating memory blocks from this region to other heap regions without free memory, so that other heap regions can provide memory storage and use. This invention not only reduces the number of times threads request memory from the operating system, significantly improving performance in cases with a large number of threads, but also reduces memory allocation time by using specific memory allocation methods for specific data.
[0091] The present invention also provides a shared memory pool implementation apparatus, including at least one memory and at least one processor;
[0092] The at least one memory is used to store a machine-readable program;
[0093] The at least one processor is used to call the machine-readable program to execute the shared memory pool implementation method.
[0094] The information interaction and execution process of the processor in the above-mentioned device are based on the same concept as the method embodiment of the present invention, and the specific details can be found in the description of the method embodiment of the present invention, and will not be repeated here.
[0095] Similarly, the device of this invention divides the shared memory pool into different heap regions, using different heap regions to provide memory blocks of different sizes for memory storage and use. For static data, the header heap region stores header information; for database data, the data heap region stores it; for temporary data, the common heap region stores it; and for metadata information, the system heap region stores it. The free heap region holds the free memory of the memory pool, allocating memory blocks from this region to other heap regions without free memory so that other heap regions can provide memory storage and use. This method not only reduces the number of times threads request memory from the operating system, greatly improving performance in the case of a large number of threads, but also reduces the time spent requesting memory by using specific memory allocation methods for specific data.
[0096] It should be noted that not all steps and modules in the above processes and system structures are mandatory; some steps or modules can be omitted as needed. The execution order of the steps is not fixed and can be adjusted as required. The system structures described in the above embodiments can be physical or logical structures. That is, some modules may be implemented by the same physical entity, or some modules may be implemented by multiple physical entities, or they may be implemented by certain components in multiple independent devices.
[0097] The above-described embodiments are merely preferred embodiments provided to fully illustrate the present invention, and the scope of protection of the present invention is not limited thereto. Equivalent substitutions or modifications made by those skilled in the art based on the present invention are all within the scope of protection of the present invention. The scope of protection of the present invention is defined by the claims.
Claims
1. A method for implementing a shared memory pool, characterized in that: Memory is requested from the operating system to form a shared memory pool. This shared memory pool is then divided into different heap regions, each providing memory blocks of different sizes for storage and use. The heap areas include, in sequence, the Header Heap area, the Data Heap area, the Free Heap area, the Common Heap area, and the System Heap area. The header information for the database and shared memory is stored in the Header Heap area. Database data is stored in the Data Heap area, and the memory block size of the Data Heap area is fixed. The Common Heap area is used for temporary data processing or communication; the memory block size of the Common Heap area is not fixed. Metadata is stored in the System Heap area. The memory blocks in the Free Heap area are dynamically allocated to other heap areas that do not have free memory, so that other heap areas can provide memory storage and use.
2. The method of claim 1, wherein Receiving a thread request through the Free Heap area indicates that the thread has requested memory from other heap areas and those other heap areas do not have free memory. The system searches for the smallest memory block within the Free Heap region that matches the memory requested by the thread. If a matching smallest memory block is found, it is provided to other Heap regions so that the thread can obtain the corresponding memory. If no matching smallest memory block is found, the system triggers the GC process in other Heap regions through the shared memory pool, storing the free memory released by the GC process in other Heap regions into the Free Heap region in order to obtain a matching smallest memory block.
3. The method of claim 2, wherein the shared memory pool is implemented by The search includes: using a prefix tree that reflects the mapping relationship between memory blocks and pages to find the smallest memory block in the Free Heap region that meets the memory request of the thread, where the page is the smallest memory request unit in the heap region of the shared memory pool.
4. The shared memory pool implementation method according to claim 2 or 3, characterized in that The provision of minimum memory blocks to other Heap regions so that threads can acquire the requested memory includes: Obtain the minimum memory block, divide the minimum memory block to obtain the corresponding memory requested by the thread, and provide it to the corresponding other Heap areas.
5. The method of claim 2, wherein The step of storing free memory released by the GC process in other Heap regions into the Free Heap region includes: Obtain the free memory, determine whether there is a free memory block among adjacent pages in the Free Heap area according to the prefix tree, if there is, merge the free memory and the free memory block to form a new memory block, and store the mapping relationship between the new page and the memory block in the prefix tree.
6. The method of claim 2, wherein the shared memory pool is implemented by The specific steps are as follows: Requests are received through the Free Heap region; Use a prefix tree to find the smallest memory block within the Free Heap region that matches the memory request of the specified thread. If a suitable minimum memory block is found, the corresponding memory requested by the thread is cut out from the minimum memory block; If no matching minimum memory block is found, the GC process in other Heap regions is triggered through the shared memory pool. Free memory released by the GC process in other Heap regions is stored in the Free Heap region. A prefix tree is used to determine if there is a free memory block between adjacent pages in the Free Heap region. If so, the free memory and the free memory block are merged to form a new memory block, and the mapping relationship between the new page and the memory block is stored in the prefix tree. If no matching memory block is found, the free memory is directly stored in the memory block of the Free Heap region. Re-search the Free Heap region for the smallest memory block that matches the memory requested by the thread. If a matching smallest memory block is found, the corresponding memory requested by the thread is allocated from the smallest memory block. If no matching smallest memory block is found, an error is returned.
7. The method of claim 1, wherein the shared memory pool is implemented by The system receives thread memory requests through the System Heap area, checks the size of the requested memory, and throws an error if the size exceeds a set value. If the value is less than the set value, the system searches for a memory block in the System Heap region that matches the thread's memory request size. This memory block is the Central cache, which is shared by the threads. If a matching memory block is found in the Central cache, it is returned to the thread. If no matching memory block is found in the Central cache, the system checks the Free Heap region for any free memory blocks to provide to the thread.
8. The method of claim 7, wherein the shared memory pool is implemented by The step of checking the Free Heap region for free memory blocks includes: Check if there is a memory block in the Free Heap region that matches the thread's request. If not, return an error. Otherwise, round up the size of the memory requested by the thread to get the corresponding page number, put the memory block corresponding to the page into the central cache, and provide it to the thread for the requested memory.
9. A shared memory pool implementation system characterized by Includes a shared memory pool management module. The shared memory pool management module requests memory from the operating system to form a shared memory pool, divides the shared memory pool into different heap regions, and utilizes memory blocks of different sizes in different heap regions for memory storage and use. The heap areas include, in sequence, the Header Heap area, the Data Heap area, the Free Heap area, the Common Heap area, and the System Heap area. The header information for the database and shared memory is stored in the Header Heap area. Database data is stored in the Data Heap area, and the memory block size of the Data Heap area is fixed. The Common Heap area is used for temporary data processing or communication; the memory block size of the Common Heap area is not fixed. Metadata is stored in the System Heap area. The Free Heap region dynamically allocates memory blocks to replace other heap regions with no free memory to provide memory storage and use.
10. A shared memory pool implementation apparatus, characterized in that: Includes at least one memory and at least one processor; The at least one memory is used to store a machine-readable program; The at least one processor is configured to invoke the machine-readable program to execute a shared memory pool implementation method according to any one of claims 1 to 8.