Concurrent Extensible Cuckoo Hashing with Overflow Buffers
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional sequential cuckoo hashing algorithms face bottlenecks when applied to multicore or multithread processors, as they require locking the entire hash table during operations, leading to decreased performance due to waiting processes.
Innovation Solution
The concurrent extensible cuckoo hashing method breaks operations into phases, reduces the number of locks needed, and uses overflow buffers to manage displaced values, allowing concurrent execution and minimizing bottlenecks by acquiring at most two locks per phase and using overflow buffers to hold values.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If conventional sequential cuckoo hashing locks the entire hash table during operations, then data consistency is maintained, but processor performance decreases due to waiting processes
Solution Approach 1:
The patent segments the hash table into multiple independent buckets, each protected by its own lock instead of a single global lock. This allows concurrent operations on different buckets simultaneously, resolving the contradiction between maintaining data consistency and improving processor performance in multicore environments.
Solution Approach 2:
The patent implements dynamic locking where locks are acquired and released during the cuckoo hashing operation sequence. The locking strategy adapts to the specific operation being performed (add, remove, contains) and the current state of the hash table, allowing fine-grained concurrency while maintaining consistency where needed.
2Reliability
If the hash table is locked until a single operation finishes, then operation correctness is ensured, but concurrent execution of multiple processes is blocked
Solution Approach 1:
The patent divides the hash table into separate buckets, each with its own lock. This segmentation enables multiple processes to execute concurrently on different buckets without blocking each other, while still ensuring correctness through proper lock management and atomic operations on individual buckets.
Solution Approach 2:
The patent uses locks as intermediary mechanisms that mediate between concurrent processes and the hash table data. Each lock acts as a mediator that allows controlled access to its protected bucket, enabling concurrent execution while maintaining operation correctness through synchronized access patterns.
3Device complexity
If sequential cuckoo hashing is used, then algorithm simplicity is maintained, but bottlenecks occur in multicore processor environments
Solution Approach 1:
The patent maintains the simplicity of sequential cuckoo hashing by preserving the basic swap-based displacement mechanism, while adding bucket-level segmentation with individual locks. This allows the algorithm to remain conceptually simple while eliminating the bottleneck of global locking in multicore environments.
Solution Approach 2:
The patent applies local locking at the bucket level rather than global locking, creating local quality in the synchronization strategy. Each bucket has its own lock that is acquired and released independently, allowing concurrent operations on different buckets while maintaining the simplicity of the underlying cuckoo hashing logic.
Data Source
AI summary
Concurrent cuckoo hashing is performed on a hash table that includes a number of locations; each may hold a value. A plurality of processes may concurrently execute on the table; each process includes a sequence of operations, which are divided into a number of phases. Each phase corresponds to one operation in the sequence. An overflow buffer is provided for each location in the table. Each overflow buffer may hold a value displaced from its corresponding location in the table. A plurality of sequences of operations is concurrently executed. Each phase in a sequence executes by acquiring one or two locks on two locations in the table; a lock acts on a location and its overflow buffer. An operation of a phase is then executed. If, on conclusion of the phase execution, any overflow buffer holds a value, the execution is repeated until all overflow buffers are empty.