Runtime Context Storage for Reconfigurable Thread Execution
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing systems face inefficiencies in managing concurrent threads on reconfigurable processing grids due to inconsistent latency operations, leading to idle processing resources and reduced throughput and latency, particularly when executing dataflow graphs in a pipeline fashion.
Innovation Solution
Storing thread contexts in a context storage to manage execution of concurrent threads, allowing pausing and resuming threads without reconfiguring the processing grid, and utilizing multiple context entries and buffer storage to optimize thread management and scheduling.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If conventional thread management is used on reconfigurable processing grids, then thread execution is possible, but processing resources remain idle during inconsistent latency operations and throughput is reduced
Solution Approach 1:
The patent implements context storage that preserves thread execution state during inconsistent latency operations, allowing processing resources to continuously execute other threads instead of remaining idle. This ensures useful action continues uninterrupted by storing and restoring thread contexts as needed.
Solution Approach 2:
The patent introduces context storage as an intermediary mechanism between thread execution and processing resources. This intermediary preserves thread state information, enabling seamless switching between threads and preventing resource idle time during operations with variable completion times.
2Adaptability or versatility
If reconfiguring logical elements is performed to execute different threads, then thread execution flexibility is achieved, but configuration time increases and reduces overall execution speed
Solution Approach 1:
The patent performs preliminary configuration of logical elements for a first thread before its execution begins. This preliminary action allows the system to have thread execution flexibility ready in advance, eliminating the need for reconfiguration during thread switching and maintaining high execution speed.
Solution Approach 2:
The patent implements dynamic thread context management where the system can switch between different thread configurations by restoring previously saved contexts rather than performing static reconfiguration. This dynamic approach maintains adaptability while reducing configuration overhead and improving execution speed.
3Ease of operation
If concurrent threads are executed simultaneously, then system responsiveness increases, but managing thread contexts becomes more complex
Solution Approach 1:
The patent creates copies of thread execution contexts and stores them in dedicated context storage. This copying mechanism simplifies concurrent thread management by preserving complete thread states without requiring complex inter-thread coordination, thereby maintaining system responsiveness while reducing management complexity.
Solution Approach 2:
The patent segments thread management by separating thread execution from thread context storage. Each thread's context is independently stored and managed, allowing concurrent execution to proceed with minimal coordination overhead. This segmentation reduces the complexity of managing multiple concurrent threads while maintaining high responsiveness.
Data Source
AI summary
A system for processing a plurality of concurrent threads comprising: a reconfigurable processing grid, comprising logical elements and a context storage for storing thread contexts, each thread context for one of a plurality of concurrent threads, each implementing a dataflow graph comprising an identified operation; and a hardware processor configured for configuring the at reconfigurable processing grid for: executing a first thread of the plurality of concurrent threads; and while executing the first thread: storing a runtime context value of the first thread in the context storage; while waiting for completion of the identified operation by identified logical elements, executing the identified operation of a second thread by the identified logical element; and when execution of the identified operation of the first thread completes: retrieving the runtime context value of the first thread from the context storage; and executing another operation of the first thread.


