Non-blocking Resource Pool Access via Multidimensional Search
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing computing environments with resource pools, such as connection pools, face scalability issues due to the inefficiencies of critical sections, which lead to performance limitations and thread blocking, making it difficult to support large numbers of threads and complex borrow operations.
Innovation Solution
A non-blocking process using atomic references and compareAndSet operations, along with a multidimensional search mechanism within a k-dimensional tree (KD-tree) to enable efficient access and reservation of resources without locking, allowing multiple threads to access and reserve resources concurrently.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If synchronization mechanisms (critical sections) are used to manage resource pool access, then thread safety is ensured, but scalability and performance deteriorate due to thread blocking
Solution Approach 1:
The patent segments the resource pool management by creating separate ownership domains for different threads. Each thread has its own set of pool elements it can access without synchronization, while shared pool elements use versioned references to coordinate access. This segmentation eliminates the need for global critical sections, allowing threads to operate independently on their assigned resources.
Solution Approach 2:
The patent introduces versioned pool element references as intermediaries between threads and pool resources. These references contain version information that allows threads to detect conflicts and retry operations without requiring traditional locking. The intermediary absorbs the synchronization complexity, enabling threads to proceed without blocking while maintaining thread safety through version checking.
2Manufacturing precision
If traditional locking mechanisms are used for complex borrow operations, then resource allocation accuracy is maintained, but operation time increases due to thread waiting
Solution Approach 1:
The patent performs preliminary validation of borrow operations by checking version information and availability status before actual resource allocation. This preliminary action identifies conflicts early, allowing the system to retry or abort operations without holding threads in blocked states. The version checking mechanism pre-validates access rights, ensuring allocation accuracy while minimizing waiting time.
Solution Approach 2:
The patent implements optimistic concurrency control where threads attempt to allocate resources without blocking, skipping ahead in the execution flow. If version conflicts are detected during the allocation process, threads retry the operation rather than waiting. This approach rushes through potential conflicts quickly, maintaining allocation accuracy through version verification while minimizing time loss through non-blocking retries.
3Device complexity
If resource pools are designed for simple access patterns, then implementation complexity is reduced, but adaptability to complex borrow operations deteriorates
Solution Approach 1:
The patent creates a universal pool element reference structure that handles both simple and complex borrow operations through the same mechanism. The versioned reference system provides a unified interface that works for single-element borrows, multi-element borrows with constraints, and conditional borrows. This universal approach maintains implementation simplicity while achieving high adaptability to various operation types.
Solution Approach 2:
The patent achieves operational flexibility through parameter changes in the pool element metadata, specifically availability status and version numbers. By modifying these parameters during operations, the system supports diverse borrow patterns without changing the core data structure. Threads can specify different borrow criteria (availability, version ranges), and the system adapts by checking and updating these parameters, providing versatility while maintaining simple implementation.
Data Source
AI summary
In accordance with an embodiment, a system enables multidimensional search within a resource pool, to support complex borrow operations such as, for example, specifying ranges for particular connection properties. As threads access the pool, attempting to borrow connections having particular connection properties, one or more skipped pool elements can be represented as skip lists within a k-dimensional tree (KD-tree) or other data structure that enables searching across multiple dimensions. In response to receiving a request to borrow a connection having particular connection properties, a multidimensional search can be performed within the KD-tree to determine the availability of a connection having the requested properties.