Multi-agent process engine system and method for realizing context based on memory level
By implementing a multi-agent process engine system based on memory-level context, and utilizing off-heap memory pools and differential persistence mechanisms, the problems of serialization overhead and low memory efficiency in agent process engines are solved, achieving efficient data transfer and storage optimization, and improving system performance and scalability.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2025-12-08
- Publication Date
- 2026-04-03
AI Technical Summary
Existing intelligent agent process engines suffer from problems such as accumulated serialization/deserialization overhead, low memory usage efficiency, and coarse persistence mechanisms in multi-node scenarios, resulting in significant latency and wasted storage space.
A multi-agent process engine system based on memory-level implementation context is adopted. It optimizes memory usage through off-Heap memory pool, eliminates serialization overhead for data transfer between nodes, and reduces I/O operation frequency by adopting differential persistence mechanism, thereby achieving efficient memory management and data transfer.
It significantly improves system performance, reduces multi-node process latency by more than 60%, increases system throughput, optimizes memory resource utilization, supports dynamic expansion of complex workflows, and improves system observability and debugging efficiency.
Smart Images
Figure CN121785764A_ABST
Abstract
Description
Technical Field
[0001] This invention discloses a multi-agent process engine system and method based on memory-level implementation context, which relates to the field of agent application development technology. Background Technology
[0002] Existing intelligent agent workflow engines such as LangChain, LangGraph, and Dify generally use JSON serialization and deserialization for data transfer between nodes. While JSON format offers good readability and compatibility, it has the following inherent drawbacks in multi-node intelligent agent workflows:
[0003] Cumulative Serialization / Deserialization Overhead: Each node's execution requires a complete JSON serialization and deserialization operation. As the number of nodes increases, the overhead of these operations grows linearly, leading to significant latency. In complex business scenarios, the agent process may contain dozens of nodes, with cumulative latency reaching hundreds of milliseconds or even seconds.
[0004] Inefficient memory usage: Serialization requires the creation of a large number of intermediate objects, increasing memory allocation pressure and garbage collection burden, and reducing system throughput.
[0005] The persistence mechanism is crude: Existing systems usually adopt the full state persistence method, writing the complete context data when logization or fault recovery is required, resulting in wasted storage space and I / O bottlenecks. Summary of the Invention
[0006] This invention aims to solve the problem of multi-agent process latency caused by serialization / deserialization in existing technologies. It provides a multi-agent process engine system and method based on memory-level context implementation, eliminating the serialization overhead of data transmission between nodes, improving execution efficiency through direct memory access, and providing a unified memory context management mechanism to ensure data security and isolation. It also achieves efficient differential persistence, reducing I / O operation frequency and storage requirements, and optimizes memory usage through off-heap memory pools to improve system throughput.
[0007] The specific solution proposed in this invention is as follows:
[0008] This invention provides a method for a multi-agent process engine based on memory-level context implementation, comprising:
[0009] A multi-agent process engine system based on memory-level implementation context is created. The system includes a memory context management module, a process execution engine module, a reading module, and a processing module.
[0010] Step 1: Initialize and allocate the memory context for the off-heap memory pool:
[0011] The memory context management module estimates the required memory space based on the complexity of the agent's workflow and requests a contiguous memory region from the off-heap memory pool.
[0012] The memory context management module predefines typed memory structures in the allocated memory area based on the data types to be passed in the process. Each memory structure has a fixed offset, and the data space required for each agent node is reserved based on the offset.
[0013] The memory context management module generates a memory context object, which is then used to maintain a series of structure references pointing to specific data blocks in the off-heap memory pool, forming a global data mapping graph.
[0014] Step 2: Determine the process execution path and schedule agent nodes:
[0015] The process execution engine module analyzes the execution order and data dependencies of each agent node in the agent workflow, and determines one or more feasible execution paths.
[0016] The process execution engine module adds the first executable agent node to the scheduling queue, and at the same time maintains the execution status of each agent node.
[0017] Step 3: The agent node executes the process and passes data between nodes in the memory area:
[0018] For each agent node scheduled for execution, the process execution engine module directly passes a structure reference pointing to the memory context location of the previous node's output data to the current node.
[0019] The current agent node uses the read module to directly read the required input data from the shared memory context based on the structure reference.
[0020] After the current agent node finishes processing the data using the processing module, the output result is directly written to the data reserved location of the current agent node in the memory context.
[0021] Furthermore, in step 1 of the method for a multi-agent process engine based on a memory-level implementation context, a differential persistence module for the multi-agent process engine system based on a memory-level implementation context is also created. The differential persistence module monitors the modification operations of the memory context in real time, records the difference data, persists the changed data fragments, and applies a compression algorithm to the differential data to further reduce storage overhead.
[0022] Furthermore, the multi-agent process engine method based on memory-level implementation context also includes step 4: real-time monitoring of memory context modification operations through differential persistence module and recording differential data: monitoring the modification status of shared memory context and recording which data blocks or structure fields have been modified, added or deleted since the last persistence checkpoint;
[0023] Persisting changed data fragments: Only the changed data differences are extracted when certain conditions are met. These conditions include reaching a predetermined time interval, completion of a key node in the process, or explicit invocation of a save command.
[0024] Applying compression algorithms to differential data further reduces storage overhead: After performing lightweight serialization processing on the differential data, it is asynchronously written to persistent storage, reducing the amount and frequency of I / O operations.
[0025] Furthermore, in step 1 of the method for a multi-agent process engine based on memory-level implementation context, an Off-Heap memory pool management module for the multi-agent process engine system based on memory-level implementation context is also created. The Off-Heap memory pool management module manages off-heap memory resources and optimizes memory usage efficiency: it performs direct memory allocation, bypassing JVM heap memory and reducing garbage collection pressure; it performs memory pre-allocation: pre-allocates large blocks of contiguous memory to reduce dynamic allocation overhead; and it designs a cache: optimizes memory access patterns and improves CPU cache hit rate.
[0026] Furthermore, the multi-agent process engine method based on memory-level context implementation also includes step 5: after the entire agent process is completed, resource cleanup and optimization are performed.
[0027] Perform a context reset: The memory context management module marks all data reservation locations as overwriteable and resets the internal state tracker, preparing them for reuse in the next process instance.
[0028] Memory defragmentation: The Off-Heap memory pool management module periodically or when a certain level of fragmentation is detected, defragments and optimizes the memory space, merges free blocks, and ensures that large, contiguous memory blocks can be allocated subsequently.
[0029] This invention also provides a multi-agent process engine system based on memory-level context implementation, including a memory context management module, a process execution engine module, a reading module, and a processing module.
[0030] The system performs memory context initialization and allocation for the off-heap memory pool:
[0031] The memory context management module estimates the required memory space based on the complexity of the agent's workflow and requests a contiguous memory region from the off-heap memory pool.
[0032] The memory context management module predefines typed memory structures in the allocated memory area based on the data types to be passed in the process. Each memory structure has a fixed offset, and the data space required for each agent node is reserved based on the offset.
[0033] The memory context management module generates a memory context object, which is then used to maintain a series of structure references pointing to specific data blocks in the off-heap memory pool, forming a global data mapping graph.
[0034] The system determines the process execution path and schedules agent nodes:
[0035] The process execution engine module analyzes the execution order and data dependencies of each agent node in the agent workflow, and determines one or more feasible execution paths.
[0036] The process execution engine module adds the first executable agent node to the scheduling queue, and at the same time maintains the execution status of each agent node.
[0037] When an agent node executes its process, it uses the memory region to pass data between nodes:
[0038] For each agent node scheduled for execution, the process execution engine module directly passes a structure reference pointing to the memory context location of the previous node's output data to the current node.
[0039] The current agent node uses the read module to directly read the required input data from the shared memory context based on the structure reference.
[0040] After the current agent node finishes processing the data using the processing module, the output result is directly written to the data reserved location of the current agent node in the memory context.
[0041] Furthermore, the multi-agent process engine system based on memory-level context implementation also creates a differential persistence module. The differential persistence module monitors the modification operations of the memory context in real time, records the difference data, persists the changed data fragments, and applies compression algorithms to the differential data to reduce storage overhead.
[0042] Furthermore, the differential persistence module of the multi-agent process engine system based on memory-level implementation context monitors the modification operations of the memory context in real time and records the difference data: it monitors the modification status of the shared memory context and records which data blocks or structure fields have been modified, added, or deleted since the last persistence checkpoint.
[0043] Persisting changed data fragments: Only the changed data differences are extracted when certain conditions are met. These conditions include reaching a predetermined time interval, completion of a key node in the process, or explicit invocation of a save command.
[0044] Applying compression algorithms to differential data reduces storage overhead: After performing lightweight serialization processing on the differential data, it is asynchronously written to persistent storage, reducing the amount and frequency of I / O operations.
[0045] Furthermore, the aforementioned multi-agent process engine system based on memory-level implementation context also creates an Off-Heap memory pool management module. The Off-Heap memory pool management module manages off-heap memory resources and optimizes memory usage efficiency: it performs direct memory allocation, bypassing JVM heap memory and reducing garbage collection pressure; it performs memory pre-allocation: pre-allocates large blocks of contiguous memory to reduce dynamic allocation overhead; and it designs a cache: optimizes memory access patterns and improves CPU cache hit rate.
[0046] Furthermore, the multi-agent process engine system based on memory-level context implementation performs resource cleanup and optimization after the entire agent process is completed:
[0047] Perform a context reset: The memory context management module marks all data reservation locations as overwriteable and resets the internal state tracker, preparing them for reuse in the next process instance.
[0048] Memory defragmentation: The Off-Heap memory pool management module periodically or when a certain level of fragmentation is detected, defragments and optimizes the memory space, merges free blocks, and ensures that large, contiguous memory blocks can be allocated subsequently.
[0049] The advantages of this invention are:
[0050] Significant performance improvement: By eliminating serialization overhead, multi-node process latency is reduced by more than 60%, increasing system throughput;
[0051] Efficient resource utilization: Off-heap memory pools reduce JVM heap pressure, and differential persistence reduces I / O load;
[0052] Enhanced system scalability: The unified memory context design supports dynamic node expansion, adapting to complex workflow requirements;
[0053] Maintainability improvements: A clear memory management interface and state tracking mechanism improve system observability and debugging efficiency.
[0054] This invention is applicable to various multi-agent application scenarios such as intelligent customer service, sales support, and teaching assistance. It is particularly suitable for complex business processes with high real-time requirements, providing an efficient and reliable execution infrastructure for AI applications. Attached Figure Description
[0055] Figure 1 This is a schematic diagram of the method flow of the present invention. Detailed Implementation
[0056] 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.
[0057] Example 1
[0058] This invention provides a method for a multi-agent process engine based on memory-level context implementation, comprising:
[0059] A multi-agent process engine system based on memory-level implementation context is created. The system includes a memory context management module, a process execution engine module, a reading module, a processing module, a differential persistence module, and an off-heap memory pool management module.
[0060] The memory context management module is responsible for maintaining a globally unified memory context object, providing a shared memory space for all agent nodes. Its core functions mainly include: structured memory layout: using typed memory areas to store different data types, supporting direct structure references, and avoiding serialization operations; access control mechanism: allocating independent data access permissions to each agent node to ensure the secure isolation of context data; lifecycle management: tracking the creation, use, and destruction of context objects to prevent memory leaks.
[0061] The process execution engine module, as the core scheduling module of the system, is responsible for coordinating the execution order and data flow of intelligent agent nodes. Its main functions include: node dependency resolution: dynamically analyzing data dependencies between nodes to optimize execution paths; direct reference passing: passing data between nodes via memory address references rather than value copying; and asynchronous execution support: supporting non-blocking node execution to improve concurrency processing capabilities.
[0062] The differential persistence module implements an efficient context state persistence mechanism. Its main functions are: change tracking: real-time monitoring of changes to the memory context and recording the differences; incremental snapshots: only persisting the changed data fragments, not the complete context; and compressed storage: applying compression algorithms to the differential data to further reduce storage overhead.
[0063] The Off-Heap memory pool management module manages off-heap memory resources and optimizes memory usage efficiency. Its main functions are: direct memory allocation: bypassing JVM heap memory and reducing garbage collection pressure; memory pre-allocation: pre-allocating large blocks of contiguous memory and reducing dynamic allocation overhead; and cache-friendly design: optimizing memory access patterns and improving CPU cache hit rate.
[0064] When executing a multi-agent process, the main steps are as follows:
[0065] Step 1: Initialize and allocate the memory context for the off-heap memory pool:
[0066] The memory context management module estimates the required memory space based on the complexity of the agent's workflow and requests a contiguous memory region from the off-heap memory pool.
[0067] The memory context management module predefines typed memory structures, similar to structs in C / C++, in the allocated memory area based on the data types to be passed in the process, such as text, numbers, arrays, and complex objects. Each memory structure has a fixed offset, and specific slots are reserved for the data required by each agent node based on the offset, that is, the reserved positions for the data required by each agent node.
[0068] The memory context management module generates a memory context object, which is used to maintain a series of structure references, such as pointers or offsets, pointing to specific data blocks in the off-heap memory pool, forming a global data mapping graph.
[0069] Step 2: Determine the process execution path and schedule agent nodes:
[0070] The process execution engine module analyzes the execution order and data dependencies of each agent node in the agent workflow, and determines one or more feasible execution paths.
[0071] The process execution engine module adds the first executable agent node to the scheduling queue, while maintaining the execution status of each agent node. All the data that needs to be transferred between nodes is already in the initialized shared memory context.
[0072] Step 3: The agent node executes the process and passes data between nodes in the memory area:
[0073] For each agent node scheduled for execution, the process execution engine module directly passes a structure reference pointing to the memory context location of the previous node's output data to the current node.
[0074] The current agent node uses the reading module to directly read the required input data from the shared memory context based on the structure reference. Since the memory layout is a predefined structured type, the node can understand and manipulate the data without deserialization, just like directly accessing local variables.
[0075] After the current agent node finishes processing the data using the processing module, the output is directly written to the data reservation location of the current agent node in the memory context. Similarly, structured data, not JSON strings, is written. By directly passing and accessing memory addresses, the JSON serialization and deserialization operations at each node's input / output in traditional architectures are completely bypassed, thus eliminating the performance bottleneck caused by this.
[0076] Step 4: Monitor the modification operations of the memory context in real time through the differential persistence module and record the difference data: Monitor the modification status of the shared memory context and record which data blocks or structure fields have been modified, added or deleted since the last persistence checkpoint;
[0077] Persisting changed data fragments: Only the changed data differences are extracted when certain conditions are met. These conditions include reaching a predetermined time interval, completion of a key node in the process, or explicit invocation of a save command.
[0078] Applying compression algorithms to differential data further reduces storage overhead: After performing lightweight serialization processing on the differential data, it is asynchronously written to persistent storage, reducing the amount and frequency of I / O operations.
[0079] Step 5: After the entire agent process is completed, perform resource cleanup and optimization:
[0080] Perform a context reset: The memory context management module marks all data reservation locations as overwriteable and resets the internal state tracker, preparing them for reuse in the next process instance.
[0081] Memory defragmentation: The Off-Heap memory pool management module periodically or when a certain level of fragmentation is detected, defragments and optimizes the memory space, merges free blocks, and ensures that large, contiguous memory blocks can be allocated subsequently.
[0082] Example 2
[0083] This invention also provides a multi-agent process engine system based on memory-level context implementation, including a memory context management module, a process execution engine module, a reading module, and a processing module.
[0084] The system performs memory context initialization and allocation for the off-heap memory pool:
[0085] The memory context management module estimates the required memory space based on the complexity of the agent's workflow and requests a contiguous memory region from the off-heap memory pool.
[0086] The memory context management module predefines typed memory structures in the allocated memory area based on the data types to be passed in the process. Each memory structure has a fixed offset, and the data space required for each agent node is reserved based on the offset.
[0087] The memory context management module generates a memory context object, which is then used to maintain a series of structure references pointing to specific data blocks in the off-heap memory pool, forming a global data mapping graph.
[0088] The system determines the process execution path and schedules agent nodes:
[0089] The process execution engine module analyzes the execution order and data dependencies of each agent node in the agent workflow, and determines one or more feasible execution paths.
[0090] The process execution engine module adds the first executable agent node to the scheduling queue, and at the same time maintains the execution status of each agent node.
[0091] When an agent node executes its process, it uses the memory region to pass data between nodes:
[0092] For each agent node scheduled for execution, the process execution engine module directly passes a structure reference pointing to the memory context location of the previous node's output data to the current node.
[0093] The current agent node uses the read module to directly read the required input data from the shared memory context based on the structure reference.
[0094] After the current agent node finishes processing the data using the processing module, the output result is directly written to the data reserved location of the current agent node in the memory context.
[0095] 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.
[0096] Similarly, the advantages of the system of the present invention are:
[0097] Significant performance improvement: By eliminating serialization overhead, multi-node process latency is reduced by more than 60%, increasing system throughput;
[0098] Efficient resource utilization: Off-heap memory pools reduce JVM heap pressure, and differential persistence reduces I / O load;
[0099] Enhanced system scalability: The unified memory context design supports dynamic node expansion, adapting to complex workflow requirements;
[0100] Maintainability improvements: A clear memory management interface and state tracking mechanism improve system observability and debugging efficiency.
[0101] This invention is applicable to various multi-agent application scenarios such as intelligent customer service, sales support, and teaching assistance. It is particularly suitable for complex business processes with high real-time requirements, providing an efficient and reliable execution infrastructure for AI applications.
[0102] 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 each step 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 jointly implemented by certain components in multiple independent devices.
[0103] 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 multi-agent process engine method based on memory-level implementation of context, characterized by: include: A multi-agent process engine system based on memory-level implementation context is created. The system includes a memory context management module, a process execution engine module, a reading module, and a processing module. Step 1: Initialize and allocate the memory context for the off-heap memory pool: The memory context management module estimates the required memory space based on the complexity of the agent's workflow and requests a contiguous memory region from the off-heap memory pool. The memory context management module predefines typed memory structures in the allocated memory area based on the data types to be passed in the process. Each memory structure has a fixed offset, and the data space required for each agent node is reserved based on the offset. The memory context management module generates a memory context object, which is then used to maintain a series of structure references pointing to specific data blocks in the off-heap memory pool, forming a global data mapping graph. Step 2: Determine the process execution path and schedule agent nodes: The process execution engine module analyzes the execution order and data dependencies of each agent node in the agent workflow, and determines one or more feasible execution paths. The process execution engine module adds the first executable agent node to the scheduling queue, and at the same time maintains the execution status of each agent node. Step 3: The agent node executes the process and passes data between nodes in the memory area: For each agent node scheduled for execution, the process execution engine module directly passes a structure reference pointing to the memory context location of the previous node's output data to the current node. The current agent node uses the read module to directly read the required input data from the shared memory context based on the structure reference. After the current agent node finishes processing the data using the processing module, the output result is directly written to the data reserved location of the current agent node in the memory context.
2. The method for a multi-agent process engine based on memory-level context implementation according to claim 1, characterized in that: Step 1 also creates a differential persistence module for a multi-agent process engine system based on memory-level implementation context. The differential persistence module monitors the modification operations of the memory context in real time, records the difference data, persists the changed data fragments, and applies compression algorithms to the differential data to further reduce storage overhead.
3. The method for a multi-agent process engine based on memory-level context implementation according to claim 2, characterized in that: It also includes step 4: Real-time monitoring of memory context modification operations through the differential persistence module and recording differential data: monitoring the modification status of the shared memory context and recording which data blocks or structure fields have been modified, added, or deleted since the last persistence checkpoint; Persisting changed data fragments: Only the changed data differences are extracted when certain conditions are met. These conditions include reaching a predetermined time interval, completion of a key node in the process, or explicit invocation of a save command. Applying compression algorithms to differential data further reduces storage overhead: After performing lightweight serialization processing on the differential data, it is asynchronously written to persistent storage, reducing the amount and frequency of I / O operations.
4. The method for a multi-agent process engine based on memory-level context implementation according to claim 1, characterized in that: Step 1 also creates an Off-Heap memory pool management module for a multi-agent process engine system based on memory-level implementation context. The Off-Heap memory pool management module manages off-heap memory resources and optimizes memory usage efficiency: it performs direct memory allocation, bypassing JVM heap memory and reducing garbage collection pressure; it performs memory pre-allocation: pre-allocates large blocks of contiguous memory to reduce dynamic allocation overhead; and it designs a cache: optimizes memory access patterns and improves CPU cache hit rate.
5. A multi-agent process engine method based on memory-level context implementation according to claim 4, characterized in that: It also includes step 5: After the entire agent process is completed, perform resource cleanup and optimization: Perform a context reset: The memory context management module marks all data reservation locations as overwriteable and resets the internal state tracker, preparing them for reuse in the next process instance. Memory defragmentation: The Off-Heap memory pool management module periodically or when a certain level of fragmentation is detected, defragments and optimizes the memory space, merges free blocks, and ensures that large, contiguous memory blocks can be allocated subsequently.
6. A multi-agent process engine system based on memory-level implementation of context, characterized in that: It includes a memory context management module, a process execution engine module, a reading module, and a processing module. The system performs memory context initialization and allocation for the off-heap memory pool: The memory context management module estimates the required memory space based on the complexity of the agent's workflow and requests a contiguous memory region from the off-heap memory pool. The memory context management module predefines typed memory structures in the allocated memory area based on the data types to be passed in the process. Each memory structure has a fixed offset, and the data space required for each agent node is reserved based on the offset. The memory context management module generates a memory context object, which is then used to maintain a series of structure references pointing to specific data blocks in the off-heap memory pool, forming a global data mapping graph. The system determines the process execution path and schedules agent nodes: The process execution engine module analyzes the execution order and data dependencies of each agent node in the agent workflow, and determines one or more feasible execution paths. The process execution engine module adds the first executable agent node to the scheduling queue, and at the same time maintains the execution status of each agent node. When an agent node executes its process, it uses the memory region to pass data between nodes: For each agent node scheduled for execution, the process execution engine module directly passes a structure reference pointing to the memory context location of the previous node's output data to the current node. The current agent node uses the read module to directly read the required input data from the shared memory context based on the structure reference. After the current agent node finishes processing the data using the processing module, the output result is directly written to the data reserved location of the current agent node in the memory context.
7. A multi-agent process engine system based on memory-level context implementation according to claim 6, characterized in that: A differential persistence module is also created, which monitors changes to the memory context in real time, records the differences, persists the changed data segments, and applies compression algorithms to the differential data to reduce storage overhead.
8. A multi-agent process engine system based on memory-level context implementation according to claim 7, characterized in that: The differential persistence module monitors the modification operations of the memory context in real time and records the difference data: it monitors the modification status of the shared memory context and records which data blocks or structure fields have been modified, added, or deleted since the last persistence checkpoint. Persisting changed data fragments: Only the changed data differences are extracted when certain conditions are met. These conditions include reaching a predetermined time interval, completion of a key node in the process, or explicit invocation of a save command. Applying compression algorithms to differential data reduces storage overhead: After performing lightweight serialization processing on the differential data, it is asynchronously written to persistent storage, reducing the amount and frequency of I / O operations.
9. A multi-agent process engine system based on memory-level context implementation according to claim 6, characterized in that: It also creates an Off-Heap memory pool management module, which manages off-heap memory resources and optimizes memory usage efficiency: it performs direct memory allocation, bypassing JVM heap memory and reducing garbage collection pressure; it performs memory pre-allocation: pre-allocates large blocks of contiguous memory to reduce dynamic allocation overhead; and it designs a cache: optimizes memory access patterns and improves CPU cache hit rate.
10. A multi-agent process engine system based on memory-level implementation of context according to claim 9, characterized in that... After the entire intelligent agent process is completed, the system performs resource cleanup and optimization: Perform a context reset: The memory context management module marks all data reservation locations as overwriteable and resets the internal state tracker, preparing them for reuse in the next process instance. Memory defragmentation: The Off-Heap memory pool management module periodically or when a certain level of fragmentation is detected, defragments and optimizes the memory space, merges free blocks, and ensures that large, contiguous memory blocks can be allocated subsequently.