Thread Arbitration Table with History Shift Register
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In multi-threaded processor systems, resource allocation inefficiencies lead to throughput losses due to thread hogs that monopolize shared resources, affecting overall performance.
Innovation Solution
A thread arbitration system that uses a thread arbitration table with high and low threshold values and a thread history shift register to dynamically allocate resources, stalling or releasing threads based on their allocation history, ensuring fair access to shared resources like the pick queue.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If dynamic resource allocation is used to improve throughput, then overall system performance improves, but thread hogs may monopolize resources causing throughput losses
Solution Approach 1:
The patent implements feedback mechanisms through thread history shift registers that track allocation patterns and arbitration tables that use threshold comparisons. When a thread exceeds the high threshold for allocated entries, the system detects this as potential hogging behavior and responds by stalling further allocations to that thread, creating a feedback loop that prevents resource monopolization while maintaining dynamic allocation benefits
Solution Approach 2:
The system dynamically adjusts resource allocation based on real-time thread behavior patterns. The thread history shift register continuously updates allocation history, and the arbitration table dynamically modifies allocation decisions based on current thread needs versus historical patterns. This dynamic approach allows the system to adapt to changing workload conditions while preventing threads from permanently monopolizing resources
2Adaptability or versatility
If shared resources are allocated to multiple threads, then resource utilization efficiency improves, but arbitration complexity increases
Solution Approach 1:
The arbitration mechanism is segmented into distinct functional components: thread history shift registers for tracking allocation patterns, arbitration tables for storing threshold values and making decisions, and allocation logic for executing decisions. This segmentation allows each component to perform its specific function efficiently, reducing overall system complexity while maintaining flexible multi-threaded resource allocation
Solution Approach 2:
The system uses partial action by implementing arbitration only when threshold conditions are met, rather than continuously monitoring all threads. The high and low thresholds create boundaries that trigger arbitration actions only when necessary, reducing the complexity of continuous arbitration while maintaining effective resource allocation flexibility
Data Source
AI summary
Systems and methods for efficient thread arbitration in a processor. A processor comprises a multi-threaded resource. The resource may include an array of entries which may be allocated by threads. A thread arbitration table corresponding to a given thread stores a high and a low threshold value in each table entry. A thread history shift register (HSR) indexes the table, wherein each bit of the HSR indicates whether the given thread is a thread hog. When the given thread has more allocated entries in the array than the high threshold of the table entry, the given thread is stalled from further allocating array entries. Similarly, when the given thread has fewer allocated entries in the array than the low threshold of the selected table entry, the given thread is permitted to allocate entries. In this manner, threads that hog dynamic resources can be mitigated such that more resources are available to other threads that are not thread hogs. This can result in a significant increase in overall processor performance.