Heapviz: Interactive heap visualization for program understanding and debugging

  title={Heapviz: Interactive heap visualization for program understanding and debugging},
  author={Sean Kelley and Edward Aftandilian and Connor Gramazio and Nathan P. Ricci and Sara L. Su and Samuel Z. Guyer},
  journal={Information Visualization},
  pages={163 - 177}
Understanding the data structures in a program is crucial to understanding how the program works, or why it does not work. Inspecting the code that implements the data structures, however, is an arduous task and often fails to yield insights into the global organization of a program’s data. Inspecting the actual contents of the heap solves these problems but presents a significant challenge of its own: finding an effective way to present the enormous number of objects it contains. In this paper… 

Figures from this paper

HeapVision:Debugging by Interactive Heap Navigation

A tool called HeapVision is developed, which allows for inspection of and interaction with dynamic visual representations of the heap structure, and a novel pen and touch based interface that allows developers to more directly interact with the running process and to concentrate on the essence of the program.

An Interactive System for Data Structure Development

The key technical idea of this work is to combine deep parametric abstraction techniques emerging from the area of static analysis with interactive abstraction manipulation, which bridges program analysis with HCI and enables new capabilities not possible before.

An Interactive System for Data Structure Development

The key technical idea of the work is to combine deep parametric abstraction techniques emerging from the area of static analysis with interactive abstraction manipulation, which bridges program analysis with HCI and enables new capabilities not possible before.

Visualizing trace of Java collection APIs by dynamic bytecode instrumentation

Abstracting runtime heaps for program understanding

The abstract heap model and the associated algorithms for transforming a concrete heap dump into the corresponding abstract model as well as algorithms for merging, comparing, and computing changes between abstract models are described.

DrAST - An attribute debugger for JastAdd

DrAST is presented, a new solution in compiler debugging which can be of use for both students and professionals and is built for further extension.

Shape-Analysis Driven Memory Graph Visualization

MGE (Memory Graph Explorer) is presented, a memory analyzer and visualizer that combines a novel memory graph abstraction with an interactive visualization that works for corrupt data structures, and is particularly powerful for large, nested structures due to its support for interactive (un)folding.

ClassSpy: Java Object Pattern Visualization Tool

This paper presents a visualization approach that depicts information about all the objects instantiated during the program execution that is more space efficient and scalable to handle vast datasets, at the same time helpful to identify the key program components.

Heap Patterns for Memory Graph Visualization

A novel heap pattern language for concisely and intuitively describing structural aspects of dynamic data structures and nested payload data is presented and developers can now control the construction of hierarchies using heap patterns to flexibly and locally adjust the level of memory graph abstraction in an interactive graph visualization.

Data Structure Visualization on the Web

  • Juan LinHui Zhang
  • Computer Science
    2020 IEEE International Conference on Big Data (Big Data)
  • 2020
This paper presents an interactive visualization tool for data structure in Python that can monitor the run-time data structure change and render the corresponding presentation in real-time by using the inner execution trace.

Heapviz : Interactive Heap Visualization for Program Understanding and Debugging 1

Heapviz is a tool for visualizing and exploring snapshots of the heap obtained from a running Java program that presents a global view of the program state as a graph together with powerful interactive capabilities for navigating it and reduces the size and complexity of the graph.

High-Level Heap Abstractions for Debugging Programs

A novel approach that emphasizes highlevel concepts about heap based data structures (their layout and size) and relationships between them (sharing and connectivity) and an efficient algorithm for computing this abstract representation that scales quasilinearly with the size of the heap is given.

Dynamic Data Structure Analysis for Java Programs

A dynamic heap analysis system is designed and implemented that allows one to examine and analyze how Java programs build and modify data structures, and to establish limits on static data structure analysis.

An information exploration tool for performance analysis of Java programs

This work presents Jinsight EX, a tool for analyzing Java performance, that adopts techniques that have been successfully used to explore large data sets in other application domains, and adapts them specifically to the needs of program execution analysis.

Visualizing the Java heap to detect memory problems

  • S. Reiss
  • Computer Science
    2009 5th IEEE International Workshop on Visualizing Software for Understanding and Analysis
  • 2009
This paper describes the visualization strategy it uses for interactively displaying the model of the heap from a running Java system and related information to achieve these goals.

Visualizing reference patterns for solving memory leaks in Java

This paper shows a new methodology for finding the causes of memory leaks in Java, and proposes a novel combination of visual syntax and reference pattern extraction to manage this additional complexity.

Making Sense of Large Heaps

This work presents Yeti, a tool that summarizes memory usage to uncover the costs of design decisions, rather than of lower-level artifacts as in traditional tools, making it possible to quickly identify and remediate problems.

Visualizing Memory Graphs

A memory graph gives a comprehensive view of all data structures of a program; data items are related by operations like dereferencing, indexing or member access.

Scalable Visualizations of Object-Oriented Systems with Ownership Trees

This work has developed a program visualization tool that makes use of ownership trees to display the structure of object-oriented programs and is applicable at all levels of abstraction within a program's design.

HDPV: interactive, faithful, in-vivo runtime state visualization for C/C++ and Java

The design and implementation of HDPV are presented, a system for interactive, faithful, in-vivo runtime state visualization for native C/C++ programs and Java programs and the visual effect of programming errors such as buffer overflows are discussed.