MVCC Timestamp Assignment for Distributed Database Throughput
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing multiversion concurrency control algorithms in distributed databases perform commit wait while holding user-level locks at servers, limiting write throughput to at most (1/commit wait time).
Innovation Solution
The commit wait time is moved from the server to the client library or other devices in the distributed system, allowing the server to release user-level locks without waiting for the commit wait time to expire. This is achieved by assigning a timestamp to the written data, which clients must wait for before reading the data.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If the server performs commit wait while holding user-level locks, then data consistency is ensured, but write throughput is limited to at most (1/commit wait time)
Solution Approach 1:
The patent extracts the commit wait operation from the server-side lock holding context and relocates it to the client-side. The server no longer performs commit wait while holding locks; instead, the client performs commit wait after receiving data. This separation allows the server to release locks immediately after writing, eliminating the throughput bottleneck while maintaining consistency through client-side waiting.
Solution Approach 2:
The patent inverts the traditional commit wait location from server-side to client-side. Instead of the server waiting for commit time to pass before releasing locks, the client waits for commit time to pass after receiving the data. This inversion resolves the contradiction by allowing the server to proceed without blocking on commit wait, thereby improving throughput while the client ensures consistency.
2Productivity
If the server releases locks during commit wait time, then write throughput increases, but data consistency may be compromised
Solution Approach 1:
The commit wait operation is extracted from the server's lock holding period and relocated to the client's data reception phase. This allows the server to release locks immediately after writing completes, maximizing throughput, while the client ensures consistency by waiting for the commit timestamp before processing the data.
Solution Approach 2:
The commit timestamp acts as an intermediary mechanism that coordinates between server and client. The server uses the timestamp to indicate when data becomes visible, and the client uses it to synchronize its read operations. This intermediary allows the server to release locks without compromising consistency, as the timestamp ensures proper ordering.
3Reliability
If commit wait is performed by the client library before notifying clients, then consistency is maintained, but client response time increases
Solution Approach 1:
The server performs the preliminary action of assigning a commit timestamp immediately after writing the data, before the client even receives the data. This allows the client to understand the commit timing requirements in advance. The actual commit wait then occurs naturally as part of the client's normal data processing flow, minimizing additional delay.
Data Source
AI summary
Throughput is preserved in a distributed system while maintaining concurrency by pushing a commit wait period to client commit paths and to future readers. As opposed to servers performing commit waits, the servers assign timestamps, which are used to ensure that causality is preserved. When a server executes a transaction that writes data to a distributed database, the server acquires a user-level lock, and assigns the transaction a timestamp equal to a current time plus an interval corresponding to bounds of uncertainty of clocks in the distributed system. After assigning the timestamp, the server releases the user-level lock. Any client devices, before performing a read of the written data, must wait until the assigned timestamp is in the past.