allinea - Now part of ARM

Allinea DDT - The debugger for C++ developers on Linux

C++ debugging with the Allinea DDT debugger

Allinea DDT is the fast, powerful and comprehensive C++ debugger for developers on Linux.

  • Rapid process control and inspection.
  • Powerful C++ STL debugging to view STL containers and many Qt and Boost classes automatically.
  • Memory debugging for hard-to-find or intermittent problems caused by memory leaks, dangling pointers, beyond-bounds array access.
  • Fast navigation of complex code - with in-built editing, building and version control integration.
  • Outstanding support for working on remote or cloud-based systems.
  • For single threaded, multi-threaded and multi-process applications - including those running on HPC clusters such as those using MPI, client-server models and RPC.

Request a live demo Try now Buy now

Rapid Process Control and Inspection

  • Keyboard shortcuts accelerate those common operations such as step in to, step over and step out of functions, pause, resume.
  • Set breakpoints to pause at any location - or watchpoints to trigger when a variable is accessed.
  • Advanced conditions and counters to pause every n'th pass or change for breakpoints and watchpoints.
  • Choose to pause at exception throw or catch, fork or exec, exit or abort, or for specific signals.
  • Windows show local variables, current lines, or expressions - and see variable values as tooltips in the source code.
  • Navigate complex stacks with the stacks view that groups threads and processes by stack traces.

Debugging C++ STL, Qt, Boost and user defined classes

Displaying C++ STL types

DDT lets you see variables quickly and understand the most complex data structures:

  • View variables and expressions - and watch as they change as you move through your code with automatic change highlighting.
  • Browse variables, objects and complex C++ classes, structs 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 such as 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.

DDT is the only C++ debugger that handles the large data sets of scientific computing and deep learning. It can display or filter large arrays - even when distributed on multiple processes.

Screenshot of array viewing in Allinea DDT

Memory Debugging

Screenshot from memory debugging with Allinea DDTAllocated (heap) memory is often behind random and difficult to catch bugs. DDT's built-in fast memory debugger can spot these problems 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.
  • Memory allocated with malloc, new and similar.

Read More about Memory Debugging

Powerful source navigation with editing, building and version control integration

  • Navigate even the largest codes with rapid search of files and functions.
  • Key GUI components are connected to let you navigate to the relevant source easily.
  • Edit the code within your debugging session - and build and commit to your version control system.
  • Working on remote systems or in the cloud?  Connect from your laptop with native Mac, Windows and Linux clients with the free native remote client - no more laggy X connection forwarding!

Think 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 and C++ - 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.

Debugging multi-process, multi-threaded codes

If you work with multiple processes and threads, through libraries like MPI or OpenMP, or with client-server and RPC style applications, DDT makes it easy.

Control threads and processes individually and collectively

  • Set breakpoints on groups of 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 state and differences between processes and threads

DDT has unique data aggregation and difference-highlighting views to automatically compare and contrast program state so it's quicker to handle multiple contexts.

The parallel stack view gives a scalable view of thread and process stacks - from a handful of processes and threads to hundreds of thousands - it groups stacks to highlight the differences that can indicate divergence:

Screenshot of multiple process debuggingUnusual data values and changes are seen instantly with smart highlighting and sparklines - thumbnail-plots that show values of variables across every process:

Screenshot of sparkline plots of variables from different processes

Read more about sparklines in our blog.

Request a live demo Try now Buy now