Allinea/ARM-DDT Installation

Official homepage

Allinea/ARM DDT is a commercial debugging tool available for scalar, multi-threaded and large-scale parallel applications.

For details, we refer to the official User Manual

Please contact if you have any questions or problems.

General Tips

• To debug your application, you should use a compute node and not a login node
• Since DDT has a graphical user interface, we recommend to use ThinLinc. How to use ThinLinc, we refer to our documentation Running graphical applications using ThinLinc.

How to compile your code for debugging

To prepare your code for debugging with DDT, compile your code with the compiler flag -g. It is the standard compiler flag for debugging for C and Fortran programs, supported by Intel and GNU compiler. For purpose of debugging, any optimization flags are typically disabled. You can use the option -O0 to explicitly disable optimization.

Error Backtrace The compiler runtime library can give a diagnostic output message (backtrace), if your code crashes due to a segmenation fault, wrong deallocation of dynamic arrays, bus error, floating-point exception etc. This information can be useful to find the location of the error in your code.

Typically, one has to activate the output of backtrace information. Otherwise, the location where the error occured may not be shown. The compiler options for Intel and GNU compiler are as following:

Intel:    -g -traceback
GNU:      -g -fbacktrace

Backtracing can slow slow down your application. Therefore, backtracing should only be used if necessary, but not as a standard debugging option.

How to run DDT

DDT can be started in different ways. In most cases, you will run DDT interactively, using the GUI. An interactive session can be allocated for example as following:

    interactive -n<number_of_tasks>

to run parallel MPI programs, or

    interactive -c<number_of_threads>

to run parallel OpenMP programs.

Load the DDT module corresponding to the version that you want to use:

    module load arm-DDT/23.1.1

How to run DDT for Serial Codes

To interactively debug a serial code with DDT, start your application as follows:

    ddt your_serial_program

It will launch the graphical user interface to debug your application.

How to run DDT for OpenMP Codes

To profile a code that uses OpenMP parallelization, you have to specify the number of threads and then start the debugger as follows:

    interactive -c<number_of_threads>
    export OMP_NUM_THREADS=<number_of_threads>
    ddt your_openmp_program

How to run DDT for Parallel MPI Codes

To profile a parallel MPI code, DDT needs to access the MPI library. In this case, you need to load the build-environment that was used to compile your code. For example:

    module load arm-DDT/23.1.1
    module load buildenv-intel/2018b-eb

How to start your parallel MPI application with DDT, depends on the MPI library that you are using. We distinguish between Intel MPI and OpenMPI:

Intel MPI

    ddt --mpi=intel-mpi -n <number_of_tasks> your_mpi_program

OpenMPI

    ddt  --mpi=openmpi -n <number_of_tasks> your_mpi_program

How to determine the build-environment of your application

If you do not remember the build-environment that was used to compile the code, or if it is unknown to you, you can check how it was build as following:

    dumptag your_executable

dumptag will tell you, how the executable was built. For example, to see how the executable pimpleFoam from OpenFOAM was built (we omit loading the OpenFOAM module for brievety):

    dumptag pimpleFoam

gives the output

    NSC tags ---------------------------------
    Build date      190912
    Build time      164115
    Built with MPI  impi 2018_3_222__eb
    Linked with     intel 2018b__eb
    Tag version     6
    ------------------------------------------

Here we see, that the build-environment intel 2018b__eb was used. Accordingly, we load the following module in this case:

    module load buildenv-intel/2018b-eb