Memory Management System for Concurrent Garbage Collection
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing memory-management systems face inefficiencies in managing large heaps and multiple threads, particularly during garbage collection, as they struggle to balance the overhead of object relocation and allocation between address-referenced and identifier-referenced objects.
Innovation Solution
A memory-management system that supports both address-referenced and identifier-referenced objects, allowing for concurrent garbage collection by initially creating objects as address-referenced and converting them to identifier-referenced when necessary, with address-referenced objects in thread-local heaps and identifier-referenced objects in shared memory, enabling efficient object management and reduced pause times.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Speed
If an object is referenced by an address in an address-based reference system, then the object can be accessed directly and quickly, but during garbage collection all pointers that refer to the object must be updated to point to the new location, which involves a large amount of work and increases garbage collection overhead
Solution Approach 1:
The patent segments the reference system into two types: address-based references for objects that don't need sharing and OID-based references for objects that may be shared across threads. This segmentation allows the system to use the most efficient reference type for each object, minimizing garbage collection overhead while maintaining fast access where needed.
Solution Approach 2:
The patent changes the reference parameter from direct memory addresses to OIDs for specific objects that benefit from sharing. This parameter change enables the garbage collector to update only a single OTE entry rather than multiple pointers, dramatically reducing garbage collection work and pause times for shared objects.
2Loss of time
If an OID-based reference system is used to facilitate efficient object relocation during garbage collection, then only the OTE needs to be updated during relocation, but the operations involved in managing OIDs and OTEs create a significant amount of overhead and allocation is slower
Solution Approach 1:
The patent applies different reference qualities to different objects based on their sharing requirements. Objects in thread-local heaps use simple address-based references with no OID overhead, while objects in the shared heap use OID-based references. This local quality approach ensures that OID management overhead is incurred only for objects that actually need sharing, maximizing allocation speed for the majority of objects.
3Adaptability or versatility
If the system supports concurrent garbage collection to allow threads to continue executing while garbage collection occurs, then larger heaps and more threads can be supported, but the system must manage both address-referenced and identifier-referenced objects efficiently simultaneously
Solution Approach 1:
The patent segments the heap into thread-local heaps and a shared heap, with different reference types for each segment. This segmentation simplifies concurrent garbage collection by allowing collection in thread-local heaps without affecting other threads, while OID-based references in the shared heap enable safe concurrent access and collection.
Solution Approach 2:
The patent creates a universal reference system that can handle both address-based and OID-based references within the same memory management infrastructure. The system universally supports both reference types, allowing objects to be accessed efficiently whether they are locally-owned or shared, while providing a unified garbage collection mechanism that works for both types.
Data Source
AI summary
One embodiment of the present invention provides a memory-management system that supports both address-referenced objects and identifier-referenced objects, wherein an address-referenced object is accessed through a reference containing an address of the object, and wherein an identifier-referenced object is accessed through a reference containing an object identifier (OID) for the object. During operation, the system receives a request to access an object. Next, the system determines if the object is an address-referenced object or an identifier-referenced object. If the object is an address-referenced object, the system accesses the object using the associated address for the object. If the object is an identifier-referenced object, the system accesses the object by using the associated OID for the object to look up the address for the object, and then using the address to access the object.