Official homepage: www.allinea.com/products/ddt
Allinea DDT is the most advanced debugging tool available for scalar, multi-threaded and large-scale parallel applications. Features are described on the official homepage and in the User Manual
Please contact if you have any questions or problems.
|ddt||DDT debugging binary which truns on its GUI|
Load the DDT module corresponding to the version you want to use, e.g.,
module load allinea-DDT/20.1
It launches the DDT binary path.
At your first use, you shall set environmental configuration. Log in through ThinLinc or with X-ternimal turned on. For use of ThinLinc, please refer to Running graphical applications using ThinLinc. For X-windows user, install Cygwin-X (Windows user) or other relevant software, run X-client on your computer, lo g in with X-11 forwarding turned on.
> Use of ThinLinc is highly recommended for two reasons: (1) ThinLinc loads a Linux desktop so that you can work on multiple graphical tasks under the same environment. (2) The grap
hical process through ThinLinc is faster than the use of X-windows client.
Using DDT requires configuration, say, how to set up the scheduler, work on job scheduler, etc. So initially it has to be provided. If you intend to use DDT in interactive mode, sch
eduler setup is not needed. (NSC would recommend working with interactive mode for direct debugging.)
If you want to change this initial setup later, ddt -cleanconfig $home/.ddt/config.ddt will delete your config file (for the new setup). You will perform configuration at the next DDT run.
To prepare debugging your code with ddt, compile your source code with the compiler flag
-g For running the debugger, run
ddt ./your_executable It will load a new DDT window. The interface is very intuitive so you will easily use it. FYI, when DDT has been turned on, it opens the configuration window. your_executable name w
ill be mentioned in 'Application'. For MPI application, check 'MPI' enabled. For memory debugging, check 'Memory Debugging' turned on.
That is quite intuitive, so not hard to understand.
Tracing variable with properties, all others can be done rather easily
Initially check the memory debug when you start a new session. In the "View" and "Current Memory Usage", * if you click on a bar, the list of allocated pointers will be available * if you click on a pointer, the stack view will appear * and if you click on the function call and get back to the source code, you will see where the allocation has been made. To debug memory leaks, I suggest that: * you run the code until the end and watch at the memory usage at that point (remaining arrays should have been freed at this stage) * or put a breakpoint in the "right loop" and watch the memory grow as you move forward. Though this memory debug is quite useful, also it should be used with care. It usually slows down the run, also it fails to find the correct buggy location if the problem comes from
the false MPI communication. NSC experienced one user's code has the wrong MPI communication call on threaded computing (which uses boost), DDT memory debug detected that it is due to orphan MPI communication (i.e., dummy communication call from sub-threads were stacked on buffer) while it failed to mark the erronous location.
We recommend users to use DDT through an interactive allocation, not running on the login node. Resource heavy processes on the login node will be terminated.
Please refer to the Allinea-DDT User Manual for more details.
To get the interactive allocation, type
interactive -N node_count -t hh:mm:ss -A your_allocation
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