Hierarchical Shared Memory for Concurrent State Updates
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current shared memory designs face performance and scalability issues due to the need for re-copying entire state processes with every change, leading to processing speed impairments and memory resource constraints, particularly in large-scale systems, and are burdened by complex hash table management and overhead in single-level hierarchy approaches.
Innovation Solution
A multi-level hierarchical shared memory architecture that allows concurrent, independent access by writer and reader agents, using a hierarchical state tree with smart addressing schemes and notification coalescing to manage state changes efficiently, reducing memory usage and avoiding complex design intricacies.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If traditional shared memory designs are used with single-level hierarchy, then implementation is simpler, but performance deteriorates due to re-copying entire state processes with every change
Solution Approach 1:
The patent divides the shared memory into a multi-level hierarchical structure with parent and child entries, where each level represents a segment of the state data. This segmentation allows only the specific changed portion (child entry) to be updated and notified, rather than re-copying the entire state process, thereby improving processing speed while maintaining manageable complexity through organized structure.
Solution Approach 2:
The patent transitions from a single-level flat memory structure to a multi-dimensional hierarchical structure with multiple levels of parent-child relationships. This dimensional change enables selective notification and update propagation through the hierarchy, allowing fast updates at specific levels without affecting the entire memory structure, thus improving productivity.
2Reliability
If entire state processes are re-copied with every change, then data consistency is maintained, but memory resource consumption increases
Solution Approach 1:
The patent extracts and separates the notification mechanism from the entire state copy process. Instead of copying all state data, only the specific changed entry (child entry) is updated and a notification is extracted and propagated through the hierarchy. This allows data consistency to be maintained through selective updates while significantly reducing memory resource consumption.
Solution Approach 2:
The patent applies local quality by allowing different parts of the memory hierarchy to have different update behaviors. Parent entries maintain references to child entries, and when a child entry changes, only that local portion is updated and notified. This localized update approach ensures data integrity for changed portions while avoiding unnecessary copying of unchanged portions, reducing memory resource usage.
3Adaptability or versatility
If conventional shared memory approaches are used, then implementation is straightforward, but scalability is limited in large-scale systems
Solution Approach 1:
The patent segments the memory management into hierarchical levels with parent-child relationships, replacing the conventional single-level hash table approach. This segmentation allows the system to scale by adding more hierarchical levels or entries at each level without managing a single massive hash table, improving scalability while distributing management complexity across multiple manageable levels.
Solution Approach 2:
The patent introduces dynamic notification propagation through the hierarchical structure. When entries are added, modified, or removed, notifications are dynamically propagated from child to parent entries through the hierarchy. This dynamic approach allows the system to adapt to changes at any level and scale efficiently, as the notification mechanism automatically adjusts to the hierarchical structure rather than requiring complex centralized hash table management.
Data Source
AI summary
Systems and methods for creating a new entry in a hierarchical state data structure with object entries is disclosed. The method includes allocating a shared memory buffer for a new entry in a shared memory. A request to create the new entry for a child object in a hierarchical state data structure in the shared memory is received. The new entry is to span at least one shared memory buffer uniquely identifiable in a location of the shared memory. The child object is a logical representation of a state of a system. In response to a request for an allocation of a shared memory buffer within a region of the shared memory for the new entry, a location identifier corresponding to a location of a parent entry holding a parent object to the child object in the hierarchical state data structure of an allocated region is received. The child object is created in the shared memory buffer for the new entry, and the new entry is available for concurrent access by one or more readers of the shared memory.