No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
Voyeur: Graphical Views of Parallel Programs
Abstract
Voyeur is a prototype system that facilitates the construction of application-specific, visual views of parallel programs. These views range from textual views showing the contents of variables to graphical maps of the state of the computational domain of the program. These views have been instrumental in quickly detecting bugs that would have been difficult to detect otherwise.
... Incompatibility of the facilities for different parts of concurrent debugging forces the programmer to either use different facilities for different parts of the cycle or debug without them. Use of multiple representations for P, M and E typically compels the debuggers to either constrain the range of behaviors that can be checked [ReSc94]; or to tolerate the ambiguities in the observed behavior [EGP89], [HMW90], [NM91a]; or to demand extra programming effort [SBN89], [LMF90], [Bat89]. ...
... Animation facilities help in following the progress of execution "instantaneously" in each thread of control [HoC87], [PaU89], [HoC90], [SBN89], [ZeR91], [Ho91]. The focus of animation is mapping Ε to P. ...
... Animation facilities [HoC87], [PaU89], [McH89], [Ho91] provide an instantaneous view of the mapping of events of a time-process graph to a graphical structure. This, however, translates into extra effort for the user who must then develop a graphical structure that can support animation [HoC90], [SBN89], [Ho91], [ZeR91]. Such structures are, however, unable to support the visualization of the abstractions defined by the user. ...
Debugging is a process that involves establishing relationships between several entities: The behavior specified in the program, P, the model/predicate of the expected behavior, M, and the observed execution behavior, E. The thesis of the unified approach is that a consistent representation for P, M and E greatly simplifies the problem of concurrent debugging, both from the viewpoint of the programmer attempting to debug a program and from the viewpoint of the implementor of debugging facilities. Provision of such a consistent representation becomes possible when sequential behavior is separated from concurrent or parallel structuring. Given this separation, the program becomes a set of sequential actions and relationships among these actions. The debugging process, then, becomes a matter of specifying and determining relations on the set of program actions. The relations are specified in P, modeled in M and observed in E. This simplifies debugging because it allows the programmer to think in terms of the program which he understands. It also simplifies the development of a unified debugging system because all of the different approaches to concurrent debugging become instances of the establishment of relationships between the actions.
The unified approach defines a formal model for concurrent debugging in which the entire debugging process is specified in terms of program actions. The unified model places all of the approaches to debugging of parallel programs such as execution replay, race detection, model/predicate checking, execution history displays and animation, which are commonly formulated as disjoint facilities, in a single, uniform framework.
We have also developed a feasibility demonstration prototype implementation of this unified model of concurrent debugging in the context of the CODE 2.0 parallel programming system. This implementation demonstrates and validates the claims of integration of debugging facilities in a single framework. It is further the case that the unified model of debugging greatly
simplifies the construction of a concurrent debugger. All of the capabilities previously regarded as separate for debugging of parallel programs, both in shared memory models of execution and distributed memory models of execution, are supported by this prototype.
... De façon complémentaire, l'observation de l'exécution se concentre sur un instantané de l'exécution à un moment donné, et peut donc montrer plus d'informations. Celle−ci peut prendre différentes formes, adaptées aux particularités du système, et peut être animée pour montrer l'évolution de l'état de l'exécution (Hough [34], Socha [76], Jamrozik [38]). ...
... Différentes réalisations ont été effectuées, dont la plus simple consiste à faire conserver les événements par les processus de l'application eux−mêmes (Socha [76]). Une réalisation plus intéressante consiste à dissocier la détection des événements de leur sauvegarde, qui est alors réalisée par un processus différent de ceux mis en oeuvre par l'exécution (Tokuda [79]). ...
Our goal is to provide a debugging assistance for parallel and distributed applications based on persistent objects which allows cyclical debugging and offers a high level of abstraction for the observation of an execution. The nondeterminism and the probe effect of this kind of execution make bugs caused by race conditions difficult to correct. The limitations of both static analysis and dynamic approaches based on a current execution justify the choice of a debugging methodology based on replay, which solves the problem of nondeterminism by recording an execution. In this case the behavior of an incorrect execution is well known and can be visualised in specific views according to the particularities of the execution environment. In the context of object-oriented systems, we define a debugging record/replay (control driven) system based on the objects which allows cyclical debugging and object execution observation. The reexecution and the observation services are designed and integrated in a modular architecture. These concepts have been applied to the Guide system. A reexecuting kernel has been implemented using Guide objects, which automatically records and replays an execution.
... One of the first of the new generation of visualization tools to include the time-space diagram was the Voyeur [Socha et al. 1989] system, which provided a framework for defining various animation views for parallel algorithms. The TOP- SYS [Bemmerl and Braum 1993] environment includes various standard concurrency visualizations (called VISTOP) integrated with the debugging and performance analysis tools of the system, with time-space visualization being one of them. ...
... Visualizations of causal relations in the form of such time-space diagrams are currently quite standard in visualization and debugging platforms for parallel and distributed systems, and the number of such platforms is too large to allow discussing them all; we will just focus on a few of the noteworthy systems. One of the first of the new generation of visualization tools to include the time-space diagram was the Voyeur [Socha et al. 1989] system, which provided a framework for defining various animation views for parallel algorithms. The TOP- SYS [Bemmerl and Braum 1993] environment includes various standard concurrency visualizations (called VISTOP) integrated with the debugging and performance analysis tools of the system, with time-space visualization being one of them. ...
Abstract Causality visualization is an important tool for many scientic domains,that involve complex interactions between multiple entities (examples include parallel and distributed systems in computer science). However, traditional visualization techniques such,as Hasse diagrams,are not well-suited to large system executions, and users often have diculties answering even basic questions using them, or have to spend inordinate amounts of time to do so. In this paper we present the Growing Squares and,Growing Polygons methods, two sibling visualization techniques that were designed to solve this problem by providing ecien t 2D causality visualization through the use of color, texture, and animation. Both techniques have abandoned,the traditional linear timeline and instead map,the time parameter to the size of geometrical primitives representing the processes; in the Growing Squares case, each process is a color-coded square that receives color inuences,from other process squares as messages reach it; in the Growing Polygons case, each process is instead an n-sided polygon consisting of triangular sectors showing color-coded inuences,from the other processes. We have performed user studies of both techniques, comparing them with Hasse diagrams, and they have been shown,to be signican tly more,ecien t than old techniques, both in terms of objective performance as well as the subjective opinion of the test subjects (the Growing Squares technique is, however, only signican tly more ecien t for small systems). Keywords: causal relations, information visualization, in-
... Trace Visualization Trace visualizations are often applied in support of understanding parallel programs [17,33,35]. Often, trace visualizations leverage icicle plots and flame graphs as the primary visual representation [5,12,17,28,35]. ...
... Trace Visualization People have tried to provide assistance in program understanding by visualizing program traces. Many of these visualizations are designed for view traces of parallel programs [24,37,41]. There also exists a significant body of trace visualizations that use icicle plots and flame graphs as the primary visualization [7,17,24,33,41]. ...
Understanding and debugging long, complex programs can be extremely difficult; it often includes significant, manual program instrumentation and searches through source files. In this paper, we present Anteater, an interactive visualization system for tracing and exploring the execution of a program. While existing debugging tools often have visualization components, these components are often added on top of an existing environment. In Anteater, in contrast, visualization is a driving concern. We answer the following question: what should a debugging tool look like if it were designed from the ground up to support interactive visualization principles? Anteater automatically instruments source code to capture execution behavior along with variables and expressions specified by the user. After generating the execution trace, Anteater presents the execution information through interactive visualizations. Anteater supports interactions that help with tasks such as discovering important structures in the execution, learning dependencies, and understanding and debugging unexpected behaviors. To assess the utility of Anteater, we present several real-world case studies that show how Anteater compares favorably to existing approaches. Finally, we discuss limitations of our system and where further research is needed.
... For a general overview of the field, see [2, 10, 16, 17, 18, 32, 35]. Early work that inspired or influenced the initial development of ParaGraph includes [3, 20, 21, 24, 25, 26, 31, 34]. The original version of ParaGraph was developed during the period 1989–1991 [11, 12, 13]; its further evolution is described in [14, 15]. ...
ParaGraph is a graphical display tool for visualizing the behavior and performance of parallel programs that use MPI (Message-Passing Interface). The visual animation of a parallel program is based on execution trace information gathered during an actual run of the program on a message-passing parallel computer system. The resulting trace data are replayed pictorially to provide a dynamic depiction of the behavior of the parallel program, as well as graphical summaries of its overall performance. The same performance data can be viewed from many dierent visual perspectives to gain insights that might be missed by any single view. We describe the visualization tool, discuss the motivation and philosophy behind its design, and provide details on how to use it.
... In the simplest BEE configuration, the event interpreter and the client share the same address space (see figure 4) and the event interpreter functions are called directly by the client This architecture is used in many early debuggers. If the local event interpreter is a separate thread such as in figure 5, it models the architecture used by the PARASIGHT debugger [1]. Figure 6 shows a client connected to several event interpreters, each of them tapping on the same event stream, but providing different views of the behavior [17,19]. The different event interpreters can either be on the same node or on different nodes. ...
... This way, complex or huge data sets can be examined easily. Similar capabilities are offered by [14][15][16][17]. Our data-visualisation tool differs from these however by its 'open' approach and its ease of use. ...
In this paper, we describe the process-level debugger of GRAPE, our hierarchical graphical programming environment for concurrent programs. Its unique feature is that it clearly separates the identification of erroneous processes, which we call process-level debugging, from the exact localisation of the bug at the source-level. This divide-and-conquer approach is absolutely necessary for debugging complex parallel programs in a fast and systematic way. Our process-level debugging approach is based on an animation of the program's behaviour on its hierarchical graphical representations. Graphical views are used that reflect the programmer's mental picture of the actual application. Hierarchy allows us to employ a top-down debugging approach in which we successively refine the search-space by zooming in on suspect processes first-time-right. During animation a debugging kernel implementing a record-replay mechanism guarantees reproducible behaviour.
... The need for support tools to analyse the dynamics of parallel computations is evident. Literature reviews show that most of the systems under development aim at processes 11,3,8] and do not exploit graphics 12,8,7]. To extract the maximum performance from processor networks, study of hardware's run-time needs to be addressed. ...
This paper presents Maritxu, a visualisation system developed to aid in theunderstanding and optimisation of highly parallel computer systems. Maritxuimplements a new visualisation paradigm, combining the use of colour, algorithmanimation and visual overload. Maritxu adopts an integral approachto Parallel Computing by emphasising the role of the processor (rather thanprocess) in performance optimisation. There are no constraints to the visualisation:network size, topology, subnetworks,...
... This straightforward method is currently found in many platforms for visualization and debugging, especially those aimed at parallel and distributed systems. In fact, too many such platforms exist for us to mention them all; examples include [Socha et al. 1989; Bemmerl and Braum 1993; Moses et al. 1998; Koldehofe et al. 1999; Kraemer and Stasko 1998; Heath 1990; Heath and Etheridge 1991; Topol et al. 1998; Stasko and Kraemer 1993]. While Hasse diagrams certainly are in widespread use, they have a number of deficiencies that lower their usefulness for realistic systems. ...
We present Growing Polygons, a novel visualization technique for the graphical representation of causal relations and information flow in a system of interacting processes. Using this method, individual processes are displayed as partitioned polygons with color-coded segments showing dependencies to other processes. The entire visualization is also animated to communicate the dynamic execution of the system to the user. The results from a comparative user study of the method show that the Growing Polygons technique is significantly more efficient than the traditional Hasse diagram visualization for analysis tasks related to deducing information flow in a system for both small and large executions. Furthermore, our findings indicate that the correctness when solving causality tasks is significantly improved using our method. In addition, the subjective ratings of the users rank the method as superior in all regards, including usability, efficiency, and enjoyability.
... Visualizations of causal relations in the form of such time-space diagrams are currently quite standard in visualization and debugging platforms for parallel and distributed systems, and the number of such platforms is too large to allow mentioning them all. One of the first of the new generation of visualization tools to include the time-space diagram was the Voyeur [Socha et al. 1989] system, which provided a framework for defining various animation views for parallel algorithms. The TOPSYS [Bemmerl and Braum 1993] environment includes various standard concurrency visualizations integrated with the debugging and performance analysis tools of the system , with time-space visualization being one of them. ...
We present a novel information visualization technique for the graphical representation of causal relations, that is based on the metaphor of color pools spreading over time on a piece of paper. Messages between processes in the system affect the colors of their respective pool, making it possible to quickly see the influences each process has received. This technique, called Growing Squares, has been evaluated in a comparative user study and shown to be significantly faster and more efficient for sparse data sets than the traditional Hasse diagram visualization. Growing Squares were also more efficient for large data sets, but not significantly so. Test subjects clearly favored Growing Squares over old methods, naming the new technique easier, more efficient, and much more enjoyable to use.
... Work in this area is numerous but peripheral to the system described in this paper; examples include [3, 4, 5, 7, 19]. Timelines, like the Newton's Shoulders visualization in CiteWiz, have been widely used for applications like personal histories [28] , time-space diagrams for distributed sys- tems [33, 1], and scientific publication analysis such as for research fronts [26] and historiographs [16]. Our approach provides an interactive and linked view that integrates well with the other visualizations in the CiteWiz system. ...
We present CiteWiz, an extensible framework for visualization of scientific citation networks. The system is based on a taxonomy of citation database usage for researchers, and provides a timeline visualization for overviews and an influence visualization for detailed views. The timeline displays the general chronology and importance of authors and articles in a citation database, whereas the influence visualization is implemented using the Growing Polygons technique, suitably modified to the context of browsing citation data. Using the latter technique, hierarchies of articles with potentially very long citation chains can be graphically represented. The visualization is augmented with mechanisms for parent–child visualization and suitable interaction techniques for interacting with the view hierarchy and the individual articles in the dataset. We also provide an interactive concept map for keywords and co-authorship using a basic force-directed graph layout scheme. A formal user study indicates that CiteWiz is significantly more efficient than traditional database interfaces for high-level analysis tasks relating to influence and overviews, and equally efficient for low-level tasks such as finding a paper and correlating bibliographical data.
... Users display this data through an external graphics program. Voyeur [7] and POLKA [8] offer object-oriented tools for designing program views. Users model elements of a display as objects with specific interfaces and capabilities . ...
An extensible parallel debugger helps programmers create new views
of their programs' behavior. This paper describes the features of the
Panorama parallel debugger that programmers can use to design a variety
of specialized debugging views. A graphical tool for designing elements
of a display simplifies the most tedious steps in creating program
views. Programmers can incorporate these new views into Panorama using a
modest amount of code
... The need for support tools to analyse the dynamics of parallel computations is evident. Literature reviews show that most of the systems under development aim at processes 11,3,8] and do not exploit graphics 12,8,7]. To extract the maximum performance from processor networks, study of hardware's run-time needs to be addressed. ...
This paper presents Maritxu, a visualisation system developed to aid in the understanding and optimisation of highly parallel computer systems. Maritxu implements a new visualisation paradigm, combining the use of colour, algorithm animation and visual overload. Maritxu adopts an integral approach to Parallel Computing by emphasising the role of the processor (rather than process) in performance optimisation. There are no constraints to the visualisation: network size, topology, subnetworks, icon shapes, data mapping, statistics, etc. can all be interactively defined by the user. An example of performance enhancement in a practical transputer-based EMC application is included. 1 Introduction In the last few years parallel processing has become a reality affordable to many companies and institutions. Parallel processing promises enormous power at a cost - understanding. Parallel computations involve highly complex and little understood behaviour. This lack of understanding prevents eff...
Актуальность. В условиях глобальной цифровизации, когда становятся актуальными такие проекты, как цифровая земля, компьютерная визуализация является важным элементом компьютерного моделирования как в научных исследованиях, так и в технике, в частности, в областях геоинформатики, природо- и недропользования, исследования георесурсов. Также компьютерная визуализация необходима при представлении «больших данных», например, накопленных в результате геологических исследований больших пространств. Компьютерная визуализация как самостоятельная дисциплина развивается уже более тридцати лет. В настоящее время в компьютерной визуализации активно используются средства виртуальной реальности, которые и оперируют геопространственными данными. Виртуальная реальность может использоваться при представлении данных о Земле. Возможно создание трёхмерных отображений графических объектов, представляющих элементы ландшафта. Одной из подобластей компьютерной визуализации является визуализация программного обеспечения (Software Visualization). Визуализация программного обеспечения необходима при представлении сложных программных комплексов, связанных с проектированием и разработкой в различных областях техники, включая энергоэффективные технологии. Объекты. Работа посвящена исследованиям и разработкам в области визуализации программного обеспечения на базе виртуальной реальности. Эти исследования могут применяться в целом ряде областей, связанных с геоинформатикой, а также в области исследования георесурсов. Методы: методы теории компьютерной визуализации, а именно элементы теории метафоры визуализации. Цель: поиск подходов, позволяющих эффективно использовать виртуальную реальность для решения сложных проблем, встающих перед специалистами в области программного обеспечения, связанного с большими объёмами сложно структурированных данных, в том числе больших геопространственных данных. Результаты. Проведен обзор развития визуализации программного обеспечения и описаны проекты в данном направлении, разработанные за последние десятилетия. Приводятся разработанные авторами проекты систем визуального программирования и визуализации программного обеспечения на базе виртуальной реальности с использованием метафор космического пространства и расширенной метафоры города. Рассматриваются психологические аспекты человеческого фактора в разработке систем визуализации программного обеспечения с использованием виртуальной реальности, включая использование теории деятельности. Возникает проблема описания деятельности программиста в качестве пользователя систем визуализации программного обеспечения. Разработка программного обеспечения для реальных технических задач, например для нужд инженерной геологии или прогнозирования георесурсов, требует специализации, а то и персонализации визуальных систем. В результате проведенного анализа можно заключить, что мы находимся на первых этапах важных исследований.
The problem of debugging parallel and distributed applications provides a framework for research in the fields of static analysis of distributed programs, observation of distributed computations, detection of distributed properties and post-mortem analysis. We have been particularly interested in this last field during the design and implementation of the CDB tool for the CHORUS micro-kernel operating system. CDB provides and execution replay facility to record and then replay the execution of complex distributed applications running on top of CHORUS, thus enabling cyclic debugging for non-deterministic distributed programs. The use of CDB is transparent to the re-executed application (no instrumentation is necessary.) CDB uses modern techniques, such as interposition, instruction counting, causal diffusion, logical clocks... We describe the CHORUS kernel enhancements developed to support execution replay, the algorithms (some are original) used by CDB, CDB's user interface and its performance.
: : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : ix 1 Introduction : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 1 1. Background : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 1 2. Problems in developing parallel debuggers : : : : : : : : : : : : : : : : 3 1. Quantity of state information : : : : : : : : : : : : : : : : : : : : : 3 2. Nondeterminism : : : : : : : : : : : : : : : : : : : : : : : : : : : : 4 3. Architectural variation : : : : : : : : : : : : : : : : : : : : : : : : : 5 3. Related work : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 5 1. Program replay : : : : : : : : : : : : : : : : : : : : : : : : : : : : 5 2. Visualization : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 8 3. Extensibility : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 11 4. Portability : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 13 4. Goals of this research : : : : : : : : : : : : : ...
This paper describes an architectural framework for virtually transparent monitoring of massively-parallel computers, which combines the principle of permanent probe monitoring with generic architectural models of the monitor, and the target parallel system. A virtually transparent monitor is one in which probe effects — namely, those effects which cause a monitored program to behave differently from the same, but unmonitored one — are effectively masked at the programming level. Permanent probe monitoring is a technique for realising virtual transparency, by allowing the software monitoring probes to remain permanently active within the target parallel system. The generic monitoring architecture introduced in the paper encompasses the description of a wide range of systems ranging from simple centralised monitors to highly-distributed ones. The framework has been validated and evaluated through the experimental realisation of a message communication monitor (Monitorix) in which the target system is a token-ring message router (Routix) for a transputer-based multiprocessor. Experimental results have shown the system to be reasonably efficient.
We present a unifying view of visualization in which comprehensive support for software, algorithm, process and application (including scientific) visualizations is treated as an essential component of the computing environment. We describe our recent work toward making this view a reality: a tool for computer-assisted design of visualizations and a technique for monitoring a computational process in a non-invasive fashion.
Developing a distributed debugger is much more complex than developing a sequential debugger. This added complexity is mainly due to the non-determinism of events that communication delays introduce into distributed systems. We explore the problems that one must address when designing a distributed program debugger and then describe our design and implementation of DPD (distributed program debugger). Problems addressed include non-determinism of events, finding consistent system states, setting breakpoints, recording events, and checkpointing. Important features of DPD include dynamic roll back and replay, as well as a graphical user interface. DPD has been tested successfully in debugging distributed programs within a distributed facility called REM (remote execution manager).
To understand a parallel program's execution we must be able to analyze lots of information describing complex relationships among many processes. Various techniques have been used, from program replay to program animation, but each has limited applicability and the lack of a common foundation precludes an integrated solution. Our approach to parallel program analysis is based on a multiplicity of views of an execution. We use a synchronization trace captured during execution to construct a graph representation of the program's behavior. A user manipulates this representation to create and fine-tune visualizations using an integrated, programmable toolkit. Additional execution details can be recovered as needed using program replay to reconstruct an execution from an existing synchronization trace. We present a framework for describing views of a parallel program's execution, and an analysis methodology that relates a sequence of views to the program development cycle. We then describe our toolkit implementation and explain how users construct visualizations using the toolkit. Finally, we present an extended example to illustrate both our methodology and the power of our programmable toolkit.
This paper reports on the initial stages of a research project involving the development of an experimental parallel computing system. The system is intended to support research in a variety of areas, including computer architectures, task models, language implementations and interconnection techniques. A pragmatic approach is being undertaken to evaluating techniques in these areas through applying the system to actual applications.The system is based on a hierarchical structure of processors, using shared memory as the communication medium. This paper identifies the main features of the hardware being used, and presents an outline of the initial software for task creation and management.
This paper investigates the visualization of distributed algorithms. We present a conceptual model and a system, VADE, that realizes this model. Since in asynchronous distributed systems there is no way of knowing (let alone, visualizing) the “real” execution, we show how to generate a visualization which is consistent with the execution of the distributed algorithm. We also present the design and implementation of our system. VADE is designed so that the algorithm runs on the server's machines while the visualization is executed on a web page on the client's machine. Programmers can write animations quickly and easily with the assistance of VADE's libraries. End-users can experiment with the animation and change its visual properties.
Graphical representations of a program execution (also called visualization) have been shown to be useful to understand the behavior of parallel programs. Visualization of an execution is generally done off-line, using an adequate trace generated during execution. However, during the debugging phase, such representations may turn out to be insufficient: use of a symbolic debugger may also be required. The goal of this paper is to show that execution replay is the basic component that must be used to integrate a symbolic debugger with a visualization tool. Such an integration allows a simultaneous use of both tools during an execution, leading to an ideal observation of the execution: low level observation thanks to the debugger, and high level observation thanks to the visualization. This new approach has been implemented for parallel programs running on an iPSC/2.
Techniques that manipulate logical time in order to produce coherent animations of parallel program behavior despite the presence of asynchrony are presented. The techniques interpret program behavior in light of user-defined abstractions and generate animations based on a logical, rather than a physical, view of time. If this interpretation succeeds, the resulting animation is easily understood. If it fails, the programmer can be assured that the failure was not an artifact of the visualization. It is shown that these techniques can be generally applied to enhance visualizations of a variety of types of data as they are produced by parallel, MIMD (multiple instruction stream, multiple data stream) computations
Conceptual ideas are developed to provide algebraic specifications with animation, i.e. graphics — possibly moving — of datas and their operations.
We are convinced that animation
helps to understand algebraic specifications easier
supports error detection
supports the operational view
and improves the acceptance of specifications.
In our theory we emphasize the connection between building the terms of a specification and visualizing this term. To achive this we assign to every constant in the signature of the specification SPEC = (SIG,E) a graphic and to every operation in SIG instructions, how to manipulate the argument graphs. The assignment between terms and graphs is realized as an implementation, especially a graphical implementation by so called basic graphic algebra BaGrA, where all the graphical basic operations like linedrawing etc. and other types, are collected. The graphical implementation is compatible with the actualization of parameterized specifications. An example is given to visualize our ideas of animation.
A new design process for the development of parallel performance visualizations that uses existing scientific data visualization software to prototype new performance visualizations can lead to drastic reductions in the graphics and data manipulation programming overhead currently experienced by performance visualization developers. The process evolves from a formal methodology relating performance abstractions to visual representations under which performance visualizations are described as mappings from performance objects to view objects, independent of any graphical programming. This prototyping environment also facilitates iterative design and evaluation of new and existing displays. Our work examines how an existing data visualization tool can provide a robust prototyping environment for next-generation parallel performance visualizations.
This paper describes the design and implementation ofPanorama, a parallel debugger for MIMD message-passing computers. Programmers can readily adapt Panorama to new parallel platforms and extended it to include their ownviewsof a target program. The system comes with three built-in graphical program views, and it also includes a software tool to help programmers design and implement new views. Panorama avoids detailed dependence on target architectures by using thebase debuggersupplied by each hardware vendor to carry out low-level debugging tasks such as setting breakpoints and examining data. Since the interfaces and capabilities of base debuggers vary, we have developed a strategy that models interactions between Panorama and base debuggers. The model separates general-purpose code from the special-case functions that handle specific debugger characteristics. The resulting system is easy to adapt and free from the clutter of conditionally-executed, special-case code.
Execution monitors are widely used during software development for tasks that require an understanding of program behavior, such as debugging and profiling. The Icon programming language has been enhanced with a framework that supports execution monitoring. Under the enhanced translator and interpreter, neither source modification nor any special compiler command-line option is required in order to monitor an Icon program. Execution monitors are written in the source language, instead of the implementation language. Performance, portability, and detailed access to the monitored program's state are achieved using a coroutine model and dynamic loading rather than the separate-process model employed by many conventional monitoring systems.
A bibliography of over three hundred technical reports, journal and conference papers, and Ph.D. dissertations dealing with parallel and distributed debuggers. Treatments of programming environments, debugging methodology, and techniques for program analysis are included when a significant portion of the publication is devoted to factors influencing the design or implementation of debugging tools.
Network computing has evolved into a popular and effective mode of high performance computing. Network computing environments have fundamental differences from hardware multiprocessors, involving a different approach to measuring and characterizing performance, monitoring an application's progress and understanding program behavior. In this paper, we present the design and implementation of PVaniM, an experimental visualization environment we have developed for the PVM network computing system. PVaniM supports a two-phase approach whereby on-line visualization focuses on large-grained events that are influenced by and relate to the dynamic network computing environment, and postmortem visualization provides for detailed program analysis and tuning. PVaniM's capabilities are illustrated via its use on several applications and a comparison with single-phase visualization environments developed for network computing. Our experiences indicate that, for several classes of applications, the two-phase visualization scheme can provide valuable insight into the behavior, efficiency and operation of distributed and parallel programs in network computing environments. © 1998 John Wiley & Sons, Ltd.
Recently the need for extreme scale computing solutions presents demands for powerful and easy to use performance visualization
tools. This paper presents a review of existing research on performance visualization for large-scale systems. A general approach
to performance visualization is introduced in relation to performance analysis, and issues that need to be addressed throughout
the performance visualization process are summarized. Then visualization techniques from 21 performance visualization systems
are reviewed and discussed, with the hope of shedding light on the design of visualization tools for ultra-large systems.
The paper investigates the visualization of distributed
algorithms. We present a conceptual model and a system, VADE, that
realizes this model. Since in asynchronous distributed systems there is
no way of knowing (let alone, visualizing) the “real”
execution, we show how to generate a visualization which is consistent
with the execution of the distributed algorithm. We also present the
design and implementation of our system. VADE is designed so that the
algorithm runs on the server's machines while the visualization is
executed on a Web page on the client's machine. Programmers can write
animations quickly and easily with the assistance of VADE's libraries
Event-based behavioral abstraction, in which models of intended
program behavior are compared to actual program behavior, offers
solutions to many of the debugging problems introduced by parallelism.
Currently, however, its widespread application is limited by an
inability to provide sufficient feedback on the mismatches between
intended and actual behaviors, and an inability to provide output that
scales for large or complex systems. The AVE/Ariadne debugging system
was developed to address these limitations. Ariadne is a post mortem
debugger that combines a simple modeling language with functional
queries to support thorough exploration of execution traces. AVE is a
visual interface to Ariadne that provides scalable, visual feedback. AVE
features hierarchical visualizations that reflect the structure of
user-defined behavioral models, dynamic attribute calculation, and
automatic partitioning of matched behaviors and attributes
Developing robust techniques for visualizing the performance
behavior of parallel programs that can scale in problem size and/or
number of processors remains a challenge. We present several performance
visualization techniques based on the context of data-parallel
programming and execution that demonstrate good visual scalability
properties. These techniques are a result of utilizing the structural
and distribution semantics of data-parallel programs as well as
sophisticated three-dimensional graphics. A categorization and examples
of scalable performance visualizations are given for programs, written
in Dataparallel C and pC++
We present PDG, a debugger that allows one to identify erroneous processes without examining the source-level. Instead the interactions between processes are examined by animating program behaviour. For this, we use hierarchical graphical representations that are constructed during top-down program development. During animation, a debugging kernel implementing a record-replay mechanism guarantees reproducible program behaviour. To minimise interference, we are developing a tracing mechanism that decides at run-time which messages are to be traced to guarantee reproducibility. The run-time debugging kernel provides portability by supporting standard portable communication calls. In addition, the kernel itself is easy to port, since all architecture and communication-protocol dependent functionality is clearly separated from the generic debugging functionality.< >
The authors describe a high level language for specifying programming environments for programming languages that are based on directed attributed graphs. The high level language allows the specifier to describe views of portions of a program written in such a graph-based language, the editing operations used to create the program, animations of the execution of the program, and sufficient detail of the execution semantics to support the animations. The use of the specification language is demonstrated with a simple example of a graph-based language. The automatic generation of the programming environment is described for such graph based languages from descriptions made in the specification language. The specification language is based on using a grammar to describe the components of the graph based language and using a first-order logic based language to describe state changes in editing, execution, and animation
The authors describe the process-level debugger of GRAPE, an
environment for the rapid prototyping of digital signal processing
systems on parallel computers. This debugger allows one to debug
concurrent programs that are based on communicating sequential
processes. Its unique feature is that it clearly separates the
identification of erroneous processes from the exact localisation of the
bug on the source-level. This divide-and-conquer approach is absolutely
necessary for debugging complex parallel programs in a fast and
systematic way, which is a key issue for rapid prototyping. The
process-level debugging approach is based on an animation of program
behaviour on its hierarchical graphical representation. Graphical views
are used that reflect the programmer's mental picture of the
application. Hierarchy allows one to employ a top-down debugging
approach in which one successively refines the search-space by zooming
in on suspect processes first-time-right. They consider both hierarchy
that hides algorithmic details, and hierarchy that hides implementation
issues. During animation a debugging kernel implementing a record-replay
mechanism guarantees reproducible program behaviour even for programs
containing asynchronisities
As more sophisticated tools for parallel programming become
available, programmers will inevitably want to use them together.
However, some parallel programming tools can interact with each other in
ways that make them less useful. In particular, it a mapping tool is
used to adapt a parallel program to run on relatively few processors,
the information presented by a debugger may become difficult to
interpret. The authors examine the problems that can arise when
programmers use debuggers to interpret the patterns of message traffic
in mapped parallel programs. They also suggest how to avoid these
problems and made debugging tools more useful
The author outlines the requirements for debugger visualizations and describes the difficulties involved in devising graphical techniques which reduce the complexity of parallel behavior to manageable proportions. Examples are presented which demonstrate that visualization techniques can elucidate several aspects of run-time behavior. In this sense, they can improve the usefulness of parallel debugging tools: the application of specialized representational schema facilitates the recognition of patterns which would be hidden in any textual report. This allows the human programmer, adept at identifying visual anomalies, to isolate behavioral problems more quickly and accurately.< >
A software visualization tool is described that transforms program
execution trace data from a multiprocessor into a single, color image.
The image is essentially the program's logical procedure-invocation
tree, displayed radially from the root. An algorithm is described that
condenses the image both radially and laterally, producing a color-dense
abstraction of the program's execution behavior: a program signature,
within a workstation window. An implementation of the tool was made in
X-Windows, including a user interface that can zoom the image and
annotate any node in the image with the corresponding
procedure-invocation data. Experimentation with the system was performed
with trace data from Panda, a concurrent logic programming system on
shared-memory multiprocessors. The authors demonstrate how the tool
helps the programmer develop intuitions about parallel performance and
how condensation successfully abstracts very large traces
Programmers who want to do network computing face several
challenges: the network and attached systems are shared resources with
an unpredictable behavior and network communication primitives are often
hard to use. The programming environment developed for the Nectar system
addresses both problems. It provides simple and efficient communication
primitives, and an efficient monitoring kernel that allows both
programmers and programming tools to monitor the behavior of the program
in the dynamic network environment. Experience shows that monitoring the
progress of applications interactively is both desirable and practical
Although parallel programs are significantly more complex than
sequential programs the same debugging methodology, augmented with the
appropriate tools, can be used to debug parallel and sequential
programs. Experiments have shown that these tools can reduce the
debugging cycle for a parallel program dramatically. Other techniques,
such as verification and testing, can be integrated with the debugging
methodology. For example, static analysis can be used to discover
erroneous race conditions. Verification can be used to narrow the search
space for errors during monitoring and debugging. Nonetheless, debugging
remains the most widely used technique for developing correct parallel
programs
Chitra analyzes a program execution sequence (PES) collected
during execution of a program and produces a homogeneous, semi-Markov
chain model fitting the PES. The PES represents the evolution of a
program state vector in time. Therefore Chitra analyzes the
time-dependent behavior of a program. The authors describe a set of
transforms that map a PES to a simplified PES. Because the transforms
are program-independent. Chitra can be used with any program. Chitra
provides a visualization of PESs and transforms, to allow a user to
visually guide transform selection in an effort to generate a simple yet
accurate semi-Markov chain model. The resultant chain can predict
performance at program parameters different than those used in the input
PES, and the chain structure can diagnose performance problems
It is suggested that a functional model of monitoring in terms of the generation, processing, dissemination, and presentation of information can help determine the facilities needed to design and construct distributed systems. Implementation issues are also discussed, with attention given to the intrusiveness of monitoring systems and object-based implementation. It is concluded that generic monitoring services are important tools for managing distributed systems and for debugging during system development. Monitoring services may also be needed as part of the application itself, such as in process control and factory automation.< >
The Time Warp Operating System (TWOS) runs discrete event simulations on parallel hardware using an optimistic synchronization method based on rollback and message cancellation. Developing this system caused many difficult debugging problems, both because of its unique method of operation and general problems of developing a distributed system. This paper describes some of the techniques used to debug TWOS. These techniques include debuggers built into the operating system, logging methods, graphical tools, internal statistics, special-purpose applications, and monitors. In addition, TWOS has an important property that aids in debugging -- simulations run under TWOS must produce deterministic results from run to run. The paper discusses how this property proved useful for debugging both TWOS and the applications run on it. 1. Introduction The Time Warp Operating System (TWOS) is a special purpose operating system designed to run discrete event simulations in parallel with the primary...
The enormous quantities of trace data available to the user of parallel systems overwhelms most traditional data presentation approaches. This paper proposes a model that combines visual and audio stimuli to organise and present data. The psychological basis for this model is presented, and the implications for applicability and implementation explored. A practical implementation of this model Maritxu is introduced. Maritxu focuses on the presentation of the run-time behaviour of networks of parallel processors. It provides the user with total control over the visualisation process, and as such is an ideal tool for both analysis and experiment. The paper concludes by examining the effectiveness of this approach when used to analyse real data. Recommendations for further development of the model in relation to this implementation are presented and discussed. 1. Introduction The development of information technology has generated an enormous "appetite" for data, covering all areas of m...
The proliferation of graphical user interfaces has had a dramatic impact on the ability to work as a programmer. It is particularly difficult for the blind to create forms for visual programming applications, such as Visual Basic. A scripting language is introduced that enables the blind to create Visual Basic forms without needing to specify a great deal of detail and without needing the "point and click" approach that they cannot use. Related issues of accommodating the blind in a computer science course are also discussed.
The debugging cycle is the most common methodology for finding and correcting errors in sequential programs. Cyclic debugging is effective because sequential programs are usually deterministic. Debugging parallel programs is considerably more difficult because successive executions of the same program often do not produce the same results. In this paper we present a general solution for reproducing the execution behavior of parallel programs, termed Instant Replay. During program execution we save the relative order of significant events as they occur, not the data associated with such events. As a result, our approach requires less time and space to save the information needed for program replay than other methods. Our technique is not dependent on any particular form of interprocess communication. It provides for replay of an entire program, rather than individual processes in isolation. No centralized bottlenecks are introduced and there is no need for synchronized clocks or a globally consistent logical time. We describe a prototype implementation of Instant Replay on the BBN Butterfly™ Parallel Processor, and discuss how it can be incorporated into the debugging cycle for parallel programs.
SDEF, a systolic array programming system, is presented. It is intended to provide 1) systolic algorithm researchers/developers with an executable notation, and 2) the software systems community with a target notation for the development of higher level systolic software tools. The design issues associated with such a programming system are identified. A spacetime representation of systolic computations is described briefly in order to motivate SDEF’s program notation. The programming system treats a special class of systolic computations, called atomic systolic computations, any one of which can be specified as a set of properties: the computation’s 1) index set (S), 2) domain dependencies (D), 3) spacetime embedding (E), and nodal function (F). These properties are defined and illustrated. SDEF’s user interface is presented. It comprises an editor, a translator, a domain type database, and a systolic array simulator used to test SDEF programs. The system currently runs on a Sun 3/50 operating under Unix and Xwindows. Key design choices affecting this implementation are described. SDEF is designed for portability. The problem of porting it to a Transputer array is discussed.
PRESTO is a programming system for writing object‐oriented parallel programs in a multiprocessor environment. PRESTO provides the programmer with a set of pre‐defined object types that simplify the construction of parallel programs. Examples of PRESTO objects are threads, which provide fine‐grained control over a program's execution, and synchronization objects, which allow simultaneously executing threads to co‐ordinate their activities.
The goals of PRESTO are to provide a programming environment that makes it easy to express concurrent algorithms, to do so efficiently, and to do so in a manner that invites extensions and modifications. The first two goals, which are the focus of this paper, allow a programmer to use parallelism in a way that is naturally suited to the problem at hand, rather than being constrained by the limitations of a particular underlying kernel or hardware architecture. The third goal is touched upon but not emphasized in this paper.
PRESTO is written in C++; it currently runs on the Sequent shared‐memory multiprocessor on top of the Dynix operating system. In this paper we describe the system model, its applicability to parallel programming, experiences with the initial implementation, and some early performance measurements.
A constraint describes a relation that must be maintained. Constraints provide a useful mechanism to aid in the construction of interactive graphical user interfaces. They can be used to maintain consistency between data and a view of the data, to maintain consistency among multiple views, to specify layout, and to specify relations between events and responses for describing animations of interactive systems and event-driven simulations. Object-oriented techniques for constraint representation and satisfaction are presented, and a range of examples that demonstrate the practical use of static and temporal constraints for such purposes is presented. These examples include animations of algorithms and physics simulations, and constructing user-interface elements such as file browsers, views onto statistical data, and an interactive monitor or a simulated operating system.
The programming language aspects of a graphic simulation laboratory named ThingLab are presented. The design and implementation of ThingLab are extensions to SmaUtalk. In ThingLab, constraints are used to specify the relations that must hold among the parts of the simulation. The system is object-oriented and employs inheritance and part-whole hierarchies to describe the structure of a simulation. An interactive, graphic user interface is provided that allows the user to view and edit a simulation.
This paper describes the PECAN family of program development systems. PECAN supports multiple views of the user's program. The views can be representations of the program or of the corresponding semantics. The primary program view is a syntax-directed editor. The current semantic views include expression trees, data type diagrams, flow graphs, and the symbol table. PECAN is designed to make effective use of powerful personal machines with high-resolution graphics displays and is currently implemented on APOLLO workstations.
The programming language as-pects of ThingLab, a constraint-oriented simula-tion laboratory. A CM Transactions on Program-ming Language Systems opment systems that support multiple views PECAN: Program devel-The X
- Alan Borning
- P Steven
- Reiss
Alan Borning. The programming language as-pects of ThingLab, a constraint-oriented simula-tion laboratory. A CM Transactions on Program-ming Language Systems, 3(4):353-387, October 1981. [13] Steven P. Reiss. opment systems that support multiple views. IEEE Transactions on Software Engineering, SE-11(3):276-285, March 1985. [14] R. W. Scheifier and J. Gettys. PECAN: Program devel-The X win-
The simple code Lawrence Livermore Laboratory, Febru-ary 1987. [16] Lawrence Snyder. Parallel programming and the Poker programming environment [17] Robert L. Young. An object-oriented frame-work for interactive data graphics
- W P Crowley
- C P Hendrickson
- T L Day
W. P. Crowley, C. P. Hendrickson, and T. L. Day. The simple code. Technical Report UCID- 17715, Lawrence Livermore Laboratory, Febru-ary 1987. [16] Lawrence Snyder. Parallel programming and the Poker programming environment. IEEE Coin-puter, 17(7):27-36, July 1984. [17] Robert L. Young. An object-oriented frame-work for interactive data graphics. Proceedings of 1987 Object-Oriented Programming Systems, Languages, and Applications, pages 78-90, Oc-tober 1987.
Constraintdow system ACM Transactions on Graphics, based tools for building user interfaces
- Alan Borning
- Robert Duisberg
Alan Borning and Robert Duisberg. Constraintdow system. ACM Transactions on Graphics,
based tools for building user interfaces. ACM
5(2):79-109, April 1986.
Transactions on Graphics, 5(4):345-374, October 1986.
(151 Randal B. Smith. The alternate reality kit:
An animated environment for creating
SIMPLE, an exercise in programing in Poker
- Kevin Gates
Kevin Gates. SIMPLE, an exercise in programing in Poker. Technical Report 88-2, Depart-
0
Lawrence Snyder. Parallel programming and the Day. The simple code
- W P Crowley
- C P Hendrickson
W. P. Crowley, C. P. Hendrickson, and T. L. [16] Lawrence Snyder. Parallel programming and the
Day. The simple code. Technical Report UCID-
Poker programming environment. IEEE Coin-
17715, Lawrence Livermore Laboratory, Februputer, 17(7):27-36, July 1984.
ary 1987.
[17] Robert L. Young. An object-oriented
PECAN: Program develpects of ThingLab, a constraint-oriented simulaopment systems that support multiple views. tion laboratory
- Alan Borning
- Steven P Reiss
Alan Borning. The programming language as-[13] Steven P. Reiss.
PECAN: Program develpects of ThingLab, a constraint-oriented simulaopment systems that support multiple views.
tion laboratory. A CM Transactions on Program-
IEEE Transactions on Software Engineering,
ming Language Systems, 3(4):353-387, October
SE-11(3):276-285, March 1985.
1981.
[14] R. W. Scheifier and J. Gettys. The X
Computer recreations Scientific work for interactive data graphics
- A K Dewdney
A. K. Dewdney. Computer recreations. Scientific
work for interactive data graphics. Proceedings
American, pages 18-24, July 1984.
of 1987 Object-Oriented Programming Systems,
'
Languages, and Applications, pages 78-90, Oc-
0
Algorithm Animation PhD thesis, tive simulation
- M H Brown
M. H. Brown. Algorithm Animation. PhD thesis,
tive simulation. In 1986 IEEE Computer Society
Department of Computer Science, Brown Uni-
Workshop on Visual Languages, pages 99-106,
versity, April 1987.
June 1986.