Dynamic Heap Memory Extension via Trailing Pointers
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Garbage collected languages like Java face challenges with JVM heap sizing, which must be precisely set at startup and cannot be altered at runtime, leading to potential out-of-memory errors.
Innovation Solution
A system and method that allows dynamic updating of the heap memory by using a management console to monitor and edit attributes, employing extension points and defragmentation to increment or decrement heap size as needed, ensuring sufficient memory availability.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If the JVM heap size is set precisely at startup, then the memory allocation is stable and predictable, but the heap size cannot be altered at runtime leading to out-of-memory errors
Solution Approach 1:
The patent implements dynamic heap size adjustment by introducing extension points that allow the heap to grow at runtime. The heap is structured with multiple sections that can be individually extended by allocating additional memory chunks to sections that have extension points, enabling the system to adapt heap size to changing runtime requirements while maintaining controlled growth through a structured allocation mechanism.
2Adaptability or versatility
If the heap is extended multiple times at runtime, then the heap size flexibility is improved, but the memory structure becomes fragmented requiring defragmentation
Solution Approach 1:
The patent segments the heap into multiple independent sections (Eden space, Survivor spaces, Tenured space, PermGen space) each with its own extension point. This segmentation allows individual sections to be extended independently based on their specific memory needs, providing flexibility while maintaining a manageable structure. The segmentation also enables targeted defragmentation of individual sections rather than the entire heap.
Solution Approach 2:
The patent implements periodic defragmentation as a maintenance operation that consolidates fragmented memory chunks within each heap section. By periodically running defragmentation during maintenance windows, the system maintains efficient memory utilization without preventing runtime heap extensions, balancing structure management with operational flexibility.
3Device complexity
If defragmentation is performed to consolidate memory chunks, then the memory structure is simplified, but garbage collection must be temporarily disabled causing downtime
Solution Approach 1:
The patent performs defragmentation as a preliminary maintenance action scheduled during maintenance windows before critical operations or peak usage periods. By proactively consolidating memory structures during low-usage periods, the system prevents fragmentation from accumulating to problematic levels, reducing the need for urgent defragmentation that would cause downtime.
Solution Approach 2:
The patent implements automatic defragmentation scheduling and execution that requires minimal human intervention. The system can automatically identify when defragmentation is needed, schedule appropriate maintenance windows, and execute the consolidation process, reducing operational overhead while maintaining system performance.
Data Source
AI summary
A system and method for use with garbage collected systems and languages, for enabling an allocated heap memory to be updated (e.g., increased or decreased) at runtime, subject to sufficient availability of physical memory. In accordance with an embodiment, a Java Virtual Machine (JVM) is associated with a management console, which allows a systems administrator to monitor current heap utilization at runtime. The heap is visualized as a contiguous chunk of memory with one or more extension points, e.g., by use of a trailing pointer to a null list. If later, at runtime, the heap size needs to be incremented then the trailing pointer can be set to a new chunk of memory with a size of (new value−old value), so that the cumulative new size is made equal to a new value specified on the console.