Poet: Target-System Independent Visualizations of Complex Distributed-Application Executions

Designing and implementing a visual debugger for distributed programs is a significant challenge. Distributed applications are often large and frequently exhibit a high degree of complexity. Consequently, a debugger must address problems of complexity and scale in at least two ways. First, appropriate user interfaces should allow a user to manage the vast amount of information typically obtained from distributed executions. Second, the tool itself, in handling this information, should be implemented efficiently, providing a user with reasonable response times for interactive use. Our research efforts, concentrating on these problems, have led to the development of Poet, a tool for the collection and presentation of event-based traces of distributed executions. Poet makes as few assumptions as possible about characteristics that must be possessed by all target environments. Information describing each target environment is placed in configuration files, allowing a single set of Poet executables to be used for all target environments. Comparing Poet's performance to XPVM, the standard visualization tool for PVM executions, reveals that this target-system independence does not impose a performance penalty.

[1]  M. Pernice,et al.  PVM: Parallel Virtual Machine - A User's Guide and Tutorial for Networked Parallel Computing [Book Review] , 1996, IEEE Parallel & Distributed Technology: Systems & Applications.

[2]  Thomas Kunz Reverse Engineering Distributed Applications: an Event Abstraction Tool , 1994, Int. J. Softw. Eng. Knowl. Eng..

[3]  Thomas Kunz,et al.  Using Automatic Process Clustering for Design Recovery and Distributed Debugging , 1995, IEEE Trans. Software Eng..

[4]  Theodore Y. Ts'o,et al.  Kerberos: an authentication service for computer networks , 1994, IEEE Communications Magazine.

[5]  Daniel M. Yellin,et al.  Hermes - a language for distributed computing , 1991, Prentice Hall series in innovative technology.

[6]  David J. Taylor,et al.  Visualizing PVM Executions , 1995 .

[7]  David J. Taylor,et al.  Performing replay in an OSF DCE environment , 1995, CASCON.

[8]  James Arthur Kohl,et al.  The PVM 3.4 tracing facility and XPVM 1.1 , 1996, Proceedings of HICSS-29: 29th Hawaii International Conference on System Sciences.

[9]  Wing Hong Cheung Process and event abstraction for debugging distributed programs , 1989 .

[10]  Dahlia Malkhi,et al.  Using visualization tools to understand concurrency , 1992, IEEE Software.

[11]  Peter C. Bates Debugging Heterogeneous Distributed Systems Using Event-Based Models of Behavior , 1995, ACM Trans. Comput. Syst..

[12]  Yi-Hsiu Wei,et al.  CONCERT: a high-level-language approach to heterogeneous distributed systems , 1989, [1989] Proceedings. The 9th International Conference on Distributed Computing Systems.

[13]  Guang R. Gao,et al.  ABC++: Concurrency by Inheritance in C++ , 1995, IBM Syst. J..

[14]  Colin J. Fidge,et al.  Logical time in distributed computing systems , 1991, Computer.

[15]  David J. Taylor The use of process clustering in distributed-system event displays , 1993, CASCON.

[16]  Dennis Taylor,et al.  Time and order of abstract events in distributed computations , 1994 .

[17]  Shivakant Mishra,et al.  Units of computation in fault-tolerant distributed systems , 1994, 14th International Conference on Distributed Computing Systems.

[18]  Gregory R. Andrews,et al.  An overview of the SR language and implementation , 1988, TOPL.

[19]  Twan Basten,et al.  Parsing Partially Ordered Multisets , 1997, Int. J. Found. Comput. Sci..

[20]  Janice E. Cuny,et al.  Initial experiences with a pattern-oriented parallel debugger , 1988, PADD '88.

[21]  Dennis Gannon,et al.  The characteristics of parallel algorithms , 1987 .

[22]  Thomas Kunz,et al.  Single stepping in event-visualization tools , 1996, CASCON.

[23]  Michiel F. H. Seuren,et al.  Design and Implementation of an Automatic Event Abstraction Tool , 1996 .

[24]  Peter A. Buhr,et al.  The μsystem: Providing light‐weight concurrency on shared‐memory multiprocessor computers running UNIX , 1990, Softw. Pract. Exp..

[25]  C. Q. Lee,et al.  The Computer Journal , 1958, Nature.

[26]  Thomas Kunz,et al.  Vector time and causality among abstract events in distributed computations , 1997, Distributed Computing.

[27]  Henry McGilton,et al.  The JavaTM Language Environment , 1998 .

[28]  J. Kundu,et al.  A scalable, visual interface for debugging with event-based behavioral abstraction , 1995, Proceedings Frontiers '95. The Fifth Symposium on the Frontiers of Massively Parallel Computation.

[29]  Dieter Kranzlmüller,et al.  Event graph visualization for debugging large applications , 1996, SPDT '96.

[30]  John T. Kohl,et al.  The Kerberos Network Authentication Service (V5 , 2004 .

[31]  Gail E. Kaiser,et al.  Modeling concurrency in parallel debugging , 1990, PPOPP '90.

[32]  Jack C. Wileden,et al.  An approach to high-level debugging of distributed systems (Preliminary Draft) , 1983, SIGSOFT '83.

[33]  James A. Gosling,et al.  The java language environment: a white paper , 1995 .

[34]  Stephen G. Eick,et al.  An interactive visualization for message sequence charts , 1996, WPC '96. 4th Workshop on Program Comprehension.

[35]  Leslie Lamport,et al.  Time, clocks, and the ordering of events in a distributed system , 1978, CACM.