Graph Streaming Processor Thread Dispatch via Scorecards
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Dependency resolution between threads in graph stream processing creates performance bottlenecks, as resolving dependencies before thread execution serializes the processing and reduces performance.
Innovation Solution
A graph streaming processor with a thread manager that dispatches operations of threads before dependencies are resolved, maintains a scorecard for thread operations, and provides status updates, allowing threads to proceed once dependencies are satisfied, enabling flexible and dynamic dependency management.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If dependencies between threads are resolved before launching threads, then execution order is controlled and correctness is ensured, but the execution of threads is serialized and performance is reduced
Solution Approach 1:
The patent applies preliminary action by pre-calculating and storing dependency information in scorecards before thread execution begins. The thread manager uses these pre-computed scorecards to quickly determine whether threads can execute without waiting for runtime dependency resolution, thus maintaining correctness while enabling parallel execution.
Solution Approach 2:
The patent introduces scorecards as an intermediary data structure that mediates between the static dependency graph and dynamic thread execution. Scorecards store pre-computed dependency satisfaction information and act as a lookup table that allows the thread manager to quickly determine thread readiness without serializing execution or performing complex runtime dependency analysis.
2Productivity
If threads are dispatched before dependencies are resolved, then execution time is reduced and performance is enhanced, but complex dependency tracking is required
Solution Approach 1:
The patent segments the dependency management problem into two distinct parts: (1) static dependency analysis performed at compile-time to build scorecards, and (2) dynamic thread dispatch using pre-computed scorecard data. This segmentation allows complex dependency tracking to be handled offline, leaving only simple lookup operations for runtime thread management.
Solution Approach 2:
The patent performs preliminary dependency analysis and scorecard generation before thread execution begins. By pre-computing which dependencies are satisfied and storing this information in scorecards, the system eliminates the need for complex runtime dependency tracking, allowing threads to be dispatched quickly based on simple scorecard lookups.
3Ease of manufacture
If serial dependency resolution is used, then implementation is simpler, but execution time increases and performance decreases
Solution Approach 1:
The patent performs the complex dependency resolution work in advance during scorecard generation, before thread execution begins. This preliminary action shifts the computational burden from runtime to compile-time, allowing simple and fast thread dispatch operations during execution while maintaining implementation simplicity through the use of pre-computed lookup tables.
Solution Approach 2:
The patent creates scorecards that are copies or representations of the static dependency graph, pre-computed and stored in a format optimized for runtime lookup. Instead of performing complex dependency analysis during thread execution, the system uses these pre-generated scorecard copies to quickly determine thread readiness, thus reducing execution time while keeping implementation simple.
Data Source
AI summary
Methods, systems and apparatuses for graph processing are disclosed. One graph streaming processor includes a thread manager, wherein the thread manager is operative to dispatch operation of the plurality of threads of a plurality of thread processors before dependencies of the dependent threads have been resolved, maintain a scorecard of operation of the plurality of threads of the plurality of thread processors, and provide an indication to at least one of the plurality of thread processors when a dependency between the at least one of the plurality of threads that a request has or has not been satisfied. Further, a producer thread provides a response to the dependency when the dependency has been satisfied, and each of the plurality of thread processors is operative to provide processing updates to the thread manager, and provide queries to the thread manager upon reaching a dependency.