Shared Memory Tracking via Dual Array Mapping
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing computing systems face issues with memory corruption and leaks during initialization and reinitialization due to shared memory allocation among multiple processes, which existing techniques have not adequately addressed.
Innovation Solution
A method and system utilizing two arrays to track memory allocation within shared memory, where a first array stores process identifiers and a second array stores references to process-specific data in shared memory blocks, allowing for efficient memory management and reclamation.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If shared memory is allocated to multiple processes, then resource utilization is improved, but memory corruption and memory leaks occur during initialization and reinitialization
Solution Approach 1:
The patent segments the shared memory management by creating separate array structures: one array stores process identifiers and another array stores corresponding memory references. This segmentation allows independent tracking of each process's memory allocation, preventing corruption while maintaining shared memory utilization across multiple processes.
Solution Approach 2:
The patent introduces intermediary data structures (two arrays acting as a mapping mechanism) between processes and shared memory blocks. These arrays serve as mediators that track and manage memory allocations, ensuring proper initialization and reinitialization without direct process interference, thus preventing memory leaks and corruption.
2Reliability
If memory is tracked using complex data structures, then memory integrity is improved, but system complexity increases
Solution Approach 1:
The patent uses homogeneous array structures to track memory allocations. Both arrays are simple, uniform data structures where one array stores process identifiers and the other stores memory references at corresponding indices. This homogeneous approach maintains memory integrity through consistent indexing without introducing complex nested data structures.
Solution Approach 2:
The patent creates a simplified copy of the allocation tracking mechanism using two parallel arrays instead of complex pointer-chasing data structures. Each array entry corresponds to a specific process, creating a direct mapping that is easier to manage and less prone to errors while maintaining complete tracking capability.
3Reliability
If memory allocation is tracked for each process, then memory leaks are prevented, but access time increases
Solution Approach 1:
The patent performs preliminary action by pre-allocating array entries for each process before memory allocation occurs. When a process is created or identified, its entry is prepared in both arrays, establishing a ready-to-use mapping structure. This eliminates the need for complex searches during memory operations, maintaining fast access times while enabling complete tracking for leak prevention.
Solution Approach 2:
The two-array structure serves multiple functions simultaneously: it tracks active processes, maps process identifiers to memory blocks, enables quick lookup for allocation status, and facilitates reinitialization. This universal data structure achieves comprehensive memory leak prevention without proportionally increasing access time, as all functions are served through efficient array indexing.
Data Source
Figure 1
Figure 2
Figure 3
AI summary
Systems and methods for tracking memory allocation within shared memory are provided. In one embodiment, a method includes tracking memory allocation within shared memory. The method includes receiving instructions 508 to execute a process. The method includes assigning a process identifier to the process. The method includes allocating one or more blocks of the shared memory to store process specific data 510 associated with the process, wherein the one or more blocks of the shared memory are addressable with a reference. The method includes storing the process identifier at an index in a first array 100. The method includes storing, by the one or more processors 504, the reference to the one or more blocks of the shared memory at the index in a second array 110.