Distributed graph-based state space generation

LTSMIN provides a framework in which state space generation can be distributed easily over many cores on a single compute node, as well as over multiple compute nodes. The tool works on the basis of a vector representation of the states; the individual cores are assigned the task of computing all successors of states that are sent to them. In this paper we show how this framework can be applied in the case where states are essentially graphs interpreted up to isomorphism, such as the ones we have been studying for GROOVE. This involves developing a suitable vector representation for a canonical form of those graphs. The canonical forms are computed using a third tool called BLISS. We combined the three tools to form a system for distributed state space generation based on graph grammars. We show that the time performance of the resulting system scales well (i.e., close to linear) with the number of cores. We also report surprising statistics on the memory\ud consumption, which imply that the vector representation used to store graphs in LTSMIN is more compact than the representation used in GROOVE

Workshop on Graph-Based Tools

Abstract. Graphs are well-known, well-understood, and frequently used means to depict networks of related items. They are successfully used as the underlying mathematical concept in various application domains. In all these domains, tools are developed that store, retrieve, manipulate and display graphs. It is the purpose of this workshop to summarize the state of the art of graph-based tool development, bring together develop-ers of graph-based tools in different application fields and to encourage new tool development cooperations.

Agraphs: Definition, implementation and tools

Agraphs are a graph-based language representation, transformation and exchange format. In the same vein as XML, Agraphs form a general data representation mechanism that needs to be instantiated in different specific applications. In this paper, we present the Agraphs data structure, programming interface and related tools, identify their main features with respect to exchange format characteristics, and compare them to other existing exchange formats. These different features are illustrated on an instance of Agraphs for modular Petri nets

Isomorphism Checking in GROOVE

In this paper we show how isomorphism checking can be used as an effective technique for symmetry reduction in graph-based state spaces, despite the inherent complexity of the isomorphism problem. In particular, we show how one can use element-based graph certificate mappings to help in recognising nonisomorphic graphs. These are mappings that assign to all elements (edges and nodes) of a given graph a number that is invariant under isomorphism, in the sense that any isomorphism between graphs is sure to preserve this number. The individual element certificates of a graph give rise to a certificate for the entire graph, which can be used as a hash key for the graph; hence, this yields a heuristic to decide whether a graph has an isomorphic representative in a previously computed set of graphs. We report some experiments that show the viability of this method. \u

Creating Well-Structured Specifications in MOFLON

Considering the growing popularity of model-based development, specifications become more complex. As a consequence, graph-based modeling tools have to take measures to handle this complexity. In this paper, we present the metamodeling environment MOFLON which has been developed on top of the FUJABA Toolsuite during the last few years at our department. We focus one of MOFLON's strongest advantages, i.e. the realization of the abstraction and modularization features introduced by the recent UML 2.0 Infrastructure specification. The new concept of package merge allows to reuse and refine existing models without modifying the original. Subset and redefinition relationships become useful tools to refine associations due to the automatic propagation mechanism generated by the MOFLON code generator. We show how the user can organize large specifications using these concepts and how they effect graph transformation rules and code generation

Neighbourhood Abstraction in GROOVE - Tool Paper

In this paper we discuss the implementation of neighbourhood graph abstraction in the GROOVE tool set. Important classes of graph grammars may have unbounded state spaces and therefore cannot be verified with traditional model checking techniques. One way to address this problem is to perform graph abstraction, which allows us to generate a finite abstract state space that over-approximates the original one. In previous work we presented the theory of neighbourhood abstraction. In this paper, we present the implementation of this theory in GROOVE and illustrate its applicability with a case study that models a single-linked list

RePLEX: A Model-Based Reengineering Tool for PLEX Telecommunication Systems

Maintenance of complex legacy software systems is a challenging task. In the first place, maintenance requires understanding the system. Reverse engineering and reengineering tools, which make the design of the current system available on-line and which support planning and performing changes to the system, are urgently needed. We present a new tool for reengineering telecommunication systems, recovering the current architecture, and extracting state machines reflecting the system behavior. The tool is based on a structure graph of the architecture and allows architectural modifications with according code changes. The modifications are specified as graph transformations using FUJABA enabling the generation of a Java prototype, which is accessible via a GUI based on the Graphical Editor Framework (GEF) plug-in for the Eclipse workbench

Graph Subsumption in Abstract State Space Exploration

In this paper we present the extension of an existing method for abstract graph-based state space exploration, called neighbourhood abstraction, with a reduction technique based on subsumption. Basically, one abstract state subsumes another when it covers more concrete states; in such a case, the subsumed state need not be included in the state space, thus giving a reduction. We explain the theory and especially also report on a number of experiments, which show that subsumption indeed drastically reduces both the state space and the resources (time and memory) needed to compute it.Comment: In Proceedings GRAPHITE 2012, arXiv:1210.611