The Experts below are selected from a list of 1341 Experts worldwide ranked by ideXlab platform
David A. Bader - One of the best experts on this subject based on the ideXlab platform.
-
faster clustering coefficient using vertex covers
International Conference on Social Computing, 2013Co-Authors: Oded Green, David A. BaderAbstract:Clustering coefficients, also called triangle counting, is a widely-used graph analytic for measuring the closeness in which vertices cluster together. Intuitively, clustering coefficients can be thought of as the ratio of common friends versus all possible connections a person might have in a social network. The best known time complexity for computing clustering coefficients uses Adjacency List intersection and is O(V · dmax2), where dmax is the size of the largest Adjacency List of all the vertices in the graph. In this work, we show a novel approach for computing the clustering coefficients in an undirected and unweighted graphs by exploiting the use of a vertex cover, V ⊆ V. This new approach reduces the number of times that a triangle is counted by as many as 3 times per triangle. The complexity of the new algorithm is O(V · hmax2 + tVC) where dmax is the size of the largest Adjacency List in the vertex cover and tVC is the time needed for finding the vertex cover. Even for a simple vertex cover algorithm this can reduce the execution time 10-30% while counting the exact number of triangles (3-circuits). We extend the use of the vertex cover to support counting squares (4-circuits) and clustering coefficients for dynamic graphs.
-
SocialCom - Faster Clustering Coefficient Using Vertex Covers
2013 International Conference on Social Computing, 2013Co-Authors: Oded Green, David A. BaderAbstract:Clustering coefficients, also called triangle counting, is a widely-used graph analytic for measuring the closeness in which vertices cluster together. Intuitively, clustering coefficients can be thought of as the ratio of common friends versus all possible connections a person might have in a social network. The best known time complexity for computing clustering coefficients uses Adjacency List intersection and is O(V · dmax2), where dmax is the size of the largest Adjacency List of all the vertices in the graph. In this work, we show a novel approach for computing the clustering coefficients in an undirected and unweighted graphs by exploiting the use of a vertex cover, V ⊆ V. This new approach reduces the number of times that a triangle is counted by as many as 3 times per triangle. The complexity of the new algorithm is O(V · hmax2 + tVC) where dmax is the size of the largest Adjacency List in the vertex cover and tVC is the time needed for finding the vertex cover. Even for a simple vertex cover algorithm this can reduce the execution time 10-30% while counting the exact number of triangles (3-circuits). We extend the use of the vertex cover to support counting squares (4-circuits) and clustering coefficients for dynamic graphs.
-
ICPP - The Euler tour technique and parallel rooted spanning tree
2004Co-Authors: Guojin Cong, David A. BaderAbstract:Many parallel algorithms for graph problems start with finding a spanning tree and rooting the tree to define some structural relationship on the vertices which can be used by following problem specific computations. The generic procedure is to find an unrooted spanning tree and then root the spanning tree using the Euler tour technique. With a randomized work-time optimal unrooted spanning tree algorithm and work-time optimal List ranking, finding rooted spanning trees can be done work-time optimally on EREW PRAM w.h.p. Yet the Euler tour technique assumes as "given" a circular Adjacency List, it is not without implications though to construct the circular Adjacency List for the spanning tree found on the fly by a spanning tree algorithm. In fact our experiments show that this "hidden" step of constructing a circular Adjacency List could take as much time as both spanning tree and List ranking combined. We present new efficient algorithms that find rooted spanning trees without using the Euler tour technique and incur little or no overhead over the underlying spanning tree algorithms. We also present two new approaches that construct Euler tours efficiently when the circular Adjacency List is not given. One is a deterministic PRAM algorithm and the other is a randomized algorithm in the symmetric multiprocessor (SMP) model. The randomized algorithm takes a novel approach for the problems of constructing the Euler tour and rooting a tree. It computes a rooted spanning tree first, then constructs an Euler tour directly for the tree using depth-first traversal. The tour constructed is cache-friendly with adjacent edges in the tour stored in consecutive locations of an array so that prefix-sum (scan) can be used for tree computations instead of the more expensive List-ranking.
-
The Euler tour technique and parallel rooted spanning tree
2004Co-Authors: Guojing Cong, David A. BaderAbstract:Many parallel algorithms for graph problems start with finding a spanning tree and rooting the tree to define some structural relationship on the vertices which can be used by following problem specific computations. The generic procedure is to find an unrooted spanning tree and then root the spanning tree using the Euler tour technique. With a randomized work-time optimal unrooted spanning tree algorithm and work-time optimal List ranking, finding rooted spanning trees can be done work-time optimally on EREW PRAM w.h.p. Yet the Euler tour technique assumes as “given ” a circular Adjacency List, it is not without implications though to construct the circular Adjacency List for the spanning tree found on the fly by a spanning tree algorithm. In fact our experiments show that this “hidden ” step of constructing a circular Adjacency List could take as much time as both spanning tree and List ranking combined. In this paper we present new efficient algorithms that find rooted spanning trees without using the Euler tour technique and incur little or no overhead over the underlying spanning tree algorithms. We also present two new approaches that construct Euler tours efficiently when the circular Adjacency List is not given. One is a deterministic PRAM algorithm and the other is a randomized algorithm in the SMP model.The randomized algorithm takes a novel approach to the problems of constructing Eule
-
The Euler tour technique and parallel rooted spanning tree
2004Co-Authors: Guojing Cong, David A. BaderAbstract:Many parallel algorithms for graph problems start with finding a spanning tree and rooting the tree to define some structural relationship on the vertices which can be used by following problem specific computations. The generic procedure is to find an unrooted spanning tree and then root the spanning tree using the Euler tour technique. With a randomized work-time optimal unrooted spanning tree algorithm and work-time optimal List ranking, finding rooted spanning trees can be done work-time optimally on EREW PRAM w.h.p. Yet the Euler tour technique assumes as “given ” a circular Adjacency List, it is not without implications though to construct the circular Adjacency List for the spanning tree found on the fly by a spanning tree algorithm. In fact our experiments show that this “hidden ” step of constructing a circular Adjacency List could take as much time as both spanning tree and List ranking combined. In this paper we present new efficient algorithms that find rooted spanning trees without using the Euler tour technique and incur little or no overhead over the underlying spanning tree algorithms. We also present two new approaches that construct Euler tours efficiently when the circular Adjacency List is not given. One is a deterministic PRAM algorithm and the other is a randomized algorithm in the symmetric multiprocessor (SMP) model. The randomized algorithm takes a novel approach for the problems of constructing the Euler tour and rooting a tree. It computes a rooted spanning tree first, then constructs an Euler tour directly for the tree using depth-first traversal. The tour constructed is cache-friendly with adjacent edges in th
Joe Celko - One of the best experts on this subject based on the ideXlab platform.
-
Chapter 28 – Trees and Hierarchies in SQL
Joe Celko's SQL for Smarties, 2015Co-Authors: Joe CelkoAbstract:A tree is a special kind of directed graph. Graphs are data structures that are made up of nodes connected by edges. There are several ways to define a tree: it is a graph with no cycles and it is a graph where all nodes except the root have indegree one and the root has indegree zero. Another defining property is that a path can be found from the root to any other node in the tree by following the edges in their natural direction. Most Structured Query Language (SQL) databases use the Adjacency List model for two reasons. The first reason is that Dr. Codd came up with it in the early days of the relational model, and nobody thought about it after that. The second reason is that the Adjacency List is a way of “faking” pointer chains—the traditional programming method in procedural languages for handling trees. Because SQL is a set-oriented language, the nested set model is a better model for the approach discussed in this chapter.
-
Adjacency List Model
Joe Celko's Trees and Hierarchies in SQL for Smarties, 2012Co-Authors: Joe CelkoAbstract:The chapter discusses adjacent List models used in databases. The chapter describes a method for showing hierarchies in SQL that consists of a column for the boss and another column for the employee in a relationship. It is a direct implementation in a table of the Adjacency List model of a graph. Oracle is the first commercial database to use SQL, and the sample database that comes with their product, nicknamed the “Scott/Tiger” database in the trade because of its default user and password codes, uses an Adjacency List model in a combination Personnel/Organizational chart table. The organizational structure and the personnel data are mixed together in the same row. This model is popular as it is the most natural way to convert from an IMS database or from a procedural language to SQL. The simple Adjacency List model is not a normalized schema. A normalized schema has no data redundancy and is safe from data anomalies. The chapter proposes three characteristics required in a data model. First, that the typical Adjacency List model table includes information about the node, as well as who the boss in each row is. The second characteristic is that each fact appears in one place in the schema, but the subtree of each node can be in more than one row. The third characteristic is that each fact appears one time in the schema. Violations of these conditions result in anomalies. The chapter Lists down the fundamental problems of Adjacency List models and provide solutions to these problems.
-
Other Models for Trees
Joe Celko's Trees and Hierarchies in SQL for Smarties, 2012Co-Authors: Joe CelkoAbstract:The chapter discusses the models that use different approaches and properties of trees, some of which are hybrids of other models. These models include models such as Adjacency List with self-references and subordinate Adjacency List. Subordinate Adjacency List is a modification of the usual Adjacency List model and shows the edges of a graph as oriented from the superior to the subordinate. Nodes without a subordinate are leaf nodes, and they have a null value. Adjacency List with self-references are also slight modification of the usual Adjacency List model and include an edge that loops back to the same node. The chapter also discusses hybrid moles, such as Adjacency and nested sets model, nested set with depth model, Adjacency and depth model, and computed hybrid models. The chapter also discusses the problem of inability of the nested set model to represent more a general graph in SQL.
-
Chapter 16 – Relationship Analytics
Joe Celko's Analytics and OLAP in SQL, 2006Co-Authors: Joe CelkoAbstract:Publisher Summary It is possible to model a general graph in SQL, but it is not practical. The advantage of SQL is that it is a declarative, set-oriented language. The nature of a relational database is the assumption that the relationships are known in advance, so that a schema can be built and loaded with known facts. This is a good assumption in a production environment. Actually, it is a necessary assumption. The most common way to model a graph in SQL is an Adjacency List model. It is also the best way to model a general graph. Some special kinds of graphs can be modeled differently. It is a typical Adjacency List model of a general graph with one kind of edge. Structure goes in one table, and the nodes go in a separate table, because they are separate kinds of things (entities and relationships).
-
Chapter 28 – Trees and Hierarchies in SQL
Joe Celko's SQL for Smarties, 2005Co-Authors: Joe CelkoAbstract:Publisher Summary A tree is a special kind of directed graph. Graphs are data structures that are made up of nodes connected by edges. There are several ways to define a tree: it is a graph with no cycles and it is a graph where all nodes except the root have indegree one and the root has indegree zero. Another defining property is that a path can be found from the root to any other node in the tree by following the edges in their natural direction. Most Structured Query Language (SQL) databases use the Adjacency List model for two reasons. The first reason is that Dr. Codd came up with it in the early days of the relational model, and nobody thought about it after that. The second reason is that the Adjacency List is a way of “faking” pointer chains—the traditional programming method in procedural languages for handling trees. Because SQL is a set-oriented language, the nested set model is a better model for the approach discussed in this chapter.
Guojing Cong - One of the best experts on this subject based on the ideXlab platform.
-
The Euler tour technique and parallel rooted spanning tree
2004Co-Authors: Guojing Cong, David A. BaderAbstract:Many parallel algorithms for graph problems start with finding a spanning tree and rooting the tree to define some structural relationship on the vertices which can be used by following problem specific computations. The generic procedure is to find an unrooted spanning tree and then root the spanning tree using the Euler tour technique. With a randomized work-time optimal unrooted spanning tree algorithm and work-time optimal List ranking, finding rooted spanning trees can be done work-time optimally on EREW PRAM w.h.p. Yet the Euler tour technique assumes as “given ” a circular Adjacency List, it is not without implications though to construct the circular Adjacency List for the spanning tree found on the fly by a spanning tree algorithm. In fact our experiments show that this “hidden ” step of constructing a circular Adjacency List could take as much time as both spanning tree and List ranking combined. In this paper we present new efficient algorithms that find rooted spanning trees without using the Euler tour technique and incur little or no overhead over the underlying spanning tree algorithms. We also present two new approaches that construct Euler tours efficiently when the circular Adjacency List is not given. One is a deterministic PRAM algorithm and the other is a randomized algorithm in the SMP model.The randomized algorithm takes a novel approach to the problems of constructing Eule
-
The Euler tour technique and parallel rooted spanning tree
2004Co-Authors: Guojing Cong, David A. BaderAbstract:Many parallel algorithms for graph problems start with finding a spanning tree and rooting the tree to define some structural relationship on the vertices which can be used by following problem specific computations. The generic procedure is to find an unrooted spanning tree and then root the spanning tree using the Euler tour technique. With a randomized work-time optimal unrooted spanning tree algorithm and work-time optimal List ranking, finding rooted spanning trees can be done work-time optimally on EREW PRAM w.h.p. Yet the Euler tour technique assumes as “given ” a circular Adjacency List, it is not without implications though to construct the circular Adjacency List for the spanning tree found on the fly by a spanning tree algorithm. In fact our experiments show that this “hidden ” step of constructing a circular Adjacency List could take as much time as both spanning tree and List ranking combined. In this paper we present new efficient algorithms that find rooted spanning trees without using the Euler tour technique and incur little or no overhead over the underlying spanning tree algorithms. We also present two new approaches that construct Euler tours efficiently when the circular Adjacency List is not given. One is a deterministic PRAM algorithm and the other is a randomized algorithm in the symmetric multiprocessor (SMP) model. The randomized algorithm takes a novel approach for the problems of constructing the Euler tour and rooting a tree. It computes a rooted spanning tree first, then constructs an Euler tour directly for the tree using depth-first traversal. The tour constructed is cache-friendly with adjacent edges in th
Weiqiang Sun - One of the best experts on this subject based on the ideXlab platform.
-
scaling up scheduling in snf ocs networks an Adjacency List based solution
Optical Switching and Networking, 2019Co-Authors: Chenchen Zhao, Xiao Lin, Shengnan Yue, Weiqiang SunAbstract:Abstract It has been proved that, in networks with co-existing delay sensitive and delay tolerant traffic flows, the overall network utility can be significantly improved by putting off (or storing) delay tolerant flows until off-peak hours. In our previous work, we proposed Time-Shifted Multilayer Graph (TS-MLG), a routing framework for Store-and-Forward (SnF) optical circuit switched (OCS) networks. With TS-MLG, the scheduling of delay tolerant traffic flows can be determined through a single routing computation. TS-MLG has been shown to be useful in SnF OCS networks of medium size, but the computing time required per traffic flow increases quickly as the network size increases and the number of active requests grows. To control the computational complexity, the number of layers used in routing must be limited, resulting in degradation of network performance. Although the delay caused by computing the end-to-end spatial/temporal path is negligible compared to the overall end-to-end transmission delay, it decides the scalability of the control plane. This prevents TS-MLG from being used in large-scale networks. In this paper, we aim to increase the scalability of the TS-MLG, by taking into account the graph sparsity. Instead of running Dijkstra Algorithm on Adjacency matrices, we propose to use Adjacency List to represent the graph, and Breadth-First Search Algorithm to compute shortest paths. This reduces the computational complexity from O(N2 × L2) to O(N × L + E), in which N is the number of network nodes, L is the number of layers used in routing and E is the number of edges, with a slightly increased overhead in graph update. We verify the effectiveness of the proposed algorithm by performing a large number of computations on the same hardware platform. In a network containing 30 nodes, and when the number of layers is limited to 20, the average time needed to complete 1000 routing computations with the proposed solution is 1.597 s, while that for the original one is 244 s. The proposed solution effectively scales up TS-MLG and make it suitable for large-scale networks.
-
Scaling up scheduling in SnF OCS networks – An Adjacency List based solution
Optical Switching and Networking, 2019Co-Authors: Chenchen Zhao, Xiao Lin, Shengnan Yue, Weiqiang SunAbstract:Abstract It has been proved that, in networks with co-existing delay sensitive and delay tolerant traffic flows, the overall network utility can be significantly improved by putting off (or storing) delay tolerant flows until off-peak hours. In our previous work, we proposed Time-Shifted Multilayer Graph (TS-MLG), a routing framework for Store-and-Forward (SnF) optical circuit switched (OCS) networks. With TS-MLG, the scheduling of delay tolerant traffic flows can be determined through a single routing computation. TS-MLG has been shown to be useful in SnF OCS networks of medium size, but the computing time required per traffic flow increases quickly as the network size increases and the number of active requests grows. To control the computational complexity, the number of layers used in routing must be limited, resulting in degradation of network performance. Although the delay caused by computing the end-to-end spatial/temporal path is negligible compared to the overall end-to-end transmission delay, it decides the scalability of the control plane. This prevents TS-MLG from being used in large-scale networks. In this paper, we aim to increase the scalability of the TS-MLG, by taking into account the graph sparsity. Instead of running Dijkstra Algorithm on Adjacency matrices, we propose to use Adjacency List to represent the graph, and Breadth-First Search Algorithm to compute shortest paths. This reduces the computational complexity from O(N2 × L2) to O(N × L + E), in which N is the number of network nodes, L is the number of layers used in routing and E is the number of edges, with a slightly increased overhead in graph update. We verify the effectiveness of the proposed algorithm by performing a large number of computations on the same hardware platform. In a network containing 30 nodes, and when the number of layers is limited to 20, the average time needed to complete 1000 routing computations with the proposed solution is 1.597 s, while that for the original one is 244 s. The proposed solution effectively scales up TS-MLG and make it suitable for large-scale networks.
Wenguang Chen - One of the best experts on this subject based on the ideXlab platform.
-
livegraph a transactional graph storage system with purely sequential Adjacency List scans
Very Large Data Bases, 2020Co-Authors: Xiaowei Zhu, Guanyu Feng, Marco Serafini, Lei Xie, Ashraf Aboulnaga, Wenguang ChenAbstract:The specific characteristics of graph workloads make it hard to design a one-size-fits-all graph storage system. Systems that support transactional updates use data structures with poor data locality, which limits the efficiency of analytical workloads or even simple edge scans. Other systems run graph analytics workloads efficiently, but cannot properly support transactions.This paper presents LiveGraph, a graph storage system that outperforms both the best graph transactional systems and the best solutions for real-time graph analytics on fresh data. LiveGraph achieves this by ensuring that Adjacency List scans, a key operation in graph workloads, are purely sequential: they never require random accesses even in presence of concurrent transactions. Such pure-sequential operations are enabled by combining a novel graph-aware data structure, the Transactional Edge Log (TEL), with a concurrency control mechanism that leverages TEL's data layout. Our evaluation shows that LiveGraph significantly outperforms state-of-the-art (graph) database solutions on both transactional and real-time analytical workloads.