Massive Graphs Research Articles

Fast Algorithms for the Maximum Clique Problem on Massive Graphs with Applications to Overlapping Community Detection

The maximum clique problem is a well-known NP-hard problem with applications in data mining, network analysis, information retrieval, and many other areas related to the World Wide Web. There exist several algorithms for the problem, with acceptable runtimes for certain classes of graphs, but many of them are infeasible for massive graphs. We present a new exact algorithm that employs novel pruning techniques and is able to find maximum cliques in very large, sparse graphs quickly. Extensive experiments on different kinds of synthetic and real-world graphs show that our new algorithm can be orders of magnitude faster than existing algorithms. We also present a heuristic that runs orders of magnitude faster than the exact algorithm while providing optimal or near-optimal solutions. We illustrate a simple application of the algorithms in developing methods for detection of overlapping communities in networks.

PRS: Parallel Relaxation Simulation for Massive Graphs

Graph pattern matching is becoming important for a variety of emerging applications such as social network analysis. Graph pattern matching is traditionally defined in terms of subgraph isomorphism or graph simulation. These notions, however, often impose too strong constraint to identify meaningful matches. In this paper, we propose a new graph pattern matching based on a notion of relaxation simulation, which extends graph simulation by allowing partially absent vertices. We show that relaxation simulation is able to find significant matches which traditional approaches of graph pattern matching fail to catch. We propose two parallel algorithms to apply relaxation simulation to massive graph since the graph in practice is considerably large. The algorithms are based on Bulk Synchronous Parallel model and can be easily deployed on cloud computing platforms. Finally, we experimentally verify the effectiveness and efficiency of these algorithms, using real-life data and synthesis data. The results suggest that relaxation simulation is a promising framework for real-life massive graph analysis.

Large-scale distributed graph computing systems

With the prevalence of graph data in real-world applications (e.g., social networks, mobile phone networks, web graphs, etc.) and their ever-increasing size, many distributed graph computing systems have been developed in recent years to process and analyze massive graphs. Most of these systems adopt Pregel's vertex-centric computing model, while various techniques have been proposed to address the limitations in the Pregel framework. However, there is a lack of comprehensive comparative analysis to evaluate the performance of various systems and their techniques, making it difficult for users to choose the best system for their applications. We conduct extensive experiments to evaluate the performance of existing systems on graphs with different characteristics and on algorithms with different design logic. We also study the effectiveness of various techniques adopted in existing systems, and the scalability of the systems. The results of our study reveal the strengths and limitations of existing systems, and provide valuable insights for users, researchers and system developers.

Pregel algorithms for graph connectivity problems with performance guarantees

Graphs in real life applications are often huge, such as the Web graph and various social networks. These massive graphs are often stored and processed in distributed sites. In this paper, we study graph algorithms that adopt Google's Pregel, an iterative vertex-centric framework for graph processing in the Cloud. We first identify a set of desirable properties of an efficient Pregel algorithm, such as linear space, communication and computation cost per iteration, and logarithmic number of iterations. We define such an algorithm as a practical Pregel algorithm (PPA). We then propose PPAs for computing connected components (CCs), biconnected components (BCCs) and strongly connected components (SCCs). The PPAs for computing BCCs and SCCs use the PPAs of many fundamental graph problems as building blocks, which are of interest by themselves. Extensive experiments over large real graphs verified the efficiency of our algorithms.

LogGP

With the increasing availability and scale of graph data from Web 2.0, graph partitioning becomes one of efficient preprocessing techniques to balance the computing workload. Since the cost of partitioning the entire graph is strictly prohibitive, there are some recent tentative works towards streaming graph partitioning which can run faster, be easily paralleled, and be incrementally updated. Unfortunately, the experiments show that the running time of each partitioning is still unbalanced due to the variation of workload access pattens during the supersteps. In addition, the one-pass streaming partitioning result is not always satisfactory for the algorithms' local view of the graph. In this paper, we present LogGP, a log-based graph partitioning system that records, analyzes and reuses the historical statistical information to refine the partitioning result. LogGP can be used as a middle-ware and deployed to many state-of-the-art paralleled graph processing systems easily. LogGP utilizes the historical partitioning results to generate a hyper-graph and uses a novel hyper-graph streaming partitioning approach to generate a better initial streaming graph partitioning result. During the execution, the system uses running logs to optimize graph partitioning which prevents performance degradation. Moreover, LogGP can dynamically repartition the massive graphs in accordance with the structural changes. Extensive experiments conducted on a moderate size of computing cluster with real-world graph datasets demonstrate the superiority of our approach against the state-of-the-art solutions.

I/O efficient: computing SCCs in massive graphs

A strongly connected component ($$\mathsf {SCC}$$SCC) is a maximal subgraph of a directed graph $$G$$G in which every pair of nodes is reachable from each other in the $$\mathsf {SCC}$$SCC. With such a property, a general directed graph can be represented by a directed acyclic graph (DAG) by contracting every $$\mathsf {SCC}$$SCC of $$G$$G to a node in DAG. In many real applications that need graph pattern matching, topological sorting, or reachability query processing, the best way to deal with a general directed graph is to deal with its DAG representation. Therefore, finding all $$\mathsf {SCC}$$SCCs in a directed graph $$G$$G is a critical operation. The existing in-memory algorithms based on depth first search (DFS) can find all $$\mathsf {SCC}$$SCCs in linear time with respect to the size of a graph. However, when a graph cannot reside entirely in the main memory, the existing external or semi-external algorithms to find all $$\mathsf {SCC}$$SCCs have limitation to achieve high I/O efficiency. In this paper, we study new I/O-efficient semi-external algorithms to find all $$\mathsf {SCC}$$SCCs for a massive directed graph $$G$$G that cannot reside in main memory entirely. To overcome the deficiency of the existing DFS-based semi-external algorithm that heavily relies on a total order, we explore a weak order based on which we investigate new algorithms. We propose a new two-phase algorithm, namely, tree construction and tree search. In the tree construction phase, a spanning tree of $$G$$G can be constructed in bounded number of sequential scans of $$G$$G. In the tree search phase, it needs to sequentially scan the graph once to find all $$\mathsf {SCC}$$SCCs. In addition, we propose a new single-phase algorithm, which combines the tree construction and tree search phases into a single phase, with three new optimization techniques. They are early acceptance, early rejection, and batch processing. By the single-phase algorithm with the new optimization techniques, we can significantly reduce the number of I/Os and the CPU cost. We prove the correctness of the algorithms. We conduct extensive experimental studies using 4 real datasets including a massive real dataset and several synthetic datasets to confirm the I/O efficiency of our approaches.

Allowing each node to communicate only once in a distributed system: shared whiteboard models

In this paper we study distributed algorithms on massive graphs where links represent a particular relationship between nodes (for instance, nodes may represent phone numbers and links may indicate telephone calls). Since such graphs are massive they need to be processed in a distributed way. When computing graph-theoretic properties, nodes become natural units for distributed computation. Links do not necessarily represent communication channels between the computing units and therefore do not restrict the communication flow. Our goal is to model and analyze the computational power of such distributed systems where one computing unit is assigned to each node. Communication takes place on a whiteboard where each node is allowed to write at most one message. Every node can read the contents of the whiteboard and, when activated, can write one small message based on its local knowledge. When the protocol terminates its output is computed from the final contents of the whiteboard. We describe four synchronization models for accessing the whiteboard. We show that message size and synchronization power constitute two orthogonal hierarchies for these systems. We exhibit problems that separate these models, i.e., that can be solved in one model but not in a weaker one, even with increased message size. These problems are related to maximal independent set and connectivity. We also exhibit problems that require a given message size independently of the synchronization model.

Graph stream algorithms

Over the last decade, there has been considerable interest in designing algorithms for processing massive graphs in the data stream model. The original motivation was two-fold: a) in many applications, the dynamic graphs that arise are too large to be stored in the main memory of a single machine and b) considering graph problems yields new insights into the complexity of stream computation. However, the techniques developed in this area are now finding applications in other areas including data structures for dynamic graphs, approximation algorithms, and distributed and parallel computation. We survey the state-of-the-art results; identify general techniques; and highlight some simple algorithms that illustrate basic ideas.

Studying the Impact of 32-Bits AS Numbers on Constructing Internet AS Graphs

Modeling Internet structure as an autonomous system (AS) graph is considered one of the most common methods to study the Internet. AS-graph is constructed by utilizing ASes from the Internet. The AS number was 16-bit address. It reduced the size of ASes scope in one hand and made the AS graph small and easy to be produced and modeled. However, the number of ASes has exceeded the 16-bits limits. The 32-bit addressing has emerged as a method to tackle this problem. This increasing in the AS number scope converted the AS graph into a massive graph with unpredicted number of ASes. In this paper, we attempt to study the impact of 32-bits addresses on the AS graph. Graph parameters have been utilized to measure this impact. To this end, we have constructed two AS-graphs, a 16-bits-AS graph and a full AS graph. We have compared these graphs according to cluster coefficient, betweenness centrality, node degree and average shortest path. Our results demonstrated that the 32-bits ASes are popular. Moreover, these ASes have an effect on reducing the value of the global cluster coefficient and increasing the average shortest path. We observed that the number of vertexes that connect 16-bits and 32-bits ASes is small and requires more inferring.

Special Section on Two Themes: Planet Earth and Big Data

The 2013 SIAM Conference on Computational Science and Engineering (CS&E) was held February 25--March 1, 2013, in Boston, Massachusetts. The SIAM Journal on Scientific Computing (SISC) created this special section in association with the CSE13 conference. Of course, the topic of CS&E is quite broad, so this special section focuses on two important themes: Planet Earth and Big Data. These topics are in the forefront of many contemporary discussions. Recently, “Mathematics, Statistics, and the Data Deluge” and “Mathematics of Sustainability” were the themes of the Math Awareness Months, in 2012 and 2013, respectively. These special months are sponsored by the Joint Policy Board for Mathematics (JPBM), which includes SIAM. Additionally, more than 100 technical organizations and institutes banded together with UNESCO to declare 2013 a special year of emphasis on the Mathematics of Planet Earth (MPE13). Of course, SISC traditionally publishes papers on these themes, and the papers in this special section are no different except that they represent a concetration in these topics. The eleven papers in this special section are a nearly even split between the two topics, with six on Planet Earth, four on Big Data, and one that intersects both themes. There are many natural intersections of the interests of SISC and Big Data. Randomized algorithms are an important approach for scaling down large-scale problems with redundant data. We include two papers on this topic. One paper provides a new way to do canonical correlation analysis for tall and skinny matrices by using a randomized algorithm to reduce the problem. The other paper considers the problem of quantile regression based on a weighted sampling method. Appealingly, both methods come with robust error bounds. MapReduce represents a new distributed computing paradigm that is data-centric, and we also have two papers on this topic. One considers a network science problem: approximate triangle counting in massive graphs. The other builds a reduced-order model from a tall and skinny matrix comprising many terabytes of data. Finally, we have a paper that has intersected both themes, using a novel approach for large-scale matrix completion with applications to exploration seismology. SISC is often an ideal venue for papers on computational aspects of geophysical phenomena, so Planet Earth is a natural theme. Six such papers appear in this special section. Three papers focus on the inverse problem of estimating unknown medium parameters. One paper tackles large-scale 3D seismic waveform inversion, introducing novel heuristics for balancing between computational cost and accuracy during the solution process. A second paper develops, analyzes, and assesses highly efficient stochastic and deterministic dimensionality reduction The third paper introduces a novel approach for imaging subsurface fluid flow by estimating the flow field and initial state directly from a time series of geophysical flow data, coupling the flow and imaging equations. We have two papers focusing on large-scale planetary flows. One develops and implements derivative-based methods of uncertainty quantification for global ocean state estimation, employing the MIT ocean general circulation model. The second paper develops a fully implicit nonhydrostatic solver for mesoscale atmospheric flows. The numerical solver employs a Jacobian-free Newton--Krylov--Schwarz algorithm, and it is implemented and run in parallel, demonstrating nearly linear scaling for thousands of processor cores. Our sixth Planet Earth paper develops a finite element solver for quasi-Newtonian flows. The paper features an analysis of the continuous saddle-point problem, and the numerical solver is demonstrated on realistic gravity flows, a viscoelastic steady wave, and glacier flow. The guest editorial board worked very hard to ensure a rigorous peer-review process while meeting deadlines. Special thanks are due to Mitch Chernoff (SIAM Publications Manager) and Brittni Holland (SIAM Editorial Associate) for their efforts on this special section.

Counting Triangles in Massive Graphs with MapReduce

Graphs and networks are used to model interactions in a variety of contexts. There is a growing need to quickly assess the characteristics of a graph in order to understand its underlying structure. Some of the most useful metrics are triangle-based and give a measure of the connectedness of mutual friends. This is often summarized in terms of clustering coefficients, which measure the likelihood that two neighbors of a node are themselves connected. Computing these measures exactly for large-scale networks is prohibitively expensive in both memory and time. However, a recent wedge sampling algorithm has proved successful in efficiently and accurately estimating clustering coefficients. In this paper, we describe how to implement this approach in MapReduce to deal with massive graphs. We show results on publicly-available networks, the largest of which is 132M nodes and 4.7B edges, as well as artificially generated networks (using the Graph500 benchmark), the largest of which has 240M nodes and 8.5B edges. We can estimate the clustering coefficient by degree bin (e.g., we use exponential binning) and the number of triangles per bin, as well as the global clustering coefficient and total number of triangles, in an average of 0.33 seconds per million edges plus overhead (approximately 225 seconds total for our configuration). The technique can also be used to study triangle statistics such as the ratio of the highest and lowest degree, and we highlight differences between social and non-social networks. To the best of our knowledge, these are the largest triangle-based graph computations published to date.

GraphCT: Multithreaded Algorithms for Massive Graph Analysis

The digital world has given rise to massive quantities of data that include rich semantic and complex networks. A social graph, for example, containing hundreds of millions of actors and tens of billions of relationships is not uncommon. Analyzing these large data sets, even to answer simple analytic queries, often pushes the limits of algorithms and machine architectures. We present GraphCT, a scalable framework for graph analysis using parallel and multithreaded algorithms on shared memory platforms. Utilizing the unique characteristics of the Cray XMT, GraphCT enables fast network analysis at unprecedented scales on a variety of input data sets. On a synthetic power law graph with 2 billion vertices and 17 billion edges, we can find the connected components in 2 minutes. We can estimate the betweenness centrality of a similar graph with 537 million vertices and over 8 billion edges in under 1 hour. GraphCT is built for portability and performance.

Counting and sampling triangles from a graph stream

This paper presents a new space-efficient algorithm for counting and sampling triangles--and more generally, constant-sized cliques--in a massive graph whose edges arrive as a stream. Compared to prior work, our algorithm yields significant improvements in the space and time complexity for these fundamental problems. Our algorithm is simple to implement and has very good practical performance on large graphs.

An in-depth analysis of stochastic Kronecker graphs

Graph analysis is playing an increasingly important role in science and industry. Due to numerous limitations in sharing real-world graphs, models for generating massive graphs are critical for developing better algorithms. In this article, we analyze the stochastic Kronecker graph model (SKG), which is the foundation of the Graph500 supercomputer benchmark due to its favorable properties and easy parallelization. Our goal is to provide a deeper understanding of the parameters and properties of this model so that its functionality as a benchmark is increased. We develop a rigorous mathematical analysis that shows this model cannot generate a power-law distribution or even a lognormal distribution. However, we formalize an enhanced version of the SKG model that uses random noise for smoothing. We prove both in theory and in practice that this enhancement leads to a lognormal distribution. Additionally, we provide a precise analysis of isolated vertices, showing that the graphs that are produced by SKG might be quite different than intended. For example, between 50% and 75% of the vertices in the Graph500 benchmarks will be isolated. Finally, we show that this model tends to produce extremely small core numbers (compared to most social networks and other real graphs) for common parameter choices.

A Local Clustering Algorithm for Massive Graphs and Its Application to Nearly Linear Time Graph Partitioning

We study the design of local algorithms for massive graphs. A local graph algorithm is one that finds a solution containing or near a given vertex without looking at the whole graph. We present a local clustering algorithm. Our algorithm finds a good cluster---a subset of vertices whose internal connections are significantly richer than its external connections---near a given vertex. The running time of our algorithm, when it finds a nonempty local cluster, is nearly linear in the size of the cluster it outputs. The running time of our algorithm also depends polylogarithmically on the size of the graph and polynomially on the conductance of the cluster it produces. Our clustering algorithm could be a useful primitive for handling massive graphs, such as social networks and web-graphs. As an application of this clustering algorithm, we present a partitioning algorithm that finds an approximate sparsest cut with nearly optimal balance. Our algorithm takes time nearly linear in the number edges of the graph. Using the partitioning algorithm of this paper, we have designed a nearly linear time algorithm for constructing spectral sparsifiers of graphs, which we in turn use in a nearly linear time algorithm for solving linear systems in symmetric, diagonally dominant matrices. The linear system solver also leads to a nearly linear time algorithm for approximating the second-smallest eigenvalue and corresponding eigenvector of the Laplacian matrix of a graph. These other results are presented in two companion papers.

An auction-based weighted matching implementation on massively parallel architectures

Maximum weighted matchings represent a fundamental kernel in massive graph analysis and occur in a wide range of real-life applications. Here, a parallel auction-based matching algorithm is developed, which is able to tackle matchings in very large, dense, and sparse bipartite graphs. It will be demonstrated that the convergence of the auction algorithm crucially depends on two different @e-scaling strategies. The auction algorithm including the @e-scaling strategies has been implemented using a hybrid MPI-OpenMP programming model, and its performance is validated in various applications from bioinformatics, computer vision, and sparse linear algebra. It is concluded that for dense bipartite graphs, the auction algorithm scales well, and for sparse bipartite graphs at least a substantial speedup is achieved against alternative approaches that are based on augmenting path algorithms.

I/O-efficient approximation of graph diameters by parallel cluster growing — a first experimental study

A fundamental step in the analysis of a massive graph is to compute its diameter. In the RAM model, the diameter of a connected undirected unweighted graph can be efficiently 2-approximated using a Breadth-First Search (BFS) traversal from an arbitrary node. However, if the graph is stored on disk, even an external memory BFS traversal is prohibitive, owing to the large number of I/Os it incurs. Meyer [1] proposed a parametrized algorithm to compute an approximation of graph diameter with fewer I/Os than that required for exact BFS traversal of the graph. The approach is based on growing clusters around randomly chosen vertices ‘in parallel’ until their fringes meet. We present an implementation of this algorithm and compare it with some simple heuristics and external-memory BFS in order to determine the trade-off between the approximation ratio and running-time achievable in practice. Our experiments show that with carefully chosen parameters, the new approach is indeed capable to produce surprisingly good diameter approximations in shorter time. We also confirm experimentally, that there are graph-classes where the parametrized approach runs into bad approximation ratios just as the theoretical analysis in [1] suggests.

Graph synopses, sketches, and streams

Massive graphs arise in any application where there is data about both basic entities and the relationships between these entities, e.g., web-pages and hyperlinks; neurons and synapses; papers and citations; IP addresses and network flows; people and their friendships. Graphs have also become the de facto standard for representing many types of highly structured data. However, the sheer size of many of these graphs renders classical algorithms inapplicable when it comes to analyzing such graphs. In addition, these existing algorithms are typically ill-suited to processing distributed or stream data. Various platforms have been developed for processing large data sets. At the same time, there is the need to develop new algorithmic ideas and paradigms. In the case of graph processing, a lot of recent work has focused on understanding the important algorithmic issues. An central aspect of this is the question of how to construct and leverage small-space synopses in graph processing. The goal of this tutorial is to survey recent work on this question and highlight interesting directions for future research.

HADI

Given large, multimillion-node graphs (e.g., Facebook, Web-crawls, etc.), how do they evolve over time? How are they connected? What are the central nodes and the outliers? In this article we define the Radius plot of a graph and show how it can answer these questions. However, computing the Radius plot is prohibitively expensive for graphs reaching the planetary scale. There are two major contributions in this article: (a) We propose HADI (HAdoop DIameter and radii estimator), a carefully designed and fine-tuned algorithm to compute the radii and the diameter of massive graphs, that runs on the top of the Hadoop / MapReduce system, with excellent scale-up on the number of available machines (b) We run HADI on several real world datasets including YahooWeb (6B edges, 1/8 of a Terabyte), one of the largest public graphs ever analyzed. Thanks to HADI, we report fascinating patterns on large networks, like the surprisingly small effective diameter, the multimodal/bimodal shape of the Radius plot, and its palindrome motion over time.

Efficient algorithms for large-scale local triangle counting

In this article, we study the problem of approximate local triangle counting in large graphs. Namely, given a large graph G =( V,E ) we want to estimate as accurately as possible the number of triangles incident to every node v ∈ V in the graph. We consider the question both for undirected and directed graphs. The problem of computing the global number of triangles in a graph has been considered before, but to our knowledge this is the first contribution that addresses the problem of approximate local triangle counting with a focus on the efficiency issues arising in massive graphs and that also considers the directed case. The distribution of the local number of triangles and the related local clustering coefficient can be used in many interesting applications. For example, we show that the measures we compute can help detect the presence of spamming activity in large-scale Web graphs, as well as to provide useful features for content quality assessment in social networks. For computing the local number of triangles (undirected and directed), we propose two approximation algorithms, which are based on the idea of min-wise independent permutations [Broder et al. 1998]. Our algorithms operate in a semi-streaming fashion, using O (| V |) space in main memory and performing O (log | V |) sequential scans over the edges of the graph. The first algorithm we describe in this article also uses O (| E |) space of external memory during computation, while the second algorithm uses only main memory. We present the theoretical analysis as well as experimental results on large graphs, demonstrating the practical efficiency of our approach.