Non-blocking Write Mechanism for Operating System Page Data
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The existing 'fetch-before-write' approach in operating systems leads to process blocking during page writes, as the system synchronously fetches pages from backing storage, resulting in inefficient performance, especially in data-intensive workloads and systems with high memory usage.
Innovation Solution
Implementing non-blocking writes by creating in-memory patches for updated pages, allowing the writing process to continue without waiting for page fetches to complete, and buffering data elsewhere in memory, enabling asynchronous page fetches and reducing process blocking.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If synchronous page fetch is performed before write operation, then data consistency is ensured, but process blocking occurs and system performance deteriorates
Solution Approach 1:
The patent applies preliminary action by creating in-memory patches for updated pages before the actual page fetch completes. The system prepares patch data structures that contain the write operations, which will be applied to the page once it is fetched from backing storage. This allows the writing process to continue without waiting for the synchronous page fetch, thereby maintaining data consistency while improving system performance.
2Ease of operation
If page is fetched into memory before write, then write operation can proceed, but process must wait and blocking occurs
Solution Approach 1:
The system performs preliminary actions by preparing patch data structures that encapsulate the write operations before the page fetch completes. These patches are created in advance and stored in memory, allowing the writing process to proceed immediately without waiting for the page to be fetched from backing storage. The patches will be applied to the page once it becomes available, eliminating process blocking and reducing waiting time.
3Reliability
If fetch-before-write constraint is enforced, then data integrity is maintained, but asynchronous write capability is lost
Solution Approach 1:
The patent enables asynchronous write capability by creating patch data structures in advance that contain the write operations. These patches are prepared before the page fetch completes, allowing the writing process to continue asynchronously without waiting for the page to be available in memory. The patches ensure data integrity by being applied to the page once it is fetched, thus maintaining reliability while enabling asynchronous operation.
4Device complexity
If synchronous page fetch is used for writes, then simplicity of implementation is maintained, but system throughput is reduced
Solution Approach 1:
The system maintains implementation simplicity by using a straightforward approach of creating patch data structures before page fetch completes. The patch creation logic is integrated into the existing write path, and the patches are applied once the page is available. This preliminary action approach does not require complex changes to the overall system architecture, yet it significantly improves system throughput by eliminating process blocking during page fetch operations.
Data Source
AI summary
Techniques and systems are disclosed for implementing non-blocking writes to eliminate the fetch-before-write requirement by creating an in-memory patch for the updated page and unblocking the calling process. Non-blocking writes eliminate such blocking by buffering the written data elsewhere in memory and unblocking the writing process immediately. Subsequent reads to the updated page locations are also made non-blocking and, in some cases, can be eliminated when the read request can be serviced from in-memory patches.Implementation scenarios can include an operating system (OS) enhancement, revision to an existing OS component (e.g., the OS kernel), special OS component, or enhancement to the software or firmware of the controller software or microcontroller of a storage device or array of storage devices.