Graph Multi-threading Group Detection
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional graph analysis solutions face challenges in processing large graphs due to high computational time and memory requirements, often leading to failure when analyzing graphs with a large number of nodes and edges, as they rely on single-process approaches that are inefficient and prone to memory overflow.
Innovation Solution
Implementing a multi-threading technique where multiple software threads collaborate to detect groups within a graph, with each thread responsible for a node and performing independent computations, reducing unnecessary data transmission and comparison operations by using neighbor counts and hashed values to enhance processing efficiency.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Device complexity
If a single-process approach is used to analyze graphs, then the system is simple to implement, but the processing time and memory requirements become excessively high for large graphs
Solution Approach 1:
The patent divides the graph analysis task into multiple independent threads, each responsible for analyzing specific portions of the graph. This segmentation allows parallel processing, significantly reducing the time required to analyze large graphs while distributing the computational burden across multiple threads rather than using a single complex process
2Quantity of substance
If a single-process approach is used to analyze graphs, then the system has low memory consumption, but it fails to complete analysis due to memory overflow when graphs are large
Solution Approach 1:
The patent segments the graph analysis into multiple threads that process different portions of the graph independently. This segmentation distributes memory requirements across multiple threads, allowing the system to handle larger graphs without memory overflow while maintaining reliable task completion
Solution Approach 2:
The patent transitions from a single-process sequential approach to a multi-threaded parallel approach, adding the dimension of concurrency. This dimensional change allows the system to process larger graphs by distributing both computational and memory requirements across multiple threads, preventing memory overflow while completing the analysis
3Productivity
If multi-threading is implemented to improve processing speed, then analysis time is reduced, but data transmission and comparison operations between threads increase complexity
Solution Approach 1:
The patent extracts and transmits only the necessary information (neighbor counts and hashed values) between threads rather than transferring entire data structures. This extraction approach reduces the amount of data that needs to be transmitted and compared between threads, minimizing the added complexity of multi-threaded data exchange while maintaining processing efficiency
Solution Approach 2:
The patent uses hashed values as copies or representations of the actual data structures. Instead of transmitting and comparing complete neighbor lists between threads, the system transmits and compares hashed values that represent the data, significantly reducing the complexity of data exchange operations while maintaining the ability to identify and merge groups
Data Source
AI summary
Methods and systems are presented for detecting groups within a graph using computer-based multi-threading techniques. These techniques provide technical improvements in computing power and efficiency for analysis of large graphs. A group detection system accesses a graph. Threads are instantiated to perform task related to a group detection process based on the nodes in the graph, where a thread is instantiated for a corresponding node. Each thread determines a neighbor count representing a number of neighbor nodes having one degree of separation from the corresponding node. Each thread also generates a list comprising an identity of the corresponding node and identities of the neighbor nodes. The thread transmits the list only to threads corresponding to a first subset of the neighbor nodes having more neighbors than the corresponding node, but not to threads corresponding to a second subset of the neighbor nodes having less neighbors than the corresponding nodes.