Component-based Visualization of the Execution of a Java System

[Overview] [Papers] [Contact] [Credits]


Software developers need to understand how a software system works to introduce new behaviour, correct faults, tune the performance of the system, amongst other tasks. As a system grows in size and as it incorporates more and more libraries, frameworks and components that the developers did not themselves write, it becomes harder and harder to understand how the system does work. Visualizations of the execution of a system can help a developer gain the knowledge they need to perform a particular task. Most visualization tools provide detailed views on the execution of a system: A developer can investigate the execution in terms of objects and classes, views of the call stack, etc. These visualization tools help a developer investigate small portions of small parts of the execution of a system.

The goal of the AVID visualizer is to support the investigation of large portions of a system's execution from a software architectural view of the system. A developer is able to gain an understanding of how components in the architecture interact over time.


Figure 1 shows a screenshot of AVID visualizing part of the execution of the Eclipse integrated development environment. Boxes represent components, such as the JDK, a collection of core Eclipse components (RestOfCore), the functionality associated with refreshing a local directory (RefreshLocal), and remaining Eclipse components (RestOfEclipse). These components are defined by the user by describing a name for the component and by describing what packages, classes, methods, etc. in the execution contribute to each component. Black arrows represent the messages that have been sent between components. Colored arrows show the currently executing threads. The number of object allocations and deallocations to the point in the animation are shown in each component. The slider at the top can be used to position with the animation. The buttons are used to control the animation. The threadlist window shows the stack associated with each active thread.

Figure 1. AVID in action.

A developer may animate over execution information that is a combination of sampled and full-trace information. For instance, a developer may choose to sample the first part of the execution of a system as it is starting up, fully trace an important transaction sequence in the execution, and sample the remainder of the execution. The advantage of supporting interleaved sampled and full-trace information is that a developer can view a larger portion of the execution than they might otherwise be able because of the typical size of the full-trace information. Currently, AVID supports this interleaving of sampled and full-trace information by processing a full-trace of the system collected by the Jinsight tracer. This approach supports the investigation of the use of visualizing sampled data but it limits the scalability of the current tool because sampled information cannot be collected directly from the execution of the system.

A developer may investigate the details about messages between components, and object allocations and deallocations associated with a component, by clicking on an arc or bar in the animation view. The request for detailed information causes an appropriate slice to be defined in the Jinsight tool. The developer then has the full capabilities of Jinsight available to investigate the messages or objects.

As a result of viewing part of an animation, a developer may choose to redefine the components, or add or remove components into the view. These changes can be made during an animation by reloading a file that describes the components to use.

AVID was developed at the University of British Columbia in cooperation with OTI, Inc. as part of the Canadian Consortium for Software Engineering research (CSER).


Walker, Murphy, Steinbok, and Robillard. Efficient Mapping of Software System Traces to Architectural Views. CASCON '00.

Walker, Murphy, Freeman-Benson, Wright, Swanson, and Isaak. Visualizing Dynamic Software System Information through High-level Models. OOPSLA '98.


We are no longer actively developing AVID. For more information, please contact Gail Murphy.


AVID was developed at the University of British Columbia in cooperation with OTI, Inc. as part of the Canadian Consortium for Software Engineering research (CSER). A number of people have contributed to the ideas behind AVID, its first implementation in Smalltalk for Smalltalk and its current implementation in Java for Java.

Andrew Catton
Andrew Chan
Bjorn Freeman-Benson (OTI)
Thad Heinrichs
Reid Holmes
Thomas Jarecki
Jeremey Isaak (OTI)
Jeff McAffer (OTI)
Gail Murphy
Jeffrey Steinbok
Darin Swason (OTI)
Robert Walker
James Williams
Albert Wong
Darin Wright (OTI)
Annie Ying

Last updated: June 3, 2003