This paper presents a library of directing commands which enable the construction of powerful directors. The interface has been implemented in a Unix environment as a runtime subsystem running in the directed program's address space. The paper provides the description of the interface and the basic programming techniques in building directors. Examples of novel applications, illustrating the use of the directing interface, are demonstrated by the directors for the visualization of program control and structured snapshots

In this paper we describe our experience applying the concepts of reflection to a legacy transaction processing (TP) monitor in order to support the implementation of extended transaction models. In the past ten years, numerous extended transaction models have been proposed to address the challenges posed by new advanced applications. Few practical implementations of these extended transaction models exist and none are being used in a commercial TP monitor. We believe the reason for this state of affairs is that the interface and functionality of commercial TP monitors is "locked in" to a fixed transaction model. We have developed the Reflective Transaction Framework as a practical method to implement extended transaction models on a commercial TP monitor. The design of our framework is based on the principles of computational reflection, and in particular open implementation.

Debugging and performance measurement tools are becoming increasingly important, especially in distributed and parallel computer systems. A characteristic task of debuggers and performance measurement tools is directing. Directing consists of two major classes of activities, monitoring and controlling. Monitoring is used for collecting information about the program behavior. Controlling is used to modify the program state in order to influence its future behavior. Dynascope, a directing platform, provides basic monitoring and controlling primitives for building advanced directing applications. It is integrated with existing programming tools and uses only generic operating system and networking primitives. The usage of Dynascope facilities is demonstrated in simulator testing and program tracing. Measurements show the performance of Dynascope in local and distributed environments. 1 Introduction Increasingly complex software requires sophisticated debugging and performance...

Reverse execution provides access to old states of an executing process. An application of reverse execution can be found in program debugging. When an error is detected, its cause is often hidden in the history of the process. In such situations, it is important to be able to recover and examine past states of the process. Numerous other applications of reverse execution are found in programming environments, in fault-tolerant computing and in speculative computation. Since processes are in general irreversible, the history must be saved in order to provide reverse execution. The main problem in dealing with the history is the amount of data generated. This paper describes a new approach to reverse execution based on a history cache which compacts the history. The performance of the history cache is measured on a simulator. The history cache can compact the history by more than an order of magnitude. Efficient support for reverse execution enables many new techniques such as a generi...

Debugging and performance measurement tools are becoming increasingly important, especially in distributed and parallel computer systems. These tools are complex, because they are dependent on all major components of computer systems: computer architectures, operating systems, networking, and existing programming tools. The complexity is compounded by the heterogeneous nature of most computing environments. This complexity results in tools that are usually system specific. Significant resources are spent on reimplementing similar tools on different systems. A system independent platform for building debuggers and performance measurement tools would simplify the tool construction. This would redirect resources toward building better tools, capable of operating in heterogeneous environments. A characteristic task of debuggers and performance measurement tools is directing. Directing consists of two major classes of activities, monitoring and controlling. Monitoring is used for collectin...

Conventional debuggers provide primitives for controlling one computer process at the time. Relative debuggers extend the capabilities of conventional debuggers by being able to control two or more processes at once and by providing primitives for comparing the states of these processes. The processes can run on the same computer or on different computers, connected by a network. The processes can differ in their source programming language, in their mode of execution (sequential, parallel, vector), or in implementation details. One of the processes usually serves as a reference version which produces the desired results. The execution of the other process is compared to the reference version in order to find discrepancies. We introduce the concept of relative debugging and present a prototype implementation called Guard. Guard implements basic primitives for relative debugging. It is built on top of our portable debugging interface which provides a debugging platform for heterogeneous...

Introspection in computer systems enables a computer to examine its own computational behavior. Knowledge gained by introspection can be used by the computer to optimize itself and to explain its own behavior to other computers or to human observers. In increasingly complex computer systems, introspective computers can be applied to managing their own complexity. A computer capable of introspection requires at least two subsystems with independent threads of control, which we call an executor and a director. The director monitors the dynamic computational behavior of the executor and controls the future behavior of the executor by issuing directives. The process of monitoring and controlling is called directing. Directing is done from the outside, without any approval from the executor. The paper introduces introspective computer systems. Reasoning behind design decisions and some representative applications are presented. 1 This research has been supported in part by the Slovene Min...

As software systems are growing in size, new approaches are required to handle the resulting complexity. One approach is to improve programmer's understanding of dynamic program behavior. This has the potential to significantly increase the productivity during software development and maintenance. Better understanding of dynamic program behavior can be achieved through visual representation. In this paper, novel methods to visualize program execution are presented. Execution is expressed in terms of events. These events are analyzed and displayed to give an easily comprehensible view of execution. Visualization can be done dynamically in a fixed time regardless of the size of the execution state. Visualization methods are able to incrementally display only modified parts of the execution state. Presented methods are suitable for any compiled, imperative language. They have been implemented in Dynascope, an advanced programming environment. Visualization programs can be dynamically atta...

Introduction The Dynascope programming environment supports directing in traditional, compiled languages. Program directing involves two processes, an executor and a director. The executor is a regular program which can be directed by a director. Directing consists of monitoring and controlling. Monitoring is the analyzing of the executor's computational behavior. This behavior is provided by the execution stream emitted dynamically by the executor. The director controls the executor by changing its data values as well as its program. Dynascope provides a framework and building blocks for easy construction of sophisticated directors. Directors are regular programs that perform the directing of executors through Dynascope primitives. The source code of executors requires no changes in order to be subjected to directing. A more complete description of the philosophy behind Dynascope

Introduction The Dynascope directing platform supports directing of compiled programs. Program directing involves two processes, an executor and a director. Executors are regular user programs. Directors perform directing of executors. Directing consists of monitoring and controlling. During monitoring, the director analyzes executor's computational behavior through breakpoints or tracing events emitted dynamically by the executor. During controlling, the director changes the executor's future behavior by modifying its data values or program code. Examples of directors are debuggers and performance monitors. Dynascope provides building blocks for simple construction of sophisticated directors. This is a user's manual of the Dynascope system. Sections 2 and 3 describe the construction of executors and directors, respectively. Section 4 describes directing primitives. Section 6 gives some notes on