[Paper Review] Control and Debugging of Distributed Programs Using Fiddle

João Lourenço, José C. Cunha+1 more|ArXiv.org|Sep 26, 2003

Software Testing and Debugging Techniques15 references3 citations

TL;DR

This paper presents Fiddle, a flexible, extensible distributed debugging engine that enables integrated testing and debugging of parallel and distributed programs through a client-server architecture. By using Deipa—a Fiddle client that interprets test command sequences—developers can control execution paths in PVM-based applications, while Fiddle supports concurrent clients for fine-grained process-level debugging and tool synchronization.

ABSTRACT

The main goal of Fiddle, a distributed debugging engine, is to provide a flexible platform for developing debugging tools. Fiddle provides a layered set of interfaces with a minimal set of debugging functionalities, for the inspection and control of distributed and multi-threaded applications. This paper illustrates how Fiddle is used to support integrated testing and debugging. The approach described is based on a tool, called Deipa, that interprets sequences of commands read from an input file, generated by an independent testing tool. Deipa acts as a Fiddle client, in order to enforce specific execution paths in a distributed PVM program. Other Fiddle clients may be used along with Deipa for the fine debugging at process level. Fiddle and Deipa functionalities and architectures are described, and a working example shows a step-by-step application of these tools.

Motivation & Objective

• Address the challenge of debugging complex, nondeterministic distributed and multi-threaded applications.
• Overcome limitations of monolithic debuggers and platform-dependent tools by enabling extensible, platform-agnostic debugging support.
• Enable seamless integration between independent testing tools (like STEPS) and debugging environments via a middleware layer.
• Support high-level abstractions and visualization tools by exposing low-level debugging primitives through a standardized interface.
• Facilitate concurrent, coordinated debugging across multiple tools by providing a centralized, synchronized debugging engine.

Proposed method

• Design Fiddle as a distributed debugging engine based on a client-server model, with the engine acting as a central server and debugging tools as clients.
• Implement Fiddle with minimal core debugging services (e.g., breakpoints, single-stepping, process spawning) and extensible interfaces for new tools.
• Use a launcher mechanism in PVM to intercept process creation, redirect I/O, and register new processes with both Fiddle and Deipa via a communication channel.
• Develop Deipa as a Fiddle client that interprets test command sequences from an external testing tool (STEPS), enabling global control over distributed execution.
• Structure Deipa with a console interface and a multithreaded back-end: process threads for per-process control, and management threads for request handling and process registration.
• Standardize communication between Fiddle and clients using XML, improving interoperability and third-party tool integration.

Experimental results

Research questions

• RQ1 How can a distributed debugging engine be architected to support flexible integration with multiple, independent testing and debugging tools?
• RQ2 What mechanisms enable coordinated, concurrent debugging across multiple clients while maintaining consistency in a distributed, multi-process environment?
• RQ3 How can a testing tool’s command sequences be mapped to low-level debugging operations in a distributed system without modifying the target application?
• RQ4 What role does a launcher mechanism play in transparently integrating new processes into a debugging session?
• RQ5 To what extent can a debugging platform support high-level abstractions (e.g., visual programming models) through extensible, layered interfaces?

Key findings

• Fiddle successfully supports integrated testing and debugging by enabling Deipa, a Fiddle client, to interpret test command sequences and enforce specific execution paths in PVM-based distributed programs.
• The client-server model allows multiple tools (e.g., Deipa and Fiddle) to simultaneously access and control the same distributed application, enabling both global (Deipa) and local (Fiddle) debugging views.
• The use of a launcher program to intercept and register new PVM processes ensures transparent integration into the debugging environment without requiring changes to the application code.
• Communication between Fiddle and clients has been migrated from a proprietary format to XML, significantly improving interoperability and extensibility with third-party tools.
• The architecture enables extensibility through modular clients, as demonstrated by the development of Deipa and ongoing work on FGI and PADI, which support graphical interfaces and enhanced debugging capabilities.
• The system supports debugging at both source-code and high-level abstraction levels, including visual programming models, by mapping high-level operations to Fiddle’s core debugging primitives.