TotalView Debugging Software in Action

Watch this quick demonstration to see TotalView's key capabilities.

Dynamic Analysis of Threads, Processes, and Memory Usage

Spend your time developing the HPC solutions needed to answer life’s bigger questions — and less time on debugging — by using the tools in TotalView for debugging:

Multithreaded and Parallel Processes

Simultaneously debug thousands of threads and processes.


Pinpoint and control memory usage, leaks, and improper API use.


GPU-Specific Software

Gain insight and control over CUDA and OpenACC code running on NVIDIA GPUs.

SIMULIA Uses TotalView to Find and Fix Bugs Quickly in 3D Simulation Software

By using TotalView, elusive software bugs are a distant memory. Plus, developers are improving software quality and saving time.


Explore TotalView’s Features

Learn more about what you can accomplish with TotalView.

Debug applications running in your HPC environments faster with TotalView, by taking advantage of its abilities to: 

  • Support more than 20 different MPI implementations.
  • Debug multithreaded applications with pthreads, OpenMP, and TBB.
  • Easily establish interactive debugging sessions within your cluster  including through batch submission systems.
  • Provide visualizations of program data and variables.
  • Define how aggregate data in displayed, so you can see custom data structures in simpler forms.
  • Debug programs using the CUDA and/or OpenACC models.
  • Perform advanced memory debugging, including memory leaks and errors.

Speed issue resolution in HPC code by using the reverse debugging capability in TotalView to:

  • Work back from a failure, error, or crash to its root cause.
  • Record and replay:
  • Heap memory usage.
  • Process file and network I/O.
  • Thread context switches.
  • Multithreaded applications.
  • MPI parallel applications.
  • Distributed applications.
  • Network applications.
  • Step forward and backward by function, line, and instruction.
  • Support continuous integration, collaboration, and code-learning by recording code.
  • Eliminate restarting your program repeatedly with different breakpoints.
  • Learn new code and deliver enhancements quicker. 

Learn more

Find memory leaks and buffer overruns with TotalView's scalable memory-debugging technology:

  • Easily find memory leaks and understand heap usage.
  • Detect malloc/free, new/delete API misuse.
  • Detect buffer overruns.
  • Share memory debugging data with colleagues through data files and HTML reports.
  • Compare memory results between sessions to verify elimination of leaks.
  • Save time and money with low overhead technology that does not require recompilation or instrumentation.


When you deploy TotalView on a host machine, you can debug jobs running on compute nodes from a client running TotalView using the Remote Display Client feature. With it, you can:

  • Receive an alert when your application starts running on remote infrastructure.
  • Run remote debugging sessions using a client device — even if it does not have a TotalView license.
  • Submit batch jobs to SLURM, PBS Pro, and Load Leveler batch-queuing systems.

Customers can request these free plugins via the software download form.

Read more about Remote Development and Debugging >>

You can debug applications written in one or more of the following languages, using TotalView:

  • C and C++
  • Fortran 
  • Mixed-language applications written in Python and C/C++ 
Image Product Languages

The applications you debug using TotalView can run on the following operating systems: 

  • Linux including Cray Linux Environment (CLE) and PowerLE
  • UNIX including AIX and Solaris
  • macOS 
Image Product Operating Systems

You can use TotalView to debug and optimize code for laptops, workstations, servers, clusters, and supercomputers with the following processors: 

  • ARM (aarch64)
  • Intel/AMD (x86-64, x86)
  • NVIDIA GPUs on Linux x86-64, Linux ARM64, and Linux PowerLE (Power9)
  • NVIDIA Jetson AGX Xavier
  • OpenPOWER (ppc64le)
  • Power (ppc64, ppc32)
Image Product Processors

Use TotalView to debug code that uses the following standardized APIs, plus many more:

  • CUDA
  • MPI
  • OpenACC
  • OpenMP
  • pthreads
Image Product APIs Standards

Learn More about TotalView Debugging Software

Purpose-built for multicore and parallel computing, TotalView delivers a set of tools providing unprecedented control over processes and thread execution, along with deep visibility into program states and data. 

Share this product brief with your team, to see how you can collaboratively use TotalView to speed HPC development and improve uptime, code quality, and savings.


Free Trial

Start your free trial of TotalView to see how you can dramatically simplify and accelerate HPC debugging.

View Demo

Watch how TotalView improves HPC debugging.


Our experts are ready to help.