As codes and the systems they run on continue to increase in complexity, bugs are becoming more difficult to find. The challenges from threading, multi-process, accelerated hardware, message timing and other complexities have prompted a new set of requirements for debugging. To help address these evolving challenges, Rogue Wave has made true reverse debugging and CUDA support standard features in TotalView.

Many HPC/High Performance Computing developers don’t realize how much time can be saved by using advanced debugging techniques. Oftentimes, developers spend more time tracking down bugs in their code than they do writing it. The time, effort, schedule impact, and ultimately wasted money when a code crashes or generates incorrect results is a serious issue both for the developer and for organizations hosting HPC resources. The costs involved in having unexpected program failures on a supercomputer can be staggering. More than likely the user is working with a limited allocation of runtime, so defects that go unnoticed aren’t just frustrating, they’re a waste of precious resources both for the scientist and for the institution paying the power bill on the supercomputer.

Considering the enormity of the consequences for runtime errors, one might assume that HPC developers insist on using the best tools in the market. The hard reality is that the majority of programmers today still rely on the most tried and true method of debugging their codes: using a print statement. Print statements work, if you have the patience to keep adding new statements, recompiling, then adding more, then recompiling, then annotating them so you know which thread or process it’s from, then recompiling, and finally removing them once you figure out what went wrong. With the increase in complexities mentioned earlier – that brute force approach just doesn’t cut it anymore. The good news is that there is a much easier way to debug.

One could argue that adopting any type of commercial debugging is going to be a large leap forward over print statements. However, many times that isn’t the case, and in fact can make it more difficult. Most standard debuggers, both commercial and open source, were not designed to handle the scale and complexities involved in HPC codes. Trying to use one of these debuggers on a multi-node job utilizing GPU acceleration can lead to a lot of wasted time and effort. While writing parallel, data intensive HPC applications is extremely challenging, debugging and optimizing those applications without the right tools is even harder.

Rogue Wave is in a unique position in the HPC software tools space, with expertise and offerings for debugging, complex math and statistics as well as optimization.  By leveraging our hundreds of years of combined experience in HPC development, we are able to address the needs of the HPC programmer in new and creative ways. System and software complexity is increasing at an incredible rate, and the amount of data being generated is astounding. Tools must be designed to scale and handle massive amounts of data. Rogue Wave is the largest independent provider of cross-platform software development tools and embedded components for the next generation of HPC applications and has positioned itself to set a new standard of debugging.

HPC codes are parallel, run on multiple machines with heterogeneous hardware, and communicate in complex patterns and paradigms. To debug HPC codes, a debugger designed from the ground up with the needs of supercomputing environments considered at all stages is needed. To efficiently debug these codes, you need the following capabilities:

• Launch or attach to all or part of a large parallel job in a single debugging session
• Complete control over process and individual thread execution on multiple nodes
• Easily work with groups of processes that are automatically defined based on program structure
• Easily define groups of processes based on arbitrary criteria
• Compare data across a parallel job or across threads within a process
• Analyze memory usage across the parallel job and automatically detect leaks and corruption
• Debug backwards – backing up from a bug or crash to find the root cause
• Viewing execution and state on accelerator hardware
• Scripting debug sessions for long running and batch execution
• Remote debugging display on desktops

Put simply, HPC debugging isn’t just stopping execution, stepping through a few lines of code and looking at variable values anymore. An HPC-class debugger needs to do a whole lot more to enable the HPC developer to focus on what they should be spending their time on – solving problems previously unsolvable without supercomputing capabilities. Rogue Wave is leading the way in enabling the HPC developer with these abilities, and is dedicated to and able to provide the highest quality HPC tools in the market.