Software Object Handle Management in Dual-Threaded Garbage Collection
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In object-oriented database management systems (OODBMS), the lack of synchronicity between the garbage collector and other processes hinders the efficient determination of which persistent objects can be written into storage memory and when memory locations can be made available for other uses, leading to inefficiencies in memory management.
Innovation Solution
A method and system for managing software object handles in a dual-threaded environment, where a garbage collector process operates independently to identify unreferenced objects, update their status, and free up cache memory locations by using handle wrappers with in-use/not-in-use flags, allowing for concurrent garbage collection and finalization processes.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If the garbage collector operates in a single thread attempting to close persistent objects, then the system structure remains simple, but the efficiency of determining which objects to write and when memory locations become available is inhibited
Solution Approach 1:
The system divides the garbage collection process into separate threads: a first thread for generating persistent objects and a second thread for garbage collection. This segmentation allows independent operation of object generation and object reclamation, improving productivity without requiring complex synchronization within a single thread.
Solution Approach 2:
The patent introduces handle wrappers as intermediary structures that mediate between the first thread (object generation) and the second thread (garbage collection). These wrappers track object references and enable efficient communication between threads, allowing the garbage collector to determine which objects need to be written without complex synchronization mechanisms.
2Ease of operation
If the garbage collector and other processes operate without synchronicity, then process independence is maintained, but the efficiency of memory management and object finalization is reduced
Solution Approach 1:
The handle wrappers provide feedback mechanisms that allow the garbage collector thread to efficiently determine which persistent objects are no longer referenced. The wrappers track reference counts and object status, enabling the garbage collector to make informed decisions about which objects to finalize without requiring complex synchronization with other processes.
Solution Approach 2:
The system dynamically adjusts the state of handle wrappers based on reference counts and object usage patterns. This dynamic state management allows the garbage collector to adapt to changing memory conditions in real-time, improving memory management efficiency while maintaining process independence through thread-level operation.
Data Source
AI summary
A method and computer-readable media for managing software object handles in a dual threaded or multi-threaded environment are provided. In a first version a software driven computational process drives a first thread, while a garbage collector process drives a second active computational thread within a host computer. The software driven computational process generates persistent software objects that are temporarily stored in a memory of the host. Each handle may include an object identifier of the handle itself, an open/closed flag and a pointer to a unique persistent object. The open/closed flag indicates whether the persistent object associated with a handle shall remain open and accessible for processing or may be selected for closure by the garbage collector process. A plurality of handle wrappers are each associated in a one-to-one correspondence with a unique handle. Each handle wrapper is a software data structure that may include a in-use/not in-use flag and a specific handle or a pointer to a handle.