The generic graph component library

1999

by Lie-Quan Lee In this thesis I present the Generic Graph Component Library (GGCL), a generic programming framework for graph data structures and graph algorithms. Following the theme of the Standard Template Library (STL), the graph algorithms in GGCL do not depend on the particular data structures upon which they operate, meaning a single algorithm can operate on arbitrary concrete representations of graphs. I describe the principal abstractions comprising the GGCL, the algorithms and data structures that it provides, and provide examples that demonstrate the use of GGCL to implement some common graph algorithms. Performance results are presented which demonstrate that the use of novel lightweight implementation techniques and static polymorphism in GGCL results in code which is significantly more efficient than similar libraries written using the objectoriented paradigm. To my father, my mother in memoriam, and my wife Yun

Proceedings of the 1996 ACM symposium on Applied Computing - SAC '96, 1996

In its basic form, a graph consists of a set of vertices and a set of edges. Infinitely many variations, however, can be defined from it. One may associate any set of attributes with the set of vertices and edges (resulting directed and undirected graphs, flow networks, finit e state diagrams, vertex weighted graphs, etc.), or associate any set of restrictions with the set of vertices and edges (resulting acyclic graphs, bipartite graphs, planar graphs, interval graphs, etc.). Various graphs have been implemented and embedded in today's software systems. In this paper, we study the issues of reusable design and propose a design and implementation of reusable graph objects using object-oriented concepts so that graph objects can be adapted to new or revised applications.

This paper details the design and implementation of OCAMLGRAPH, a highly generic graph library for the programming language O CAML. This library features a large set of graph data structures-directed or undirected, with or without labels on vertices and edges, as persistent or mutable data structures, etc.-and a large set of graph algorithms. Algorithms are written independently from graph data structures, which allows combining user data structure (resp. algorithm) with OCAMLGRAPH algorithm (resp. data structure). Genericity is obtained through massive use of the OCAML module system and its functions, the so-called functors. ⋆ This work was mostly done while the third author was at LRI. 1

2014

Abstract: This paper details the design and implementation of OCAMLGRAPH, a highly generic graph library for the programming language OCAML. This li-brary features a large set of graph data structures—directed or undirected, with or without labels on vertices and edges, as persistent or mutable data structures, etc.—and a large set of graph algorithms. Algorithms are written independently from graph data structures, which allows combining user data structure (resp. algorithm) with OCAMLGRAPH algorithm (resp. data structure). Genericity is obtained through massive use of the OCAML module system and its functions, the so-called functors. 1.1

Electronic Notes in Theoretical Computer Science, 2011

This paper introduces LEMON, a generic open source C++ library of graph and network algorithms and related data structures. It is a package of highly efficient and versatile tools with simple and convenient interface, targeting both computer scientists and the operations research community, as well as serving educational purposes. In this paper, the basic design concepts, features and performance of LEMON are compared to similar software packages, namely BGL (Boost Graph Library) and LEDA. Various implementation details are also discussed demonstrating the sophisticated use of C++ templates and other techniques. Due to its clear concepts and design, the ease of use and impressive performance, LEMON proved to be a remarkable alternative to similar open source or commercial libraries.

2000

To test GGCL under Unix/Linux environment, go to the ggcl-x.x.x-x/test after you configure the package and type make test. It will take a long time to finish all the test suites. To test GGCL under Windows NT/98 you will need to use either UWIN or Cygwin. Note to g++ users on Solaris 2.5 and 2.6 According to gcc web page, Sun as 4.x has a bug and it is not able to handle very long symbol names. A typical error message might look similar to the following: /usr/ccs/bin/as: "/var/tmp/XXXXX.s", line YYYYY: error: can't compute value of an expression involving an external symbol. See "How to work around too long C++ symbol names?" at gcc FAQ to build a version of gcc which is able to compress long symbol names.

1995

This paper discusses two applications of graph packages. Some of these packages were developed at Rensselaer [6, 10, 2]; others were developed elsewhere [5, 8]. By properly interfacing with other packages, we can solve a rich variety of graph problems. In this paper, we show how these packages can be interfaced, and provide two representative examples. In the first example, we used Nauty to generate all non-isomorphic regular graphs (undirected and unlabeled) of degree 3. We used GraphPack to draw these graphs. We also used the Maple interface to GraphPack to calculate the characteristic polynomials of these graphs. In the second example, we used GraphPack with an object oriented parallelizing compiler called HICOR [2] to display the results of different scheduling disciplines. We have also developed a new graph drawing system called Zgraph, using Motif under X Windows system [10]. Using Zgraph one can draw graphs of up to 10,000 vertices. We were also able to interface Zgraph with ...

Lecture Notes in Computer Science, 2002

GXL (Graph eXchange Language) is designed to be a standard exchange format for graph-based tools. GXL is defined as an XML sublanguage, which offers support for exchanging instance graphs together with their appropriate schema information in a uniform format. Formally, GXL is based on typed, attributed, ordered directed graphs, which are extended by concepts to support representing hypergraphs and hierarchical graphs. Using this general graph model, GXL offers a versatile support for exchanging nearly all kinds of graphs. This report intends to give a short overview on the main features of GXL.

Proceedings of Annual IEEE/ACM International Symposium on Code Generation and Optimization - CGO '14, 2014

Large-scale graph processing, with its massive data sets, requires distributed processing. However, conventional frameworks for distributed graph processing, such as Pregel, use non-traditional programming models that are well-suited for parallelism and scalability but inconvenient for implementing non-trivial graph algorithms. In this paper, we use Green-Marl, a Domain-Specific Language for graph analysis, to intuitively describe graph algorithms and extend its compiler to generate equivalent Pregel implementations. Using the semantic information captured by Green-Marl, the compiler applies a set of transformation rules that convert imperative graph algorithms into Pregel's programming model. Our experiments show that the Pregel programs generated by the Green-Marl compiler perform similarly to manually coded Pregel implementations of the same algorithms. The compiler is even able to generate a Pregel implementation of a complicated graph algorithm for which a manual Pregel implementation is very challenging.

Proceedings of the 15th ACM SIGPLAN International Conference on Software Language Engineering

Domain-specific language compilers need to close the gap between the domain abstractions of the language and the lowlevel concepts of the target platform. This can be challenging to achieve for compilers targeting multiple platforms with potentially very different computing paradigms. In this paper, we present a multi-target, multi-paradigm DSL compiler for algorithmic graph processing. Our approach centers around an intermediate representation and reusable, composable transformations to be shared between the different compiler targets. These transformations embrace abstractions that align closely with the concepts of a particular target platform, and disallow abstractions that are semantically more distant. We report on our experience implementing the compiler and highlight some of the challenges and requirements for applying language workbenches in industrial use cases. CCS Concepts: • Software and its engineering → Domain specific languages.