Graph Data Store Persistent Memory Iterator Management
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing graph-based databases do not support a completely in-memory database model, limiting their ability to leverage new persistent memory technologies like memristors and phase change memory for faster and larger main memories, and fail to provide efficient management of connected data with ACID properties.
Innovation Solution
A computing device with a processor, I/O subsystem, on-die cache, and memory controller that stores an entire graph data store in persistent memory, using volatile memory for iterator objects to access and manage nodes and edges efficiently, minimizing writes to persistent memory and maintaining ACID properties through partitioning data between volatile and persistent memory.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If graph data is stored entirely in persistent memory, then data durability and storage capacity are improved, but memory access speed and write performance deteriorate
Solution Approach 1:
The system segments the graph data into two parts: node data is stored in persistent memory for durability, while edge data is stored in volatile memory for fast access. This segmentation allows each memory type to be optimized for its specific function, resolving the contradiction between durability and speed.
Solution Approach 2:
The system introduces an intermediary mechanism where the persistent memory stores only node data and provides references to edge data in volatile memory. This intermediary approach allows the persistent memory to maintain durability while the volatile memory provides fast access paths through the references.
2Speed
If graph data is stored entirely in volatile memory, then memory access speed is improved, but data durability and persistence deteriorate
Solution Approach 1:
The system segments memory responsibilities by placing node data in persistent memory for durability and edge data in volatile memory for speed. This segmentation allows the system to achieve both durability and fast access without compromising either aspect.
Solution Approach 2:
The system uses persistent memory as an intermediary that stores node data and provides stable references to edge data in volatile memory. This intermediary structure ensures data durability while maintaining fast access paths through the volatile memory references.
3Reliability
If iterator objects are stored in persistent memory, then data durability is improved, but iterator management complexity and write operations increase
Solution Approach 1:
The system extracts iterator objects from the persistent memory storage and places them in volatile memory. This extraction simplifies iterator management by removing the complexity of tracking iterators in persistent memory while maintaining durability through the persistent memory storage of graph data.
Solution Approach 2:
The system introduces volatile memory as an intermediary for storing iterator objects, separating the iterator management function from the persistent memory storage function. This intermediary approach reduces the complexity of iterator management while preserving data durability through the persistent memory.
4Quantity of substance
If more data is stored in persistent memory, then storage capacity utilization is improved, but write operations and wear increase
Solution Approach 1:
The system segments the storage of graph data by placing node data in persistent memory and edge data in volatile memory. This segmentation reduces the quantity of writes to persistent memory while still utilizing persistent memory capacity for durable storage, thereby reducing wear.
Solution Approach 2:
The system introduces volatile memory as an intermediary for storing edge data and iterator objects, reducing the burden of write operations on persistent memory. This intermediary structure allows persistent memory to be used for durable storage with minimal write operations, reducing wear.
Data Source
AI summary
Managing connected data, such as a graph data store, includes a computing device with persistent memory and volatile memory. The computing device stores a graph data store with a plurality of nodes and edges in persistent memory. Each of the edges defines the relationship between at least two of the nodes. The nodes and edges may contain tags and properties containing additional information. In response to a search request query, the computing device generates an iterator object stored in volatile memory with a reference to one or more nodes and/or edges in the graph data store. The split between volatile and persistent memory allocation could be used for other objects, such as allocators and transactions. Other embodiments are described and claimed.


