Concurrency-Restricting Lock Active Circulation Set
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In multithreaded environments, especially in multicore systems, the increasing number of threads competing for shared resources can lead to scalability collapse, where performance drops as threads are added, due to excessive coherence traffic and poor resource utilization.
Innovation Solution
A concurrency-restricting lock that divides threads into an active circulation set (ACS) and a passive set (PS), using policies like culling and long-term fairness to manage thread circulation, thereby restricting concurrency and improving throughput.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If the number of threads is increased to improve parallelism and throughput, then more threads can contend for shared resources, but scalability collapse occurs and performance drops due to excessive coherence traffic
Solution Approach 1:
The patent segments the set of threads waiting for a lock into two distinct subsets: an active circulation set (ACS) containing a limited number of threads that are actively contending for the lock, and a passive set (PS) containing threads that are not currently active contenders. This segmentation allows the system to limit the number of threads simultaneously accessing shared resources, thereby reducing coherence traffic while maintaining adequate parallelism through the controlled ACS size.
2Object-affected harmful factors
If concurrency restriction is applied to reduce coherence traffic, then fewer threads circulate over locks, but thread utilization may decrease
Solution Approach 1:
The patent implements dynamic management of the active circulation set through admission policies that can adjust which threads are active contenders based on system state. The culling policy dynamically removes threads from the ACS when it exceeds a threshold, and promotion policies can move threads from the passive set back to the ACS when conditions permit. This dynamic adjustment ensures optimal thread utilization by adapting the level of concurrency restriction to current system conditions, preventing both excessive interference and underutilization.
Data Source
AI summary
A concurrency-restricting lock may divide a set of threads waiting to acquire the lock into an active circulating set (ACS) that contends for the lock, and a passive set (PS) that awaits an opportunity to contend for the lock. The lock, which may include multiple constituent lock types, lists, or queues, may be unfair over the short term, but improve throughput of the underlying multithreaded application. Culling and long-term fairness policies may be applied to the lock to move excess threads from the ACS to the PS or promote threads from the PS to the ACS. These policies may constraint the size or distribution of threads in the ACS (which may be NUMA-aware). A waiting policy may avoid aggressive promotion from the PS to the ACS, and a short-term fairness policy may move a thread from the tail of a list or queue to its head.