A Scalable Parallel Approach for Subgraph Census Computation

Abstract

Counting the occurrences of small subgraphs in large networks is a fundamental graph mining metric with several possible applications. Computing frequencies of those subgraphs is also known as the subgraph census problem, which is a computationally hard task. In this paper we provide a parallel multicore algorithm for this purpose. At its core we use FaSE, an efficient network-centric sequential subgraph census algorithm, which is able to substantially decrease the number of isomorphism tests needed when compared to past approaches. We use one thread per core and employ a dynamic load balancing scheme capable of dealing with the highly unbalanced search tree induced by FaSE and effectively redistributing work during execution. We assessed the scalability of our algorithm on a varied set of representative networks and achieved near linear speedup up to 32 cores while obtaining a high efficiency for the total 64 cores of our machine.

A Survey on Subgraph Counting: Concepts, Algorithms and Applications to Network Motifs and Graphlets

“…DM-Gtries improves upon DM-ESU by using a faster enumeration algorithm (GTries) and having all workers perform subgraph enumeration (without wasting a node in work queue management). Similar implementations (based on W-W sharing and diagonal splitting) of GTries and FASE were also developed for shared memory (SM) environments, which achieved near-linear speedups in a 64-core machine [10,12]. The main advantages of SM implementations is that work sharing is faster (since no message passing is necessary) and SM architectures (such as multicores) are a commodity while DM architectures (such as a cluster) are not.…”

“…However, the number of cores is usually very low when compared to DM, MapReduce, and GPU architectures. Algorithms on multicores tend to traverse the search space in a DFS fashion [3,10,12,172] thus avoiding the storage of large number of subgraph occurrences in disk or main memory.…”

“…For instance, counting all the subgraph occurrences that start (or eventually reach) a hub-like node is much more time-consuming than counting occurrences of a nearly isolated node. For algorithms with vertices as work-units to be efficient they can either try to find a good initial division [190] or enable work sharing between workers [10,12,152,153]. Each of these work division strategies is discussed in Section 5.5.…”

“…This approach is applicable only for DFS-like algorithms where, since the search tree is explored in a depth-first fashion, a work-tree is implicitly built during enumeration: when the algorithm is at level k of the search, unexplored candidates of stages {k − 1, k − 2, ..., 1} were previously generated. Then, instead of splitting top vertices from stage 1 only (as described in Section 5.3.1), the search-tree is split among sharing processors [10,12,151,152] (more details on this in Section 5.5.3). Subgraph-trees are expected to be similar since both coarse-and fine-grained work-units are generated.…”

Extending the Applicability of Graphlets to Directed Networks

“…Even a very efficient tool such as GT-Scanner takes a considerable amount of time to compute uG 6 for the metabolic networks, for instance. To deal with this problem we have developed previous work on parallel strategies for subgraph census, applied to both computer clusters [53], [54] and single multicore machines [55], [56]. Past strategies relied on a static division of the work that could not guarantee a balanced division due to highly unbalanced topology of the networks.…”