Shared Memory Page Table Copy-on-Write Latency
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional memory locking mechanisms cause delays in accessing shared memory when one application is modifying the data, especially under intensive read and write workloads from multiple application processes, limiting the efficiency of shared memory access.
Innovation Solution
A system that configures page tables to create a copy of original page data in physical memory upon a write request, allowing processes to modify the copy while maintaining read access to the original data, and uses synchronization calls to transparently migrate data between shared and private states, minimizing latency and enabling efficient data sharing.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If conventional memory locking mechanisms are used to enable mutual-exclusion between different applications accessing shared memory, then data consistency is maintained, but access latency increases significantly especially under intensive read and write workloads
Solution Approach 1:
The patent segments the shared memory access mechanism into multiple components: read-set logging, version tracking, and selective synchronization. Instead of locking the entire shared memory segment, the system divides access control into fine-grained operations that track which processes have read which data, enabling parallel access while maintaining consistency through coordinated updates at synchronization points.
Solution Approach 2:
The patent implements dynamic access control where the synchronization mechanism adapts to actual workload patterns. The system dynamically adjusts which processes need to be synchronized based on real-time tracking of read sets and version changes, rather than using static locking protocols. This allows the system to optimize performance by reducing unnecessary synchronization overhead while maintaining data consistency.
2Reliability
If memory locking mechanisms are implemented to prevent concurrent modifications, then data integrity is preserved, but productivity of multiple application processes decreases due to waiting delays
Solution Approach 1:
The patent introduces an intermediary logging mechanism that records read sets and version information without requiring processes to wait for locks. The system uses this intermediary data structure to track which processes have accessed which data, enabling the main execution paths to proceed in parallel while integrity is maintained through coordinated updates at synchronization points rather than through blocking locks.
Solution Approach 2:
The patent implements a form of copying where read sets are logged and version information is tracked separately from the actual data. This allows multiple processes to work with copies of version metadata and read set information simultaneously, enabling parallel execution while the underlying data maintains integrity through version-controlled updates.
3Productivity
If copy-on-write mechanism is used to allow parent and child processes to write to their own copies, then write performance improves, but the ability to hide modifications and then make them visible to child processes is lost
Solution Approach 1:
The patent implements preliminary action by logging read sets and tracking version changes before actual modifications are made visible to other processes. The system prepares the synchronization state in advance by recording which processes have read which data, enabling controlled visibility of modifications without requiring immediate copy-on-write for all processes. This allows the parent process to make modifications and then selectively make them visible to child processes based on the logged read sets.
Solution Approach 2:
The patent makes the memory sharing mechanism dynamic by allowing transitions between shared and private states based on synchronization events. Rather than using static copy-on-write, the system dynamically adjusts the visibility of modifications through synchronization points where logged read sets are coordinated with version updates, enabling flexible control over when child processes see parent process modifications.
Data Source
AI summary
A system configures page tables to cause an operating system to copy original page data in a data store when any one of the application processes makes a first write request for the original page data. The system detects a page fault from a memory management unit receiving a first write request from one of the application processes and creates the copy in physical memory to allow the application process to modify the page data copy. The other application processes have read access to the original page data. The system replaces the original page data in the data store with the page data copy in response to receiving a first synchronization request from the application process and updates a page table for one of the other application processes to configure access to the replaced page data in response to receiving a second synchronization request from the one other application process.