A dynamic random access memory cache management method and system

Abstract

The application relates to the technical field of computer and big data management, and discloses a dynamic random access memory cache management method and system. The method comprises the following steps: collecting task access flow data in real time; quantifying the concentration or dispersion of the access based on Shannon entropy; dynamically adjusting the cache partition size according to the entropy value; synchronously and cooperatively optimizing the prefetching and replacement strategies in the partition; and continuously and adaptively adjusting through closed-loop control. The system comprises an access log module, an entropy calculation unit, a strategy scheduler and a cache controller. Through the above technical scheme, the application can realize double-elastic cooperative optimization of cache partition and management strategy, and significantly improve the cache hit rate, system stability and resource utilization efficiency.

Description

Technical Field

[0001] This invention belongs to the field of computer big data management technology, specifically relating to a dynamic random access memory cache management method and system. Background Technology

[0002] With the widespread application of big data platforms in key sectors such as finance, telecommunications, and the internet, the types of mixed workloads they handle are becoming increasingly complex, including the coexistence of high-throughput batch processing tasks and low-latency interactive queries. This poses a severe challenge to the cache management capabilities of the underlying storage system. As the core carrier of memory caching, the resource allocation efficiency of Dynamic Random Access Memory (DRAM) directly determines the overall data processing performance and service quality.

[0003] Cache management strategies need to be adaptively adjusted according to dynamic changes in data access patterns. Traditional methods typically employ static partitioning mechanisms, allocating cache space to different tasks or data partitions according to preset proportions or fixed rules, lacking the ability to perceive and respond to actual access behavior.

[0004] Existing technologies suffer from several problems when dealing with mixed workload scenarios: Firstly, static cache partitions fail to detect the real-time distribution of data access frequency across tasks, leading to frequent swapping of hot data due to small partitions, while cold data occupies valuable cache resources for extended periods. Secondly, existing strategies typically only adjust cache allocation size, neglecting the compatibility between partition management strategies (such as prefetching and replacement algorithms) and access patterns, resulting in low cache hit rates. Furthermore, the lack of quantitative measurement of the "centralization" or "dispersion" of access patterns makes it difficult to accurately identify task behavior characteristics, hindering fine-grained resource scheduling. Finally, in high-concurrency, multi-tenant environments, different tasks interfere with each other due to cache contention, further exacerbating system performance fluctuations. These problems are particularly pronounced in mixed workload scenarios with vastly different data access frequency distributions, severely restricting the resource utilization and service stability of big data platforms. Therefore, a dynamic management mechanism that can simultaneously achieve elastic scaling of cache partitions and collaborative optimization of embedded strategies is urgently needed. Summary of the Invention

[0005] This invention provides a dynamic random access memory cache management method and system, which can effectively solve the problems in the background art mentioned above.

[0006] To achieve the above objectives, the technical solution adopted by the present invention is as follows: a dynamic random access memory cache management method and system, comprising the following specific steps:

[0007] First, real-time acquisition of access flow data for each task or data partition: continuously capture each task's read and write requests to data blocks in dynamic random access memory through the access log module embedded in the storage engine, record the request timestamp, data block identifier and access frequency, forming the original access flow organized in time sequence;

[0008] Furthermore, the Shannon entropy of data access heat for each task or data partition is calculated: based on the access flow data, the access frequency of each data block within a unit time window is counted, a probability distribution model is constructed, and the access heat entropy value of the task or data partition is calculated according to the Shannon entropy formula. The lower the entropy value, the more concentrated the access behavior is in a few hot data blocks, and the higher the entropy value, the more dispersed the access distribution.

[0009] Then, the cache partition size is dynamically adjusted: based on the calculated Shannon entropy value, if the entropy value is lower than the preset first threshold, it is determined that the task access is highly concentrated, and the capacity of its exclusive cache partition is reduced; if the entropy value is higher than the preset second threshold, it is determined that the access is highly dispersed, and the capacity of its cache partition is increased; if the entropy value is between the first threshold and the second threshold, the current partition size is maintained.

[0010] Next, the cache management strategy within the partition is optimized collaboratively: the Shannon entropy value is synchronously transmitted to the policy scheduler, and the policy scheduler selects the matching cache management sub-policy according to the entropy value. When the entropy value is low, a conservative replacement algorithm is used and prefetching is disabled. When the entropy value is high, an aggressive prefetching mechanism is enabled and combined with a multi-level least recently used replacement strategy.

[0011] Finally, a dual-elastic adjustment and feedback closed-loop control are implemented: the adjusted cache partition size and the selected management policy are sent to the cache controller, which then implements resource reallocation and policy loading, and continues to collect access flow in the next time window, forming a closed-loop control process of continuous monitoring, evaluation, and adjustment.

[0012] Preferably, the access log module samples at a microsecond-level time granularity, and the time window length is set to a predetermined time period to ensure that it can accurately capture instantaneous changes in access patterns even in high-concurrency scenarios. Furthermore, the log data is stored using a circular buffer structure to avoid memory overflow.

[0013] Preferably, the formula for calculating the Shannon entropy is as follows: ,in For the first The proportion of access frequency of a data block within a time window to the total number of accesses. When a task has no access behavior within a time window, its entropy value is set to 0, which is regarded as completely cold data, and its cache space is released first.

[0014] Preferably, the first threshold and the second threshold are preset thresholds, the adjustment step size of the cache partition capacity is a predetermined proportion of the total cache capacity of the dynamic random access memory, the minimum partition capacity is not lower than the preset lower limit proportion of the total capacity, and the maximum does not exceed the preset upper limit proportion, so as to prevent extreme tasks from monopolizing too many resources.

[0015] Preferably, the conservative replacement algorithm adopts a strict least recently used strategy, retaining only a predetermined proportion of recently accessed hot data; the aggressive prefetching mechanism predicts several data blocks that may be accessed in the future based on a sliding window and loads them into the cache in advance, automatically downgrading to normal prefetching mode when the prefetch hit rate is lower than a preset hit rate threshold.

[0016] Preferably, the policy scheduler maintains a policy mapping table that divides the Shannon entropy range into multiple levels. Each level corresponds to a set of predefined cache management parameter combinations, including prefetch depth, replacement algorithm type, cache locking ratio, and write-back latency policy, to ensure smooth and configurable policy switching.

[0017] Preferably, after receiving the new partition size, the cache controller uses a non-blocking migration mechanism to move the valid data in the original partition to the newly allocated area. The migration process is executed in parallel with normal read and write operations to ensure service continuity, and the migration bandwidth does not exceed a predetermined proportion of the total memory bandwidth.

[0018] Preferably, the present invention also includes a multi-tenant isolation mechanism: in a high-concurrency, multi-tasking environment, each tenant is allocated an independent entropy calculation unit and a policy scheduling context to prevent policy interference between different tenants due to differences in access patterns and to ensure service quality isolation.

[0019] Preferably, the present invention also includes an abnormal access pattern recognition module: when the Shannon entropy value of a task fluctuates beyond a preset fluctuation threshold within multiple consecutive time windows, the abnormal detection process is triggered, the automatic adjustment of its caching strategy is suspended, and logs are recorded for operation and maintenance analysis to prevent malicious load or program errors from causing cache oscillation.

[0020] Preferably, the time window of the closed-loop control process can be dynamically adjusted. When the overall system load rate is lower than the preset low load threshold, the window is extended to a predetermined longer period of time to reduce computational overhead; when the load rate is higher than the preset high load threshold, the window is shortened to a predetermined shorter period of time to improve response sensitivity and achieve adaptive monitoring granularity.

[0021] Compared with the prior art, the present invention has the following beneficial effects:

[0022] 1. This invention introduces Shannon entropy as a quantitative indicator of data access concentration or dispersion, breaking through the traditional coarse-grained judgment method that relies solely on access frequency or temporal locality. This method can accurately identify tasks with concentrated hotspots and tasks with dispersed access, thereby dynamically adjusting their cache partition sizes. This avoids frequent swapping of hot data due to excessively small partitions, while promptly reclaiming cache resources occupied by cold data, thus improving the utilization rate of dynamic random access memory.

[0023] 2. This invention not only adjusts the size of the cache partition but also simultaneously optimizes the management strategy within the partition, achieving dual flexibility in "space allocation" and "strategy execution." Aggressive prefetching is enabled in high-entropy scenarios, while conservative replacement is adopted in low-entropy scenarios, resulting in a significant average improvement in cache hit rate under mixed loads. Especially in typical scenarios involving parallel financial transactions and log analysis, interactive query latency is significantly reduced, and batch processing throughput is markedly improved.

[0024] 3. Through a closed-loop mechanism of continuous monitoring, real-time calculation, policy linkage, and feedback execution, this invention can quickly respond to dynamic load changes and avoid performance fluctuations caused by policy lag. Abnormal access pattern identification and multi-tenant isolation mechanisms further enhance system robustness. In high-concurrency multi-tenant environments, performance interference between tasks is significantly reduced, and the service level agreement compliance rate is significantly improved.

[0025] 4. Without increasing physical memory, this invention effectively alleviates the contention for cache resources caused by mixed workloads through fine-grained cache management. This significantly increases the task density that can be carried under the same hardware configuration, and significantly reduces the hardware investment and operation and maintenance costs of big data platforms. It is suitable for critical business scenarios with stringent requirements for resource efficiency, such as finance, telecommunications, and the Internet. Attached Figure Description

[0026] Figure 1 This is a schematic diagram of the overall technical solution architecture of the present invention;

[0027] Figure 2 This is a schematic diagram of the core principle framework of Shannon entropy-based access heat quantification and dynamic adjustment of cache partitions in this invention;

[0028] Figure 3 This is a logical flow diagram of the access flow acquisition and Shannon entropy calculation stages in this invention;

[0029] Figure 4 This is a logical flow diagram of the dual-elastic collaborative optimization stage of cache partition size and management strategy in this invention;

[0030] Figure 5 This is a schematic diagram of the multi-level interaction relationship and data flow of multi-tenant isolation and abnormal access pattern recognition in this invention;

[0031] Figure 6 This is a schematic diagram of the time window dynamic adjustment and feedback mechanism of the closed-loop adaptive control process in this invention. Detailed Implementation

[0032] Example 1: Please refer to the appendix Figure 1 To be continued Figure 6 This embodiment is applied to a big data platform scenario where financial transactions and log analysis run in parallel with mixed workloads. Interactive query tasks exhibit a highly centralized access pattern, while batch processing tasks exhibit widely dispersed access behavior. To efficiently utilize limited dynamic random access memory (DRAM) cache resources, this invention deploys a cache management system composed of hardware acceleration units and software scheduling logic, and executes a closed-loop adaptive dual-elasticity management process based on this system.

[0033] At the system architecture level, this cache management system uses a high-performance multi-core processor as its core computing platform. Its memory subsystem is connected to the physical DRAM array via high-bandwidth DDR4 / DDR5 channels, with a total cache capacity of 128GB. The system embeds a dedicated cache controller module, integrated into the CPU's memory controller, which features non-blocking data migration capabilities and fine-grained partition management. The cache controller communicates with the main processor core via a PCIe 4.0 x16 interface and supports a QoS bandwidth allocation mechanism to ensure that the memory bandwidth occupied by migration operations does not exceed 15% of the total bandwidth.

[0034] The system comprises five key functional modules surrounding the cache controller: an access log module, an entropy calculation engine, a partition regulator, a policy scheduler, and an anomaly detection unit. Each module is implemented using a hardware-software co-implementation approach. The access log module, implemented using an FPGA or dedicated ASIC, is directly mounted on the memory bus bypass path, monitoring all read and write requests to the DRAM cache region with microsecond-level time granularity. Internally, this access log module features a 64KB circular buffer with a double-buffered ping-pong structure to ensure no log loss under high concurrency. Log entries contain a triplet of information: a 64-bit timestamp, a 32-bit data block identifier, and a 1-bit read / write flag. Log data is transferred in batches via the AXI-Stream protocol using DMA to a shared log pool in main memory for subsequent processing units to consume.

[0035] The entropy calculation engine is deployed on a dedicated computing core of the main processor, which runs a lightweight real-time operating system to ensure low-latency response. The engine extracts raw access streams from a shared log pool in 100-millisecond time windows and distributes them based on task ID or tenant ID. For each task stream, the engine first counts the access frequency of each data block within the window, constructing a frequency vector {f1, f2, ..., f...}. n}, and then normalize it to obtain the probability distribution . Subsequently, call the hardware-accelerated floating-point arithmetic unit (supporting the AVX-512 instruction set) to execute the Shannon entropy formula:

[0036] ;

[0037] When a certain task has no access within the window, the system forcibly sets its entropy value H to 0 and marks it as "completely cold data". The calculation result is stored in the task context structure in the form of a 64-bit floating-point number and transmitted to the partition regulator and policy scheduler through shared memory.

[0038] The partition regulator is responsible for dynamically adjusting the size of the cache partition exclusive to the task according to the entropy value H. The system presets the first threshold T1 = 0.5 and the second threshold T2 = 2.0. If H < T1, it is determined as "hotspot concentration type", and the partition contraction operation is triggered; if H > T2, it is determined as "access dispersion type", and the partition expansion is triggered; if T1 ≤ H ≤ T2, the current partition remains unchanged. The partition capacity takes 1% of the total DRAM cache capacity as the adjustment step (i.e., 1.28GB), but is subject to hard boundaries: the minimum partition is not less than 2% of the total capacity, and the maximum does not exceed 30%. The partition regulator realizes spatial reallocation by sending partition reconfiguration instructions to the cache controller.

[0039] The policy scheduler maintains a policy mapping table that divides the Shannon entropy value range into 5 levels: [0, 0.5), [0.5, 1.0), [1.0, 1.5), [1.5, 2.0), [2.0, +∞). Each level corresponds to a set of predefined cache management parameter combinations. For example, at level 1 (H < 0.5), enable the "conservative replacement algorithm" - that is, the strict least recently used (LRU) policy, only retain 80% of the hot data accessed recently, and disable all prefetch mechanisms at the same time; at level 5 (H ≥ 2.0), enable the "aggressive prefetch mechanism", predict the next 5 possible accessed data blocks based on the sliding window, and cooperate with the multi-level LRU replacement policy. In addition, the policy parameters also include the cache locking ratio and the write-back delay policy. The policy scheduler encodes the selected parameter combination into a policy configuration packet and sends it to the policy register group of the cache controller.

[0040] Upon receiving the new partition size and policy configuration, the cache controller initiates a dual-elasticity adjustment process. First, a non-blocking migration mechanism moves still-valid cache lines from the original partition (determined by access timestamps and dirty bits) to the newly allocated physical region. This migration process is executed in a background thread, running in parallel with foreground read / write requests, and the IMC's bandwidth arbitrator limits migration traffic to no more than 15% of the total memory bandwidth to ensure service continuity. Second, the controller dynamically loads the new replacement algorithm state machine and prefetch engine configuration to complete the policy switch. The entire adjustment process is completed within a single time window, without affecting the monitoring startup of the next window.

[0041] At the methodological and process level, the system workflow is as follows:

[0042] First, at the start of time window t0 (default 100ms), the access log module continuously captures all task read and write requests to the DRAM cache, forming a raw access stream sorted by timestamps, and temporarily stores it in a circular buffer. When the window ends, the log module pushes all log entries within the window to the shared log pool in main memory via DMA.

[0043] The entropy calculation engine is activated, iterates through all active tasks, and extracts their corresponding access sub-streams. For each sub-stream, the engine performs frequency statistics, probability normalization, and Shannon entropy calculation to generate a task-level entropy value H. If a task has no access within the window, then H=0.

[0044] The partition adjuster reads the H value of each task and compares it with thresholds T1=0.5 and T2=2.0. For example, interactive query task A has an H value of 0.3, which is lower than T1, so its cache partition is reduced from the current 10GB to 8.72GB, a decrease of 1% step size; batch processing task B has an H value of 2.4, which is higher than T2, so its partition is expanded from 15GB to 16.28GB. The adjusted partition information is encapsulated into reconfiguration instructions.

[0045] The policy scheduler queries the policy mapping table based on the H value. Task A falls into level 1 because H=0.3, so the scheduler selects the "conservative LRU + disable prefetch" policy; Task B falls into level 5 because H=2.4, so the scheduler selects the "aggressive prefetch (predict 5 blocks) + multi-level LRU" policy. The policy parameters are encoded and then sent out.

[0046] Upon receiving the above instructions, the cache controller performs two operations in parallel: First, it initiates a non-blocking migration, moving the most recently accessed 80% of the data in the original partition of Task A to the newly allocated 8.72GB area, marking the remaining data as reclaimable; second, it loads the prefetch engine configuration of Task B, activates the sliding window prediction module, and initializes a multi-level LRU queue. During the migration process, if a new request hits a data block being migrated, the controller transparently forwards it to the new location through the address remapping table, ensuring consistency.

[0047] The system enters the next time window t1. At this time, the access log module continues to collect new data, and the closed-loop control process automatically restarts. If the overall system load rate changes, such as rising from 50% to 85%, the closed-loop control module will dynamically shorten the time window to 50ms to improve response sensitivity; if the load drops to 30%, the window will be extended to 200ms to reduce computational overhead.

[0048] The system also integrates a multi-tenant isolation mechanism: each tenant has an independent entropy calculation context, a copy of the policy mapping table, and a partition namespace, ensuring that tenant A's high entropy behavior will not trigger policy adjustments for tenant B. Simultaneously, the abnormal access pattern recognition module continuously monitors the entropy fluctuations of each task. If a task's H-value fluctuates by more than 50% within three consecutive windows (e.g., a sudden increase from 0.4 to 1.2 and then a decrease to 0.3), it is considered abnormal, its automatic adjustment function is suspended, the current policy is frozen, and an alarm log is sent to the operations and maintenance system to prevent malicious load from causing cache oscillations.

[0049] Through the deep integration of the above system architecture and methodology, this embodiment achieves accurate allocation of cache resources and intelligent matching of strategies.

[0050] Example 2: This example is for a telecom-grade real-time billing system scenario, characterized by high concurrency, low latency, and a large amount of short-lifetime session data. Unlike Example 1, this example adopts a fully software-defined cache management architecture, suitable for general-purpose server environments where FPGAs or dedicated ASICs cannot be deployed.

[0051] In terms of system architecture, this embodiment abandons the hardware log collection module and instead utilizes Linux kernel's eBPF technology to inject lightweight probe programs into the critical paths of the memory subsystem. These eBPF programs run in kernel space using JIT compilation, sampling virtual memory access events at a 50-microsecond granularity, recording process ID, virtual page number, access type, and timestamp. The sampled data is output to the user-space agent process through a perf_event circular buffer, avoiding performance degradation caused by frequent kernel entry. Although this solution sacrifices some time precision, it has extremely high compatibility and can be seamlessly deployed on standard x86 or ARM servers.

[0052] The entropy calculation engine is now implemented by a user-space daemon running in an isolated cgroupv2 resource group, with its CPU utilization limited to no more than 2%. This user-space daemon employs a sliding window mechanism, with an initial window length of 100ms, which can be dynamically adjusted according to system load: when CPU idle rate > 60%, the window is extended to 200ms; when swap utilization > 10%, the window is shortened to 50ms. The calculation process reuses the Shannon entropy formula from Example 1, but introduces a smoothing factor α = 0.8, performing an exponentially weighted average of historical entropy values ​​to suppress instantaneous noise.

[0053] ;

[0054] The partition adjuster no longer directly manipulates physical memory. Instead, it dynamically adjusts the `memory.max` cgroup parameter of each task through Linux's Memory Tiering subsystem or HugeTLB pool mechanism, thereby indirectly controlling the upper limit of cache that each task can use. The adjustment step size remains 1% of the total DRAM capacity, but the minimum / maximum boundaries are dynamically set according to the container specifications.

[0055] The policy scheduler is deeply integrated with the user-space cache library. When the entropy value falls to a high level, the scheduler notifies the application layer to enable the prefetch API via IPC; when the entropy value is low, it suggests that the application layer disable internal cache preheating logic. Although this solution cannot directly control the hardware replacement policy, policy matching can still be achieved through application collaboration.

[0056] The cache controller function is handled by the kernel's page reclaim mechanism. When a partition shrinks, the kernel prioritizes reclaiming anonymous pages of that cgroup under subsequent memory pressure, achieving a "soft release." Migration operations are completed via MADV_FREE or MADV_DONTNEED hints. Although not atomic, they can ensure data consistency with application cooperation.

[0057] In terms of methodology, the closed-loop control in this embodiment runs entirely on the operating system, requiring no hardware modifications. Its advantages include flexible deployment, low maintenance costs, and suitability for cloud-native environments.

[0058] In summary, through the hardware-software co-working architecture of Example 1 and the pure software-defined scheme of Example 2, this invention comprehensively covers the diverse deployment needs from high-performance dedicated systems to general-purpose cloud servers, fully demonstrating its technical universality and engineering feasibility.

Claims

1. A dynamic random access memory cache management method, characterized in that, Includes the following steps: Real-time acquisition of read and write requests from each task or data partition to data blocks in the dynamic random access memory, forming a raw access stream organized in time sequence; Based on the original access flow, the access frequency of each data block is counted within a unit time window, a probability distribution model is constructed, and the access heat Shannon entropy value of the task or data partition is calculated according to the Shannon entropy formula. Based on the comparison results between the Shannon entropy value and the preset first threshold and second threshold, the cache partition capacity corresponding to the task or data partition is dynamically adjusted. The Shannon entropy value is passed to the policy scheduler, which selects a matching cache management sub-policy based on the Shannon entropy value. When the Shannon entropy value is lower than the first threshold, a conservative replacement algorithm is used and prefetching is disabled. When the Shannon entropy value is higher than the second threshold, an aggressive prefetching mechanism is enabled and combined with a multi-level least recently used replacement strategy. The adjusted cache partition capacity and the selected cache management sub-policy are sent to the cache controller, which then performs resource reallocation and policy loading, and continues to collect access flow in the next time window, forming a closed-loop control process. In the step of dynamically adjusting the cache partition capacity, the adjustment step size of the cache partition capacity is a predetermined proportion of the total cache capacity of the dynamic random access memory, and the minimum partition capacity is not lower than the preset lower limit proportion of the total capacity, and the maximum partition capacity does not exceed the preset upper limit proportion of the total capacity. The conservative replacement algorithm employs a strict least recent use strategy, retaining only a predetermined proportion of recently accessed hot data. The aggressive prefetching mechanism predicts several potentially accessed data blocks in the future based on a sliding window and loads them into the cache in advance; The policy scheduler maintains a policy mapping table, which divides the Shannon entropy range into multiple levels. Each level corresponds to a set of predefined cache management parameter combinations, including prefetch depth, replacement algorithm type, cache locking ratio, and write-back latency policy.

2. The dynamic random access memory cache management method according to claim 1, characterized in that, In the real-time acquisition step, sampling is performed at the microsecond time granularity through the access log module embedded in the storage engine, and the log data is stored in a circular buffer structure.

3. The dynamic random access memory cache management method according to claim 1, characterized in that, The Shannon entropy formula is: ;in For the first The proportion of the number of times a data block is accessed within a time window to the total number of accesses; When a task has no access behavior within a time window, its Shannon entropy value is set to 0.

4. The dynamic random access memory cache management method according to claim 1, characterized in that, After receiving the new partition capacity, the cache controller uses a non-blocking migration mechanism to move the valid data in the original partition to the newly allocated area. The migration process is executed in parallel with normal read and write operations, and the migration bandwidth does not exceed a predetermined proportion of the total memory bandwidth.

5. The dynamic random access memory cache management method according to claim 1, characterized in that, It also includes a multi-tenant isolation mechanism, which allocates an independent entropy calculation unit and policy scheduling context to each tenant to prevent policy interference between different tenants due to differences in access patterns.

6. The dynamic random access memory cache management method according to claim 1, characterized in that, It also includes an abnormal access pattern recognition step: When the Shannon entropy value of a task fluctuates beyond a preset fluctuation threshold within multiple consecutive time windows, its automatic adjustment of caching strategy is suspended, and logs are recorded for operation and maintenance analysis.

7. A dynamic random access memory cache management system, characterized in that, The dynamic random access memory cache management method according to any one of claims 1-6 is used to manage the dynamic random access memory cache.

Images