Parallel Weakly Connected Components With Deterministic Collision Merging
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Computing weakly connected components (WCCs) in large graphs with millions of vertices is computationally intensive and difficult to scale, particularly in applications like electronic design automation, where fast processing is required.
Innovation Solution
A parallel and scalable method for computing WCCs involves assigning undefined values to vertices, performing depth-first visits, detecting thread collisions, generating collision graphs, and iteratively merging WCCIDs to determine WCCs in a deterministic manner.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If a parallel algorithm is used to compute WCCs, then processing speed is improved, but thread collisions occur causing deterministic behavior to be lost
Solution Approach 1:
The patent introduces a mediator mechanism that tracks visited vertices and coordinates between threads. This mediator prevents thread collisions by ensuring each vertex is processed by exactly one thread, thereby maintaining deterministic behavior while enabling parallel processing. The mediator acts as an intermediary that resolves potential conflicts between parallel threads before they can cause non-deterministic outcomes.
Solution Approach 2:
The patent implements feedback mechanisms where threads continuously check the state of vertices and adjust their processing accordingly. Through feedback loops that monitor vertex visitation status, the system ensures that parallel threads coordinate their actions to maintain deterministic outcomes. The feedback allows the system to detect and prevent thread collisions in real-time during parallel execution.
2Reliability
If the graph is processed in a single-threaded manner, then deterministic behavior is maintained, but processing time increases significantly
Solution Approach 1:
The patent segments the graph processing task into independent sub-tasks that can be executed in parallel. By dividing the vertex processing into separate segments that can be handled by different threads simultaneously, the system achieves both speedup and determinism. Each segment is processed independently with proper coordination to ensure overall deterministic behavior.
Solution Approach 2:
The patent introduces dynamic coordination mechanisms that adapt during parallel execution. The system dynamically adjusts thread behavior based on real-time state information, allowing flexible parallel processing while maintaining deterministic outcomes. The dynamic nature of the coordination allows the system to optimize performance while preserving correctness.
3Productivity
If more processing threads are added to speed up computation, then productivity improves, but the complexity of managing thread collisions increases
Solution Approach 1:
The patent implements self-service mechanisms where each thread autonomously manages its own processing while automatically coordinating with other threads through shared state checks. Threads independently determine their next actions based on current system state, reducing the need for complex centralized coordination. This self-service approach scales efficiently with the number of threads while maintaining manageable complexity.
Solution Approach 2:
The patent changes key parameters of the processing system to enable efficient parallel coordination. By modifying how threads interact with the graph data structure and how they report their progress, the system reduces coordination overhead. Parameter changes in the data structure organization and thread communication protocols enable scalable parallel processing without proportionally increasing complexity.
Data Source
AI summary
Disclosed is a configuration to compute weakly connected components (WCCs) in a parallel, scalable and deterministic manner. The configuration receives an undirected original graph having vertices and edges. An undefined value is assigned to all the vertices of the graph. Thereafter, each vertex is visited and assigned a WCCID (index to identify a WCC). The visitation of vertices may determine whether there are one or more thread collisions. A collision is when two threads attempt to identify the same WCC. From these collisions a new graph may be generated, a collision graph, on which the same algorithm is iterated to compute WCCs of that collision graph. The process is iterated until no further collisions are determined. In a post process, the configuration merges the WCCIDs of the collision graphs to produce the WCCIDs of the original graph.