Helper Thread Execution for Wait-Free Process Requests
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Multicore processing systems face performance issues due to high contention among threads accessing shared data structures, leading to thread starvation and reduced system performance, despite the use of non-blocking algorithms like lock-free and wait-free designs.
Innovation Solution
A dedicated helper thread is used to execute process requests placed on a state array, reducing worker thread contention and ensuring wait-free progress guarantees, with a fallback mechanism to restart the helper thread if it fails to execute requests within a predetermined time.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If multiple worker threads access shared data structures simultaneously, then system throughput increases, but thread contention and starvation occur
Solution Approach 1:
The patent segments the execution of process requests by introducing a dedicated helper thread that is responsible for executing requests from the state array, while worker threads are segmented into collectors that place requests at predetermined positions. This segmentation separates the collection function from the execution function, reducing contention on shared data structures.
Solution Approach 2:
The helper thread acts as an intermediary between worker threads and the shared data structures. Worker threads place process requests in the state array at predetermined positions, and the helper thread executes these requests. This intermediary mechanism eliminates the need for worker threads to directly access and execute shared data structures, thereby reducing contention and starvation.
2Reliability
If non-blocking algorithms are used to reduce contention, then thread starvation is reduced, but system performance still degrades due to memory access time
Solution Approach 1:
The patent assigns predetermined positions in the state array to specific worker threads, creating a local ownership model. Each worker thread places requests at its assigned position, and the helper thread executes from that position. This local quality assignment reduces the need for global synchronization and minimizes memory access conflicts, thereby reducing both starvation and memory access time penalties.
3Speed
If worker threads directly execute process requests, then execution speed increases, but contention on shared data structures increases
Solution Approach 1:
The patent merges the execution function into a dedicated helper thread that is shared by all worker threads. Instead of each worker thread having its own execution capability, they all contribute to a common state array that the helper thread executes. This merging reduces the complexity of thread coordination while maintaining execution speed through the specialized helper thread.
Data Source
AI summary
One embodiment provides a method, including: utilizing at least one processor to execute computer code that performs the steps of: receiving a system instruction from the at least one processor to perform an operation on a data structure; collecting, using at least one worker thread from a plurality of worker threads, a process request associated with the system instruction, wherein the plurality of worker threads perform operations within a computer system; placing the collected process request at a predetermined position on a state array, wherein the predetermined position is assigned to the at least one worker thread and wherein a helper thread is dedicated to the state array to execute requests placed within the state array; and executing the process request. Other aspects are described and claimed.