Year 1: Integrating OpenMP into mcGDB

Year 2: Interactive Performance Debugging and Profiling

Deliverable description

  • Deliverable D1: OpenMP 3.0 Integration

    • Representing and Controlling Fork-Join Applications

    The first difficulty that developers face when using an interactive debugger to study OpenMP applications is that the tools are not aware of the fork-join paradigm used in the execution. Instead, they only show the application as a multi-threaded process that, in the middle of runtime-specific functions, executes the application source code. This execution representation can be called multi-sequential, as, from the debugger point-of-view, there is no interaction between the different threads. Our goal in the part of the work was to shift this representation towards a more appropriate fork-join representation.

    • Execution Representation with Sequence Diagrams

    When debugging an application, it is important that developers have a quick and accurate understanding of the current state of the execution. Indeed, if each time they pause the application execution, they waste seconds in understanding the current state, they may easily loose track of their debugging guideline. They should rather have a straightforward way to review it, such as what the callstack provides for simple sequential applications.

    In OpenMP, two difficulties are combined: first, the callstack is messy because of the entanglement between application frames, compiler-outlined frames and OpenMP runtime frames. Second, all the threads are supposed to execute more or less the same code (SPMD paradigm), but this is not reflected in the usual display of the callstack.

    In this chapter, we introduce a visual representation of the current location of OpenMP workers, within the OpenMP zones. This representation is inspired from UML sequence diagrams [3]. These diagrams show the interaction over the time between different actors. The semantic of our diagram is distinct from the UML’s, but the idea and general shapes are shared.

  • Deliverable D3: OpenMP 4.0 Integration

    • Task Debugging in Cooperation with Temanejo

    Temanejo is a task-graph debugging tool for OMPss [3] programming environment (part of the BSC STAR SS family ). It offers a visual representation of the application task graph, as well as different properties of the tasks and data dependencies. It also allows blocking and unblocking tasks, and stepping the application execution task-by-task.

    The design of this tool is close to what we advocate with programming-model interactive debugging. However it currently misses one aspect that is crucial from our point-of-view: it does not offer source-level debugging capabilities. Indeed, Temanejo works in cooperation with a helper library, Ayudame, that is running within the task-based runtime. This design helps them capturing and controlling the programming-model abstract machine, however it does not support any kind of source-level introspection or interactivity. After a fruitful meeting with Jose Gracia and Mathias Nachtmann from HLRS Stuttgart, Germany, we decided to start a cooperation between both tools, so that mcGDB would offer source-level (language—through GDB—and model) interactive debugging, and Temanejo the visualization engine and part of the model-level interactivity.

    In this chapter, we introduce OpenMP 4.0 task support, which is the target of this part of the work. Then we describe Temanejo debugging capabilities, and finally we detail the interactions that occur between mcGDB and Temanejo

    • Discussions about mcGDB Implementation

    In this last chapter of the report, we go though mcGDB implementation and experimentation details. We first discuss the portability question, regarding the OpenMP runtime but also the CPU architecture. Then, we present an implementation technique we used to decouple the core module ( representation ) from the user-facing interface ( interaction package). We finally discuss the micro-benchmarking we carried out to measure the execution overhead introduced by mcGDB.