Concurrent Computing Locking Reduction via Thread-Specific Constraints
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In concurrent computing systems with multi-core architectures, existing synchronization techniques limit concurrency and core utilization by requiring extensive locking mechanisms to ensure data consistency, which can lead to poor performance due to increased overhead.
Innovation Solution
A method where data shared among multiple threads is modified by determining if the modification violates a constraint associated with a tolerance value divided among threads, allowing threads to update thread-local data without locking unless necessary, thereby reducing locking requirements and enhancing concurrency.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If synchronization and locking techniques are used to ensure data consistency, then data consistency is improved, but concurrency and core utilization deteriorate
Solution Approach 1:
The patent segments the tolerance value into multiple thread-specific constraints, allowing each thread to have its own constraint threshold. This segmentation enables threads to modify shared data independently when their individual constraints are satisfied, reducing the need for centralized locking while maintaining overall data consistency within the aggregate tolerance.
Solution Approach 2:
The patent changes the parameter from a single global tolerance value to multiple thread-specific constraint values that collectively represent the tolerance. This parameter transformation allows flexible control over data consistency requirements for different threads, enabling concurrent modifications without requiring strict locking mechanisms.
2Reliability
If locking mechanisms are implemented to prevent inconsistent reads, then data consistency is improved, but system performance deteriorates due to increased overhead
Solution Approach 1:
The patent applies partial action by requiring locking only when thread-local constraint violations occur, rather than requiring locking for every data access. Threads can proceed with modifications without locking as long as their constraint checks pass, reducing synchronization overhead while still preventing inconsistent states when constraints are violated.
Solution Approach 2:
Each thread performs self-service by checking its own constraint before modifying shared data. This self-check mechanism eliminates the need for centralized locking in many cases, as threads autonomously determine whether their modification would violate the tolerance, reducing synchronization overhead and improving performance.
3Reliability
If extensive locking is used to ensure consistency, then data consistency is improved, but core utilization deteriorates
Solution Approach 1:
The patent segments the global consistency requirement into thread-specific constraint checks, simplifying the locking mechanism. Instead of requiring complex coordinated locking among multiple threads, each thread independently checks its constraint against the shared data, reducing the complexity of the synchronization mechanism while maintaining consistency.
Solution Approach 2:
The patent introduces constraint values as intermediaries between threads and shared data. These constraint values act as a mediator that translates the global tolerance requirement into thread-specific rules, simplifying the interaction between concurrent threads and reducing the complexity of direct locking mechanisms.
Data Source
AI summary
Where data are shared by multiple computer processing threads, modifying the data by determining whether modifying data associated with a first computer processing thread violates a constraint associated with the data, and responsive to determining that modifying the data associated with the computer processing thread violates the constraint associated with the data, using the data associated with the first computer processing thread to modify the data shared by the multiple computer processing threads that includes the first computer processing thread, where the constraint associated with the data associated with the first computer processing thread represents a portion of a tolerance value that is associated with the data shared by the multiple computer processing threads and that is divided among multiple constraints, where each of the constraints is associated with a different one of the multiple computer processing threads.