Allinea DDT - the world's most scalable C/C++ and F90 debugger

Allinea DDT is the Linux debugger with the power that you need to take control of software bugs whenever they occur. It makes solving even the most complex multi-threaded or multi-process software problems straightforward.

Memory Debugging

Its built-in fast memory debugger reveals problems in heap (allocated) memory usage automatically.

  • Instantly stops on exceptions and crashes – identify the source and data behind any crash with an easy to use comprehensive interface to application state.
  • Catch out-of-bounds data access as soon as it occurs.
  • Consign memory leaks to history: leak reports detail the source locations that are responsible for the memory allocation.
  • Supports custom allocators - so that allocation locations are reported at the level that matters to your application.
  • Check for dangling pointers.
  • Examine a pointer - check if it is valid and and view the full stack of where it was allocated - and how large its allocation is.
  • For C, C++ memory allocated with malloc, new and similar - and F90 allocated memory.

Comprehensive source browser with rapid navigation, edit, build and version control

  Code editing and browsing

Debugging large complex codebases can be complex - but our user interface makes it easy:

  • Edit, build and commit your code whilst debugging.
  • See version control information alongside your code - identifying the changes that may have caused a bug.
  • Leap from function to function with one click.
  • File and function tree navigation with autocompletion.
  • Rapid search capabilities in current file and whole project.
  • Syntax-highlighting support for Fortran, F90, C and C++.
  • Folding editor and browser - lets you hide sections of code so that you can see the big picture.
  • Leaps to the right source code as you move around the processes, threads and stack frames whilst you debug.
  • Set breakpoints at the click of a button to stop each time a line or function is visited.
  • Color highlighting identifies the processes and threads on each line.

Data Browsing

Displaying C++ STL types

We know it's essential to see variables quickly and understand the most complex data structures - and with Allinea DDT you can.

  • View variables and expressions - and watch as they change as you debug through your code with automatic change detection
  • Browse through variables, objects, modules and complex C++ classes, structs or F90 derived type data structures and multi-dimensional arrays.
  • Dereference pointers or find addresses of objects - and use memory debugging to find out where a pointer was allocated and how large the allocation is.
  • Extensible intelligent display of complex data structures
    • View and browse the real contents of C++ and C++11 STL, Boost and Qt data containers - including list, set, map, multimap, QString and many more.
    • Add support for your own custom data types to show only the data you care about.
  • Set watchpoints to stop when data is read or written by any process.

Powerful, scalable, multi-process, multi-threaded debugging

If you work with multiple processes and threads, through libraries like MPI or OpenMP, Allinea DDT makes managing concurrency easy.


Debug and control threads and processes individually and collectively. 

  • Set breakpoints on groups of MPI processes, and all or individual threads (OpenMP and pthreads).
  • Step or play processes and threads individually or en-masse.
  • Create groups of processes based on variable/expression values, current code location or process state.

See Stacks of Many Processes and Threads

Allinea DDT's unique data aggregation and difference-highlighting views automatically compare and contrast program state at all scales.

  • Spot unusual data values and changes instantly from one to one million processes with smart highlighting and sparklines. Read more about sparklines in our blog.  
  • Compare data across processes or OpenMP threads and pthreads.
  • Parallel stack display – the scalable view of all the stacks of every process and thread - narrows down problems for any level of concurrency: from a handful of processes and threads to hundreds of thousands. 
  • Lightning-fast performance even at extreme scale - Step and display 700,000 processes in 1/10 of a second.
  • Debug CUDA and OpenACC.

We also make it easier to understand the types of bugs that multi-process codes can introduce.

  • Diagnose deadlocks, livelocks and message synchronization errors with both graphical and table-based message queue displays.
  • Integrated support for open-source MPI correctness tools.

Thinking smarter about solving bugs

We've put time into debugging so that you don't have to.  Allinea DDT integrates the best practice to help you spot the causes of problems more quickly.

  • Catch common errors at source with built-in static analysis for C, C++ and Fortran - which warns about bugs before you've even hit them.
  • Why does this revision of my code behave differently to the previous one?  Version control integration highlights recent changes - and allows you to see why and where changes have been introduced.
  • A single command in Allinea DDT will automatically log the values of variables across all processes at each changed section of code, allowing you to track down exactly how and why a particular change introduced problems to your code.

To help you manage your progress during debugging our logbook provides a handy record of the steps you've taken and the things that have been observed.

  • Automatic, always-on logging of your debugging activity so that it’s easy to go back and review the evidence for things you might have missed at the time.
  • Share logbooks with others on your team, making collaborative debugging a reality.
  • Compare two traces side-by-side, to see changes between systems, versions or process counts jump right out.

Scalable printf and powerful command-line modes

Scalable printf debugging - instrument your code with scalable tracepoints – no recompilation necessary.
Offline batch modes – debug while you sleep and submit an offline debug run to your queue from the command line and receive a text or HTML error and trace report from DDT when the job is done. Read more about offline debugging in our blog.

Handles and visualizes huge data sets

Export to industry standard data formats HDF5 and CSV.
Browse arrays and gather statistics – over all your processes in parallel – with powerful filtering to search petabytes in parallel.

Visualize and debug data simultaneously using Allinea DDT's connector to the VisIt scientific visualization tool.  

Part of an integrated development toolsuite

It's natural to want to improve the speed of code after removing the bugs. That's why Allinea DDT is part of Allinea Forge.  Allinea DDT is available separately or in an Allinea Forge license that includes the leading Linux parallel and threaded code profiler, Allinea MAP

Allinea MAP shares the same user interface and installation as Allinea DDT - which means it is easy to switch to profile a code once debugging is complete.

Access Remote Systems with native Mac, Windows and Linux clients

Debug the supercomputer from your laptop with native Mac, Windows and Linux clients.
Run the Allinea DDT user interface on your own machine for lightning-fast responsiveness and let it connect via SSH to your remote HPC resource to debug your problem at full scale - and work with your source code remotely as you build, edit and commit.
OpenGL array visualization displays are now performed on your local graphics card - no more laggy X-forwarding or poor-quality VNC displays.

Cross-platform for the HPC architectures of today and tomorrow

Intel Xeon Phi NVIDIA CUDA - GPUs AMD ARM Architecture IBM

Allinea DDT is cross-platform supporting all of today's leading technical-computing platforms - which means you can be productive on any system.

It's a CUDA debugger, a parallel debugger, a multithreaded debugger, an OpenMP debugger and a memory debugger all at the same time - and supports mixed hybrid programming models.

Intel Xeon Phi , NVIDIA CUDA , IBM BlueGene/Q, OpenPOWER, ARM 8 (64 bit), 32-bit and 64-bit Intel Xeon
MPI, OpenMP, CUDA , OpenACC, UPC, CoArray Fortran, PGAS Languages, pthread-based multithreading, SHMEM, OpenSHMEM
Fortran, C++, C++11, C, PGAS Languages, CoArray Fortran

View the full platform compatibility list

Download a trial