Models for recovery from software instrumentation intrusion in parallel and distributed systems
Jr. James Edward Lumpp · 1993
Execution monitoring (or execution tracing) is central to the development of software on concurrent computer systems. The complexity of parallel architectures combined with non-determinism makes the performance of parallel programs difficult to predict and makes the behavior of parallel programs difficult to observe. Programmers of parallel systems need tools to provide feedback on the behavior of programs. These tools, in turn, rely on information obtained during execution of programs. For debugging and verification, obtaining information on the control flow that occurs during an actual execution has advantages over approximation techniques that are often employed for performance measurement systems. In addition, performance measurement systems can benefit from more accurate measures of event timing. Due to the characteristics of multiprocessor systems, however, obtaining accurate traces is complicated. For example, the introduction of software probes into a parallel program can differentially delay the processes and change the order of subsequent accesses to shared resources. This thesis presents techniques that allow the recovery the exact timing and ordering information for traces obtained via software instrumentation in message passing concurrent systems. The technique includes modeling characteristics of the architecture of the target system, the program being studied, and the instrumentation that is introduced into the program. After execution of the program with the instrumentation, the resulting trace is analyzed along with the models to generate a new trace with corrected timing information. The technique recovers the trace information that would have been observed had the instrumentation not been present up to the point at which the instrumentation causes event order changes that can affect the subsequent behavior of the computation. The technique is applicable to both tightly and loosely-coupled multiprocessor systems.