Dependency Graph Scheduling for Concurrent Analytics Threads
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional analytics computation in systems like supply chains requires extensive run-time due to threads independently computing dependent values, leading to inefficient use of processing units and waiting times.
Innovation Solution
Computing a full dependency graph before obtaining results and constructing a scheduling graph to optimally distribute work between available threads, using caching, heuristics, and instrumentation to mitigate performance impacts.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If threads independently compute dependent analytic values, then each thread can work autonomously, but processing time increases significantly due to redundant calculations and waiting
Solution Approach 1:
The patent merges independent thread computations by implementing a dependency graph that identifies shared analytic dependencies across threads. When multiple threads need the same dependent value (e.g., CumLeadTime of Part B), the system combines their requests into a single computation, allowing threads to share results rather than each thread independently calculating the same value, thus eliminating redundant processing and reducing overall execution time
Solution Approach 2:
The system performs preliminary computation of dependency relationships before executing the main analytic tasks. By pre-computing which analytic values are dependencies of which other values, the system can proactively identify and compute shared dependencies before threads need them, reducing waiting time and enabling more efficient parallel execution
2Reliability
If threads wait for dependent values to be computed, then correctness is maintained, but resource utilization decreases due to idle processing units
Solution Approach 1:
The patent implements dynamic thread scheduling based on real-time dependency resolution. Threads are dynamically assigned tasks from a work queue that reflects current computation status and dependency satisfaction. When dependencies are resolved, thread assignments are dynamically updated, allowing processing units to transition from idle to active states efficiently, thus maintaining correctness while maximizing resource utilization
Solution Approach 2:
The system implements feedback mechanisms where completed analytic computations automatically notify dependent threads that are waiting for those values. This feedback loop allows threads to be activated immediately when their dependencies are satisfied, ensuring correctness is maintained while minimizing idle time and maximizing resource utilization across the processing system
3Productivity
If a full dependency graph is computed before analytics, then work distribution is optimized, but initial computation overhead increases
Solution Approach 1:
The system performs preliminary computation of the dependency graph structure before executing analytic tasks, but uses caching to store this dependency information for reuse across multiple analytics operations. The dependency graph computation is done once upfront, and subsequent analytics operations can leverage this pre-computed structure, amortizing the initial computation cost over multiple uses and reducing per-operation overhead
Solution Approach 2:
The patent implements caching of dependency graph structures and computation results. Once a dependency graph is computed, it is copied and stored for reuse when similar analytic queries are made. This allows the system to avoid re-computing the same dependency relationships, reducing initial computation overhead while maintaining optimal work distribution for subsequent operations
Data Source
AI summary
A system, method and non-transitory computer-readable storage medium for computing a full dependency graph before obtaining a result of an analytic; and constructing a scheduling graph to optimally distribute work between the available threads, based on the full dependency graph. This may include receiving a request for a result of an algorithm executed on a node; checking, by the processor, the algorithm for a secondary dependency algorithm and executing, by the processor, the algorithm on the node.