Memory Pool Composite Array Slab Allocation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In computing environments with generational garbage collectors, the dynamic allocation of dataset objects in heap memory leads to frequent garbage collections, causing operational pauses and increased latency as non-permanent objects are promoted to the tenured generation space, affecting the responsiveness of applications to end-user requests.
Innovation Solution
The implementation of a memory pool application that allocates fixed-sized slabs with duplicate words, allowing values to be stored across multiple slabs via poolable arrays, which are managed to avoid garbage collection and enable efficient reuse of heap memory, thereby reducing operational pauses and latency.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If dataset objects are dynamically allocated in heap memory, then the system can flexibly manage memory resources, but frequent garbage collections cause operational pauses and increased latency
Solution Approach 1:
The patent segments memory management into two distinct parts: a memory pool that pre-allocates slabs of memory for dataset objects, and the garbage collector that manages general heap memory. This segmentation allows the dataset objects to reside in a dedicated pool that is excluded from garbage collection, eliminating operational pauses while maintaining flexible memory allocation within the pool boundaries.
Solution Approach 2:
The patent introduces a memory pool as an intermediary layer between the application and the garbage collector. The memory pool acts as a mediator that handles allocation and reuse of memory for dataset objects, preventing them from being placed in the standard heap memory that is subject to garbage collection. This intermediary structure resolves the conflict between flexible memory management and garbage collection interruptions.
2Duration of action of stationary object
If non-permanent objects are retained long enough to be promoted to tenured generation space, then object lifetime is extended, but full garbage collections become more frequent degrading server performance
Solution Approach 1:
The patent extracts dataset objects from the standard generational garbage collection system and places them in a dedicated memory pool. By taking out these objects from the tenured generation space, they are removed from the garbage collection process entirely. This allows objects to be retained as long as needed without triggering full garbage collections, maintaining both extended object lifetime and high server performance.
3Quantity of substance
If values are stored across multiple slabs in a composite array, then memory allocation efficiency is improved, but accessing values requires additional operations to retrieve data spanning slab boundaries
Solution Approach 1:
The patent performs preliminary actions by pre-calculating and storing metadata about value locations and spans within the composite array structure. When values span multiple slabs, the system prepares the necessary information in advance about which slabs contain which portions of values, allowing for more efficient retrieval operations that don't require complex runtime analysis of data distribution.
Data Source
AI summary
In various embodiments, a memory pool application implements composite arrays via a memory pool that includes a first slab and a second slab. First, the memory pool application assigns the first slab and the second slab to a composite array. The memory pool application then modifies a final data word included in the first slab to store a first portion of a specified value and a leading data word included in the second slab to store a second portion of the specified value. The memory pool application copies the second data word to a duplicate data word included in the first slab. Subsequently, the memory pool application performs an unaligned read operation on the first slab based on a specified offset to retrieve a first word stored in memory and extracts the specified value from the first word based on the specified offset and a specified number of bits.