[Paper Review] Collecting Graphical Abstract Views of Mercury Program Executions

Erwan Jahier|arXiv (Cornell University)|Oct 1, 2000

Software Engineering Research2 citations

TL;DR

This paper presents Collect, a high-level operator built on Mercury's trace system that enables developers to easily create monitors for visualizing program executions. By writing just dozens of lines of code, users can generate graphical abstractions like proof trees, control flow graphs, and dynamic call graphs, which serve as front-ends for software visualization tools, with the approach being portable across any language with a tracer.

ABSTRACT

A program execution monitor is a program that collects and abstracts information about program executions. The operator is a high level, general purpose primitive which lets users implement their own monitors. Collect is built on top of the Mercury trace. In previous work, we have demonstrated how this operator can be used to efficiently collect various kinds of statistics about Mercury program executions. In this article we further demonstrate the expressive power and effectiveness of by providing more monitor examples. In particular, we show how to implement monitors that generate graphical abstractions of program executions such as proof trees, control flow graphs and dynamic call graphs. We show how those abstractions can be easily modified and adapted, since those monitors only require several dozens of lines of code. Those abstractions are intended to serve as front-ends of software visualization tools. Although is currently implemented on top of the Mercury trace, none of its underlying concepts depend of Mercury and it can be implemented on top of any tracer for any programming language.

Motivation & Objective

• To provide a flexible, high-level mechanism for monitoring and visualizing Mercury program executions.
• To demonstrate that complex graphical abstractions of program behavior can be generated with minimal code using the Collect operator.
• To enable the creation of software visualization front-ends by abstracting execution traces into human-readable diagrams.
• To show that the underlying concepts are independent of Mercury, making them applicable to any language with a tracer.

Proposed method

• The Collect operator is used as a general-purpose primitive to define custom monitors that extract and structure execution data from Mercury traces.
• Monitors are implemented using a few dozen lines of code to generate specific graphical abstractions such as proof trees and control flow graphs.
• The approach leverages Mercury's trace system to capture runtime execution details, which are then transformed into structured visual representations.
• Graphical abstractions are generated by analyzing call patterns, control flow, and logical dependencies in the execution trace.
• The method supports extensibility, allowing easy modification and adaptation of visualizations for different analysis needs.
• The design is language-agnostic in concept, relying only on a tracer interface, enabling portability to other languages.

Experimental results

Research questions

• RQ1 Can a high-level operator like Collect be used to generate meaningful graphical abstractions of program executions with minimal code?
• RQ2 How effectively can Collect be used to represent complex program behaviors such as control flow and logical proofs in visual form?
• RQ3 To what extent can the same monitoring infrastructure support diverse visualization types like call graphs and proof trees?
• RQ4 Can the approach be generalized beyond Mercury to other programming languages with tracing support?
• RQ5 How maintainable and adaptable are the resulting visualizations when requirements change?

Key findings

• Collect enables the generation of complex graphical abstractions such as proof trees, control flow graphs, and dynamic call graphs using only a few dozen lines of code.
• The visualizations produced are effective as front-ends for software visualization tools, improving program understanding.
• The approach is highly adaptable, allowing easy modification of abstractions to suit different analysis needs.
• The core concepts of Collect are independent of Mercury, making the method applicable to any language with a compatible tracer.
• The method demonstrates that lightweight, domain-specific monitors can effectively extract and structure execution data for visualization.