Lightweight Coherency Control Protocol for Clustered Storage
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In clustered storage systems, maintaining data coherency across multiple nodes is inefficient due to the overhead required by distributed locking mechanisms, which can lead to performance degradation when a single data container is heavily accessed, causing individual storage systems to become overburdened.
Innovation Solution
A lightweight coherency control protocol that uses a current cache sequence number, comprising a load generation value and an update count, to validate and update data buffers, ensuring that cached copies are up-to-date with the authoritative version, allowing for efficient distribution of file system buffers across multiple storage systems without the need for distributed locking.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If distributed locking mechanisms are used to maintain data coherency across clustered storage nodes, then data consistency is ensured, but system overhead increases and performance degrades when single data containers are heavily accessed
Solution Approach 1:
The patent extracts the locking mechanism from the coherency control process entirely. Instead of using distributed locks to manage data consistency, the system uses a lock-free validation approach where nodes validate data freshness by comparing sequence numbers (svns) and version identifiers (vids) without acquiring any locks, thereby eliminating the overhead associated with distributed locking while maintaining data consistency
Solution Approach 2:
The patent changes the control parameter from lock acquisition status to sequence number and version identifier comparison. Each data container has an associated svn and vid that are incremented on updates. Nodes validate coherency by comparing these parameters rather than through locking, transforming the control mechanism from a resource-based approach to a parameter-based validation approach that reduces system overhead
2Productivity
If volumes are distributed across all storage systems to balance processing load, then individual node processing load is reduced, but coherency control overhead increases
Solution Approach 1:
The patent applies preliminary action by pre-incrementing sequence numbers (svns) and version identifiers (vids) at the time of data updates. This allows future validation operations to simply compare these pre-computed parameters rather than performing complex coherency checks, reducing the time overhead for coherency control while maintaining distributed volume architecture for load balancing
3Speed
If heavy access requests are concentrated on single data containers, then data access efficiency is improved, but individual storage systems become overburdened and performance degrades
Solution Approach 1:
The patent segments the data access workload across multiple storage nodes by distributing volumes containing different data containers across the cluster. Heavy access patterns are naturally distributed because different high-demand data containers reside on different nodes, preventing any single node from becoming overburdened while maintaining efficient access to frequently accessed data through local caching and validation
Data Source
AI summary
A lightweight coherency control protocol ensures consistency of data containers, such as a file, and associated data buffers stored on one or more volumes served by a plurality of nodes, e.g., storage systems, connected as a cluster. Each data buffer is associated with a current cache sequence number comprising a load generation value and an update count value. The load generation value is incremented every time an inode of a file is loaded into a memory of the storage system. Once the inode is loaded and its load generation value is set, then the appropriate buffer of a buffer tree for the file is loaded into the memory. The update count value is incremented each time the buffer is updated with a write request/operation. Therefore, each buffer loaded into memory is tagged with the load generation value and an update count from the time that buffer is loaded.