Hierarchical Data Synchronization Without File Locking
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing data synchronization systems face challenges in maintaining data integrity and availability, particularly in environments without file locking, where changes to data sets can be unpredictable and violate hierarchical relationships, leading to inconsistencies across multiple nodes.
Innovation Solution
The system identifies hierarchical relationships within data sets and uses these relationships to control the order of changes, ensuring that data sets are synchronized while preserving consistency, even in environments where changes are unpredictable and cannot be locked, by initiating comparisons and processing changes in a sequence that maintains hierarchical relationships.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If file locking process is used to ensure data integrity during updates, then data consistency across copies is improved, but data set availability is reduced
Solution Approach 1:
The patent extracts the locking mechanism from the synchronization process entirely. Instead of using file locking to ensure data integrity, the system uses version numbers and hierarchical relationship validation to detect and resolve inconsistencies without preventing concurrent access to data sets.
Solution Approach 2:
The patent introduces version numbers as an intermediary mechanism. Each data element carries a version number that acts as a mediator to track changes and detect conflicts without requiring exclusive locks. This allows multiple nodes to read and write concurrently while maintaining integrity through version comparison.
2Productivity
If asynchronous updates are allowed from multiple nodes to improve performance, then system throughput is improved, but data integrity between copies deteriorates
Solution Approach 1:
The patent implements feedback through version number comparison. When a node receives an update, it compares the incoming version number with its local version number. This feedback mechanism allows asynchronous updates to proceed while automatically detecting and resolving conflicts, maintaining data integrity without sacrificing performance.
Solution Approach 2:
The patent applies preliminary action by validating hierarchical relationships and version numbers before applying updates. Nodes check version numbers and parent-child relationships in advance, ensuring that asynchronous updates maintain consistency without requiring centralized coordination or locking.
3Ease of operation
If changes are made without locking to maintain availability, then data set availability is improved, but transient inconsistencies between copies increase
Solution Approach 1:
The patent replaces the mechanical locking system with a software-based version control mechanism. Instead of using operating system file locks that prevent concurrent access, the system uses version numbers and hierarchical validation that allow concurrent access while detecting and resolving inconsistencies through logical comparison rather than physical exclusion.
Data Source
AI summary
Systems and methods for, among other things, updating a destination data set of hierarchical data in relation to a source set of hierarchical data. The method, in certain embodiments, includes receiving an indication that the source data set has one or more changes, initiating a comparison between the source data set and the destination data set, identifying differences and related hierarchical relationships, and altering the destination data set by performing changes in an order that preserves the hierarchical relationships. The method may use the change notifications as an indicator to start the comparison and restart the comparison upon the receipt of a new notification. By using this method, the two data sets can be kept synchronized while preserving hierarchical relationships between the data elements in an environment where the source data set experiences unpredictable changes and cannot be locked.