Interfaces and Applications of Graph Packages

Software Visualisation, 1996

We present several elegant methods used in GraphPack, an educational package, for three dimensional embedding of graphs, as well as a two dimensional layout method, namely barycentric embedding. After that, a program for automatic recognition of graphs is introduced. In addition, we show how graphs in GraphPack format can be exported into X g format. Finally, we describe the client/server capabilities of GraphPack designed for providing communication with other tools and application programs written in C and C++.

The focus of traditional scientific computing has been in solving large systems of PDEs (and the corresponding linear algebra problems that they induce). Hardware architectures, computer systems, and software platforms have evolved together to efficiently support solving these kinds of problems. Similar attention has not been devoted to solving large-scale graph problems. Recently this class of applications has seen increased attention. The irregular, nonlocal, and dynamic characteristics of these problems require new programming techniques to adapt them to modern HPC systems offering multiple levels of parallelism. We describe a library for implementing graph algorithms based on asynchronous execution of fine-grained, concurrent operations. Prototype implementations of two graph kernels which combine lightweight graph metadata transactions with generalized active messages demonstrate that it is possible to implement graph applications which efficiently leverage both shared-and distributed-memory parallelism.

ACM SIGPLAN Notices, 2012

ABSTRACT Algorithms in new application areas like machine learning and network analysis use "irregular" data structures such as graphs, trees and sets. Writing efficient parallel code in these problem domains is very challenging because it requires the programmer to make many choices: a given problem can usually be solved by several algorithms, each algorithm may have many implementations, and the best choice of algorithm and implementation can depend not only on the characteristics of the parallel platform but also on properties of the input data such as the structure of the graph. One solution is to permit the application programmer to experiment with different algorithms and implementations without writing every variant from scratch. Auto-tuning to find the best variant is a more ambitious solution. These solutions require a system for automatically producing efficient parallel implementations from high-level specifications. Elixir, the system described in this paper, is the first step towards this ambitious goal. Application programmers write specifications that consist of an operator, which describes the computations to be performed, and a schedule for performing these computations. Elixir uses sophisticated inference techniques to produce efficient parallel code from such specifications. We used Elixir to automatically generate many parallel implementations for three irregular problems: breadth-first search, single source shortest path, and betweenness-centrality computation. Our experiments show that the best generated variants can be competitive with handwritten code for these problems from other research groups; for some inputs, they even outperform the handwritten versions.

Graph algorithms have several important applications in fields such as computer science, software engineering, mathematics, engineering, business, and bioinformatics. Researchers and practitioners in these disciplines often need to experiment with empirical data about graphs to gain deeper insights into their properties, which may lead to general proofs. Students also need to learn and be able to implement graph algorithms for their applications. However, these individuals often have varying backgrounds and training, and they may not have a working knowledge of programming tools to implement graph algorithms. The goal of our research is to create a software system which allows users to easily create and implement graph algorithms through a simple graphical user interface, without any coding. Towards this goal, we have developed several systems that can be used to draw and manipulate graphs as well as to execute graph algorithms. The development of the general system raises a number of interesting research questions that we will discuss. To illustrate the need for experimentation with different graph algorithms, we describe some examples of our research in different areas of graph theory and computational geometry. We also describe some features of our systems that we have found useful in teaching graph theory.

Lecture Notes in Computer Science, 2000

Specification and rapid prototyping of graph manipulation software by means of PROgrammed Graph REwriting Systems (PROGRES) is a paradigm, which attracts more and more interest in various fields of computer science. Nowadays produced specifications for process modeling tools, database query languages, etc. have a typical size of about 100 to 300 printed pages. They suffer severely from the lack of any module concept. This paper introduces a module concept for the graph rewriting (transformation) language PROGRES, which is closely related to the package concept of the standardized OO modeling language UML. It supports a variety of software design patterns including the construction of "Abstract Graph Types" and "Updatable Graph Views".

2017 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW), 2017

The purpose of the GraphBLAS Forum is to standardize linear-algebraic building blocks for graph computations. An important part of this standardization effort is to translate the mathematical specification into an actual Application Programming Interface (API) that (i) is faithful to the mathematics and (ii) enables efficient implementations on modern hardware. This paper documents the approach taken by the C language specification subcommittee and presents the main concepts, constructs, and objects within the GraphBLAS API. Use of the API is illustrated by showing an implementation of the betweenness centrality algorithm. • The domain D, the data type for the vector elements. • The size N > 0.

We describe a system that uses automated planning to synthesize correct and efficient parallel graph programs from high-level algorithmic specifications. Automated planning allows us to use constraints to declaratively encode program transformations such as scheduling, implementation selection, and insertion of synchronization. Each plan emitted by the planner satisfies all constraints simultaneously, and corresponds to a composition of these transformations. In this way, we obtain an integrated compilation approach for a very challenging problem domain. We have used this system to synthesize parallel programs for four graph problems: triangle counting, maximal independent set computation, preflow-push maxflow, and connected components. Experiments on a variety of inputs show that the synthesized implementations perform competitively with handwritten , highly-tuned code.

2008

Graph algorithms have several important applications in fields such as computer science, software engineering, mathematics, engineering, business, and bioinformatics. Researchers and practitioners in these disciplines often need to experiment with empirical data about graphs to gain deeper insights into their properties, which may lead to general proofs. Students also need to learn and be able to implement graph algorithms for their applications. However, these individuals often have varying backgrounds and training, and they may not have a working knowledge of programming tools to implement graph algorithms. The goal of our research is to create a software system which allows users to easily create and implement graph algorithms through a simple graphical user interface, without any coding. Towards this goal, we have developed several systems that can be used to draw and manipulate graphs as well as to execute graph algorithms. The development of the general system raises a number of interesting research questions that we will discuss. To illustrate the need for experimentation with different graph algorithms, we describe some examples of our research in different areas of graph theory and computational geometry. We also describe some features of our systems that we have found useful in teaching graph theory.

Graph Transformation, 2016

We show how to generate efficient C code for a high-level domain-specific language for graphs. The experimental language GP 2 is based on graph transformation rules and aims to facilitate formal reasoning on programs. Implementing graph programs is challenging because rule matching is expensive in general. GP 2 addresses this problem by providing rooted rules which under mild conditions can be matched in constant time. Using a search plan, our compiler generates C code for matching rooted graph transformation rules. We present run-time experiments with our implementation in a case study on checking graphs for two-colourability: on grid graphs of up to 100,000 nodes, the compiled GP 2 program is as fast as the tailor-made C program given by Sedgewick.

2010

Computations on unstructured graphs are challenging to parallelize because dependences in the underlying algorithms are usually complex functions of runtime data values, thwarting static parallelization. One promising general-purpose parallelization strategy for these algorithms is optimistic parallelization.