Asynchronous Counting Gate for Non-Blocking Resource Access
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing systems fail to manage access requests to computing resources without blocking the requesting thread, leading to inefficiencies and resource contention.
Innovation Solution
Implement an asynchronous access control mechanism that allows threads to continue executing while awaiting resource access permissions, using a queue for incomplete requests and dynamic permit limits.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If a thread requests access to a computing resource and waits for permission, then access control is maintained, but the thread is blocked from performing other operations
Solution Approach 1:
The patent segments the access control mechanism into separate components: a gate object that manages permits independently of thread execution. Threads can request permits without being blocked, allowing the access control function to be separated from the thread scheduling function. This resolves the contradiction by maintaining access control reliability while preventing thread blocking.
Solution Approach 2:
The patent introduces an intermediary permit system where threads interact with a gate object through permit requests rather than direct resource access. The gate object acts as a mediator that tracks permit usage and enforces access limits without blocking threads. This intermediary mechanism maintains access control while allowing continuous thread execution.
2Reliability
If a thread is blocked while awaiting resource access, then resource contention is controlled, but resource utilization decreases
Solution Approach 1:
The patent enables continuous thread execution by allowing threads to perform other operations while awaiting resource access. Instead of blocking threads, the system allows them to continue useful work and check permit availability later. This maintains resource contention control while maximizing resource utilization through continuous productive action.
Solution Approach 2:
The patent implements preliminary permit acquisition where threads can request permits in advance without blocking. Threads prepare their access requests and continue executing other tasks, checking back later for permit availability. This preliminary action approach controls resource contention while maintaining high resource utilization.
3Reliability
If traditional access control mechanisms are used, then resource access is regulated, but blocking times increase
Solution Approach 1:
The patent implements a dynamic permit system where the gate object can adjust permit availability and track usage flexibly. Rather than static blocking mechanisms, the system dynamically manages permit allocation and allows threads to check availability at their convenience. This dynamic approach maintains access regulation while eliminating fixed blocking times.
Solution Approach 2:
The patent incorporates feedback mechanisms where threads can query the gate object for current permit availability and adjust their execution accordingly. The gate object provides feedback on permit status, allowing threads to make informed decisions about when to attempt resource access. This feedback loop maintains access regulation while minimizing unnecessary blocking time.
Data Source
AI summary
Techniques are disclosed for restricting access to a computing resource in a manner that does not block the performance of other operations in a multi-thread computing environment. A software gate receives a request from a thread for permission to access a computing resource. Responsive to receiving the request, the software gate determines that a dynamic permit limit currently prevents the request from being granted. The software gate returns a data structure indicating that the request is incomplete, adds the request to a queue of pending requests, and releases the thread. Once released, the thread is free to perform other operations while the request is pending. If the request subsequently becomes allowable, the software gate grants the request, removes the request from the queue, and updates the data structure to indicate the request is complete.