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.
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
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.
Allocated (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.
- 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!
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.
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
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:
Read more about sparklines in our blog.