Graph-Related Properties for Comparing Dynamic Call Graphs

https://doi.org/10.1016/j.cola.2020.100967Get rights and content

Abstract

Software systems produce long sequences of call graphs, in particular, if the graphs are generated during runtime and not revision by revision. Visualizing, analyzing, and interacting with such long dynamic graphs with respect to different properties is a challenging task. In this article we describe an interactive visualization technique for dynamic call graphs that supports the observation of the data in vertex, edge, and time dimensions based on properties related to the graph topology, inherent vertex hierarchy, involved links, and graph-theoretic problems. Moreover, we provide a time-aligned view on several dynamic graphs with the goal to compare them visually. We also provide standard node-link diagrams for individual graphs or aggregated dynamic graph subsequences as a details-on-demand technique and for supporting graph comparisons on different temporal granularities. We illustrate the usefulness of the dynamic graph visualization by applying it to the call relations at runtime of the open source software project JHotDraw. We evaluated the interactive visualization by reflecting on the static and dynamic patterns we could identify in the dataset by changing the graph properties under exploration. Moreover, we conducted a controlled user study with 20 participants investigating three typical tasks like finding graph sequences, identifying a complete graph, and exploring the reason for a change in a shortest path algorithm. Finally, we discuss scalabilities and limitations of our approach.

Introduction

Interacting with a software system at runtime may show if it works reliably or not, i.e., if problems like strange behaviors occur that are not easily fixable when inspecting the source code alone [15]. However, recording the call relations during runtime can help to identify functionality problems. For such a scenario the dynamic graph data can become temporally long involving hundreds or thousands of functions spread all over the software system hierarchy. For this reason an overview in form of a dynamic graph visualization is important to observe the time-varying call relation patterns and therefore, which calls may cause an erroneous functionality.

Visualizations can be useful if there is no algorithm available that can be specified clearly enough to compute patterns in a dataset. This can be the case in a dynamic call graph in which the generated patterns are unclear due to bugs or an unexpected behavior. Based on visual representations we might be able to build, refine, reject, or confirm hypotheses about the data [28], making visualization a powerful concept to explore unknown call graph datasets. The calls in a software system indicate if the functionality of the system runs properly or if certain parameter configurations cause calls that have a strange behavior for the run of a software system. This behavior may be observed from a dynamic call graph pattern, i.e. in most cases we cannot search for it, for example, with an algorithm, hence visualization might give hints.

Generally, dynamic graphs consist of at least three data dimensions that come in the form of vertices, edges, and time steps. Moreover, if the vertices are attached by an additional hierarchical organization, also this can be worth investigating. Edges may additionally carry weights and can be directed, finally, generating a dynamic network dataset, providing a challenging dataset scenario to be visualized.

In particular, call relations in software systems belong to this special type of dynamic graph. The software entities like functions build the vertices that are related by calls, i.e., functions or methods call each other, building a call graph that can be changing over time. The functions typically build a level of granularity that can make the graphs rather big and hence, a hierarchical organization into subdirectories, directories, or packages may also be a useful concept in order to reduce the amount of graph vertices by filtering or by aggregating the call relations. This hierarchy aspect can be of particular interest if the call relations have to be inspected on several hierarchical granularities.

In this article we introduce an algorithmic as well as a visual approach to first, identify phases in dynamic call graphs and second, visualize those phases in a scalable dynamic graph visualization. The identification can be based on the graph topology, the hierarchical structure, or the visual properties given by the layout or vertex order implying link properties like link lengths or link orientations/directions. Moreover, the dynamics of typical graph-theoretic problem solutions might be of interest, for example, if and when a shortest path between two vertices changed.

For the visual representation of the dynamic call graphs we use a time-to-space mapping, i.e., a mental map-preserving and scalable visualization technique based on the concept of interleaving, introduced by Burch et al. [9]. Interaction techniques are integrated in the visualization tool while typical parameters influencing the visual appearance of the visualization can be changed on users’ demand. We add another list of interaction techniques based on the graph, hierarchy, layout, or graph-theoretic properties, also those that explicitly exploit the computed phases to filter and navigate in the dynamic call graph data.

We illustrate the usefulness of our technique by applying it to the open source software project JHotDraw in which the call relations are recorded during the runtime of the software system while a user interacts with the runnable software. This generates a dynamic call graph consisting of more than 1,000 directed and weighted graphs with several hundred hierarchically organized software entities and several thousand weighted call relations.

This article is an extension of a previously published paper [8] focusing on property-driven dynamic call graph exploration. In particular, we extended the previous work by the following points:

  • Dynamic graph-theoretic problems: Getting an over-view about the evolution of solutions to graph-theoretic problems can be of great support for detecting if and when certain graph properties changed, for example, missing relations that cause different solutions for the shortest path problem. We implemented variants of the Dijkstra [17] and Floyd-Warshall [19] algorithms and incorporated their outputs into the dynamic graph visualization (see Section 3.5).

  • Time-aligned display of several dynamic graphs: Representing several dynamic graphs next to each other can give insights into the differences over time as well as over the structure of the graph, i.e., also about specific properties for which someone has filtered the dynamic network data. This can be done for several instances of the same software for several runs or under different properties. Moreover, subsequences of the same dynamic call graph might be inspected by temporally aligning them in a stacked manner (see Section 4.3).

  • Standard views on individual graphs: We designed the dynamic graph visualization for getting an overview about the dynamics of the data, as an extension we now also support several views on individual graphs as node-link diagrams. Those can also be aggregations of a subsequence of the dynamic graph. We visually depict the node-link diagrams in certain well-known layouts like a circular [5], Fruchterman-Reingold [21], Kamada-Kawai [27], or Reingold-Tilford [33] layout which is interactively selectable by the user also helping to compare the graphs over time and by different layouts (see Section 4.5).

  • User evaluation: We conducted a controlled user study with 20 participants to investigate the effect of the graph sequence length on typical dependent variables like error rates and response times. We tested three typical tasks like finding graph sequences, identifying a complete graph, and exploring the reason for a change in a shortest path algorithm (see Section 6).

  • Discussion and limitations: As another add-on, we describe limitations and scalability issues of our technique which can be based on the data dimensions we have to deal with, i.e., vertices, edges, and timesteps. Moreover, also the additional properties might cause scalability issues in our approach, in particular, the algorithms for finding solutions to the graph-theoretic problems (see Section 8).

Section snippets

Related Work

Dynamic call relations can be visually represented by using one of the candidates from the large repertoire of dynamic graph visualization techniques [3]. However, there are two camps of researchers, one focusing on graph animation and the other on static displays of dynamic graphs while the strengths and weaknesses of each of those are discussed controversially [34]. The first approaches are denoted by time-to-space mappings while the second ones are called time-to-time mappings since the

Dynamic Call Graph Data

In this section we describe how static and dynamic call graphs can be modeled while the graph vertices are typically hierarchically organized in a software system hierarchy. Based on the dynamic graph data we explain how phases of call relations can be computed that can be based on the data only, also on visual properties given by the graph layout or linear vertex ordering [22] if a bipartite layout is applied. Also the dynamics of graph-theoretic problems is of interest.

Dynamic Graph Visualization

Since we deal with very long time-varying call graphs, a dynamic graph visualization is required that focuses on visual scalability in order to generate an overview about dynamic visual patterns. Those patterns are then useful to explore the call graph data if they can be remapped from the visualization to the dynamic data in a reliable way. Hence, we base our approach on the recently designed idea of interleaving bipartite layouts (see Figure 1), each representing a single static call graph [9]

Application Example

In this section we apply the dynamic call graph visualization to dynamic call graph data from the JHotDraw project. We first present an overview about the entire dataset that consists of 982 vertices (software entities), 32,259 weighted and directed edges (call relations), and 1,077 time steps (time stamps during program execution). Then we describe the interaction techniques focusing on phase identification applied to different graph, hierarchy, and visualization properties, also for finding

User Evaluation

We conducted a controlled user experiment with 20 participants to investigate the usefulness of the dynamic graph visualization. In the study we focus on the identification of dynamic graph patterns, a specific static graph with a certain (complete graph) property, and gaps in the dynamics of a shortest path. We varied the length parameter of the graph sequence as independent variable and measured the impact on the error rates and response times of the participants under a certain task scenario

Study Results

In this section we present the results for the three tasks and based on them we argue about the research questions. Moreover, we will take a special look at the qualitative feedback and describe the benefits and drawbacks of the technique based on the participants feedback.

The study took in average 28,45 minutes, ranging from 17 to 47 minutes. The participants answered all trials (no skip, no give up), i.e. in total 600 trials were processed at an average error rate of 3.0% for T1, 4.5% for T2,

Discussion and Limitations

As another add-on, we describe limitations and scalability issues of our technique which can be based on the data dimensions we have to deal with, i.e., vertices, edges, and timesteps. Moreover, also the additional properties might cause scalability issues in our approach, in particular, the algorithms for finding solutions to the graph-theoretic problems.

From a visual perspective there is no limitation on the number of vertices, edges, and timesteps that are plotted in an interleaved dynamic

Conclusion and Future Work

In this article we described a dynamic call graph visualization technique that is visually scalable in the number of software entities, number of call relations, and the number of call graphs over time. Moreover, we described an approach to identify certain call relation phases based on the call graph topology and the hierarchical software system structure. Additionally, the layout and order of the software entities in the dynamic call graph visualization can be used to compute a number of

Declaration of Competing Interest

Thank you for inviting the paper to an extended version in your journal.

References (35)

  • T. Kamada et al.

    An algorithm for drawing general undirected graphs

    Information Processing Letters

    (1989)
  • K. Misue et al.

    Layout adjustment and the mental map

    Journal of Visual Languages and Computing

    (1995)
  • B. Tversky et al.

    Animation: can it facilitate?

    International Journal of Human-Computer Studies

    (2002)
  • D. Archambault et al.

    Animation, small multiples, and the effect of mental map preservation in dynamic graphs

    IEEE Transactions on Visualization and Computer Graphics

    (2011)
  • A.-L. Barabasi et al.

    Emergence of scaling in random networks

    Science

    (1999)
  • F. Beck et al.

    A taxonomy and survey of dynamic graph visualization

    Computer Graphics Forum

    (2017)
  • F. Beck et al.

    Rapid serial visual presentation in dynamic graph visualization

    Proceedings of the IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC)

    (2012)
  • U. Brandes et al.

    More flexible radial layout

    Journal on Graph Algorithms and Applications

    (2011)
  • M. Burch

    The dynamic call graph matrix

    Proceedings of the International Symposium on Visual Information Communication and Interaction (VINCI)

    (2016)
  • M. Burch

    Isoline-enhanced dynamic graph visualization

    Proceedings of the International Conference on Information Visualisation (IV)

    (2016)
  • M. Burch

    Property-driven dynamic call graph exploration

    Proceedings of the 11th International Symposium on Visual Information Communication and Interaction, VINCI

    (2018)
  • M. Burch et al.

    Visualizing a sequence of a thousand graphs (or even more)

    Computer Graphics Forum

    (2017)
  • M. Burch et al.

    Visualizing dynamic call graphs

    Proceedings of the Vision, Modeling, and Visualization Workshop 2012

    (2012)
  • M. Burch et al.

    A matrix-based visualization for exploring dynamic compound digraphs

    Proceedings of the International Conference on Information Visualisation, IV

    (2013)
  • M. Burch et al.

    Parallel edge splatting for scalable dynamic graph visualization

    IEEE Transactions on Visualization and Computer Graphics

    (2011)
  • M. Burch et al.

    Visualizing dynamic quantitative data in hierarchies - TimeEdgeTrees: Attaching dynamic weights to tree edges

    IMAGAPP & IVAPP 2011 - Proceedings of the International Conference on Imaging Theory and Applications and International Conference on Information Visualization Theory and Applications

    (2011)
  • C.S. Collberg et al.

    A system for graph-based visualization of the evolution of software

    Proceedings ACM 2003 Symposium on Software Visualization

    (2003)
  • Cited by (1)

    Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]. VINCI ’18, August 13-15, 2018, Växjö, Sweden

    1

    CCS CONCEPTS: Human-centered computing  →  Visualization techniques;

    2

    ACM Reference Format: Michael Burch. 2018. Graph-Related Properties for Comparing Dynamic Call Graphs. In VINCI ’18: The 11th International Symposium on Visual Information Communication and Interaction, August 13-15, 2018, Växjö, Sweden, Jennifer B. Sartor, Theo D’Hondt, and Wolfgang De Meuter (Eds.). ACM, New York, NY, USA, Article 4, 16 pages. https://doi.org/10.1145/3231622.3231630

    View full text