TotalView Debugger 8.7.0-0

Developer debugging system
TotalView Debugger
  3 Screenshots
TotalView is useful because lots of developers are discovering its unequaled value for applications written for simulation and modeling, special effects, finance, telecommunications, scientific analysis, animation, biotechnology and many other fields.

Available on Mac OS X, Linux, and UNIX, TotalView supports threads,  C/C++, MPI, OpenMP, and Fortran, plus mixed-language codes.

Advanced features like on-demand memory leak detection, other heap allocation debugging features, and our Standard Template Library Viewer (STLView) are not found in average debuggers, and make debugging a breeze.

Unique features like dive, a wide variety of breakpoints, the Message Queue Graph/Visualizer, powerful data analysis, and control at the thread level give you the power you need to solve tough problems.

Main features:

  • TotalView understands multiple instances of templated code. You can easily set breakpoints on all instances of a template. And you can choose to enable only the instances you really care about. Setting a breakpoint on a particular instantiation works in a similar fashion. TotalView finds all instantiations of a template, and simply lets you choose those on which to set the breakpoint.
  • TotalView understands overloaded methods and directs you to, or lets you select, the right one. This means you'll quickly and accurately find potentially elusive problems. Where other debuggers are confused by overloaded methods, TotalView gets it right.
  • TotalView lets you use C++ functions in breakpoints. For example, within a conditional breakpoint or evaluation point, you can include something like: if ('A' == b1.getData() ) {$stop}. TotalView also lets you watch the value of C++ expressions as they change in the Expression List Window.
  • TotalView makes debugging shared libraries easier than ever by automatically noticing when your program loads them. This allows you to stop the process and conveniently set breakpoints within the code contained in the library. And it lets you easily debug code in header files. It all adds up to making shared libraries and header code as easy to debug as any other part of your code, no matter how complex it gets.
  • Sometimes debuggers don't know enough about an object to display it as you would expect to see it. Our Type Transformation Facility (TTF) solves this problem. You can tell TotalView how you want to display things like non-native types or STL constructs. Once you create a TTF prototype, TotalView always displays the object as you have defined it. See Creating Type Transformations in our reference guide for information on how to create your own transformations.
  • TotalView's STLView makes it easier than ever to view and debug standard template library code and data. The C++ STL (Standard Template Library) greatly simplifies your access to containers and eliminates tedious work. However, it can also be difficult to make sense of the output presented to you during your debug session. This is because the information you are shown is the compiler's view of your data rather than the STL's logical view. STLView removes this debugging obstacle by transforming the output of common templates (map, list, vector and string) into easy to read and understand information. It's a big step forward in C++ debugging. You can also create your own transformations with TTF.
  • The Standard Template Library Viewer (STLView) makes it easy to read and understand your compiler's output.
  • The C++ STL (Standard Template Library) greatly simplifies code creation, eliminating tedious and redundant work. However, STL code and data as displayed by the average debugger often looks like a lost, ancient language and can be impossible to read. This is because the information you are shown is what the compiler is generating, and most debuggers don't know how to make it useful.
  • With TotalView's STLView feature, we take common STL container classes (vector, list, map, and string, as well as any transformations you've created) and display them in an easily readable form. The following figure shows the untransformed data (background) and the output from STLView (foreground).
  • TotalView 6.5 introduces the ability, through the GUI, to create your own STL transformations. An alternative is to use our tried and true Type Transformation Facility in our command line interface. Like the GUI, TTF lets you define your own transformations by creating a prototype that TotalView understands. Each time TotalView sees that container type, it transforms the information according to your definition. Explore our Type Transformations documentation (TTF) for more information.With STLView and the Type Transformation Facility, TotalView makes easy reading out of the strangest looking hieroglyphics your compiler can send your way.STLView and the TTF require support from the compiler.
  • Quickly drill down to get the information you need on any variable or object. TotalView users tell us our exclusive dive feature is a handy favorite. Dive gives you more information about any object, variable, structure, or array on which you click. It's a wonderful, efficient way to drill down as far as necessary, until you get the information you need, at the instant you need it.Expanding on dive, TotalView offers dive-in-all, which lets you drill down on any specific field or member within complex structures, so that you see only the interesting information across all instances of the structure. TotalView shows you results in the form of an array, then lets you apply powerful data analysis features like visualization, and array analysis.
  • These features make it quick and easy to find problems in your data. TotalView's exceptional array analysis features reveal patterns, exceptions, out of range instances of data, and much more. These features make it fast and easy to find problems by quickly and easily analyzing your data. You may choose:
  • Slice lets you view a portion of an array. For example, if you only want to see the first dimension of a 3-dimensional array, you can specify this in the Slice field of the Variable Window.
  • Filter lets you display all of an array's elements that meet some elementary expression. For example, if you want to see all values greater than 100, you can write an expression in the Filter field of the Data Window and TotalView will display only these elements of your array. TotalView offers intrinsics such as $INF and $NAN that also let you query an array for infinity number and NaNs.
  • Sort You can sort what you see in the Data Window.
  • Statistics - you can get information like the size of the array, the number of infinities or NaNs contained in the array, the min or max values, and the like.
  • Visualization - a picture is worth a thousand words, and sometimes eliminates many hours of frustration. If your data has a pattern to it, yet you know something is wrong, imagine being able to watch your data change as the program executes. TotalView's visualizer lets you visualize arrays at any given moment during execution. Or you can write an evaluation point to continually update the visualization as your program runs, in effect creating a movie of your data as your program executes.
  • See an object's value across all processes or threads. If you write multi-process or multi-threaded code, you have data associated with each process or thread. There are many times when you'd like to see the value an object has across all those processes or threads. Rather than navigate from process to process and check the value, you can simply dive on a variable, and then select "View Across" from the View menu of the Data Window. This will show you the value of the object across all processes or threads in one simple and concise window.
  • Finally, view your template data in easily readable form. If you use the Standard Template Library, you know it can be very difficult to make sense out of your compiler's output of templated data. It's a bit like deciphering the symbols of some lost ancient language. Finally, you can view your template data in easily readable form, with TotalView's STLView utility. STLView removes this debugging obstacle by transforming common templates (STL vector, list, and map) into readable and understandable information. It's a big step forward in C++ debugging and we know you're going to love it. This valuable and very popular utility is now included at no charge with every TotalView license.
  • Stop your program instantly when interesting data changes. Breakpoints are to code as watchpoints are to data. Stop your program instantly when interesting data changes. You can even make it conditional. Perhaps you only care if some variable surpasses a threshold of 100. It's quick and easy to set this up, and you'll find problems in your data more quickly.
  • With TotalView, you can cast just about anything to anything else! TotalView's ability to cast just about anything to anything else is powerful. Cast data into a more familiar form. Cast a dynamic array into a static one so that you can apply some of our exceptional data analysis techniques. Cast a structure to an array and then apply a filter to look at data that's out of bounds. The options are endless and will help you gain insight when and where you need it.
  • Gather and group data you want to see as you debug. TotalView's new Expression List Window gathers and groups data you want to see as you debug. Create any number of expressions at varying levels of complexity in this window, and each time TotalView stops, it updates the result of those expressions. And if you stop and restart your program, TotalView will remember what you typed into the window. The information you see in the Expression List Window is easily customized to meet your needs. Sort the list of expressions by clicking on the column heading by which you'd like your data sorted. Right click on the line containing the column headings to see options for other information you can display. You can also add or remove columns as you wish. The expressions in the Expression List are focused on a specific process or thread. You can change the thread or process against which expressions are evaluated simply by typing in a different thread or process number in the thread/process box at the top of the window.
  • Save data for processing by another tool. Would you like to extract your data from your debugging session? Simply debug until your data is in the state in which you'd like to extract it, and select "Save to File" from the File menu.
  • TotalView is the proven leader in Fortran debugging. Installed in the most prestigious research and development environments around the world, it is considered a "must have" for Fortran developers who face the challenges of large and complex applications and of integrating legacy codes with newer applications. TotalView understands Fortran. Period.
  • If you use Fortran 90 modules, assumed shape arrays, common blocks, user defined types, or any other features of the language that push the envelope, you will find that TotalView handles them all and provides reliable and accurate results where other debuggers fail.
  • And TotalView supports mixed Fortran and C/C++ code just as seamlessly as if they were a single language. Users have said that "TotalView is a Fortran hackers dream come true." And that "everything is just raw memory waiting to be interpreted however you please." The ability to look at, change, and interpret different data is immediately obvious and convenient with TotalView. TotalView's interface lets you see the details of your complex Fortran code and perform actions quickly.
  • When the ability to handle Fortran constructs is combined with TotalView's myriad debugging features and advantages, the choice for serious developers becomes obvious. If you are working with Fortran, you owe it to yourself to try TotalView.
  • TotalView Memory Debugging Benefits
  • Built into the debugger so you don't have to switch tools
  • Lets you interactively locate memory problems
  • Breaks wasteful cycle of run-to-completion, report, fix, run-to-completion, fix...
  • Does not instrument your code or rewrite libraries
  • Graphically displays memory use, allocations, and leaks
  • Provides any-time views of memory status, not just post-mortem reports
  • Easily locates allocations that cause leaks
  • Stops execution when program incorrectly uses heap
  • Lets you hone in on what's important by filtering out what you do not want to see
  • Saves and imports memory state so you can compare states at different times
  • TotalView Debugger has an integrated, interactive memory debugger that helps you find and eliminate memory problems as you debug your code.
  • It's built into the debugger, it's less intrusive than other memory analysis tools, and you don't have to re-compile. It's a whole new experience in debugging memory problems.
  • Working with C, C++, and Fortran code, the Memory Debugger lets you watch for memory leaks, monitor the amount of memory your program uses, and track how it allocates and frees memory. You can move through any debugging session, looking for leaks, and tracking heap allocations and deallocations while getting the memory usage information you want. Far more useful and convenient than post-mortem reports, our memory debugger reports (or views) show status and leaks at any time. You get all the information about the heap, whenever you need it. And you can stop execution, check for problems, test fixes, and then continue debugging.
  • Heap status views give you an easy way to track your heap activity, make leaks visible, and drill down to specifics. The graphical heap browser makes it easy to interpret your heap activity. In this graphical view, color-coded bars show allocated, deallocated, and leaked memory blocks. You can select individual bars to get more detailed information, including the source line on which the block was allocated or deallocated. Zooming out immediately shows you how fragmented your heap is and how allocations and leaks relate to your program's activities.
  • Leak detection is easy. Heap status views display leaks in red. Leak detection views organize this information hierarchically, showing you just your leaks. TotalView tells you, down to the line number, how many bytes were leaked, so you can concentrate on your biggest leaks and ignore those that are mere nuisances.
  • The Memory Debugger gives you clear pictures of memory problems by eliminating the clutter and confusion caused by irrelevant data. For example, filters let you hide leaks originating in libraries over which you have no control.You can create filters in two ways. The easier is to select a block in a view, right-click, and select the filter command. This removes all blocks originating from that place in your code. The second lets you enter information in a dialog box. For example, you could tell the Memory Debugger that it should only show information from one or two libraries.
  • The Memory Debugger can show you the amount of memory that your program uses. This information lets you quickly identify when memory use isn't what you expect it to be. Here's a figure that has two of the ways you can see this information. For each process, program, or library, TotalView shows the amount of memory used by the text and data areas, as well as the heap, stack, and virtual memory sizes. Watch these windows over time, and you'll notice when memory usage gets out of hand for a process or your program. For more detailed information, you can tell the Memory Debugger to display information in tables.
  • The Memory Debugger tracks memory events and can stop and display event information before the event occurs. You can then tell the TotalView debugger to skip over the instruction that might cause memory-related crashes.Some of the events that TotalView detects:
  • Free not allocated: An application calls free() with an address not existing in any block allocated on the heap.
  • Realloc not allocated: An application calls realloc() with an address not at any block allocated on the heap.
  • Address not at start of block: free() or realloc() address not at the start of a previously allocated block.
  • Free interior pointer: The address being freed is within an allocated block.
  • Deallocation notification: When your program deallocates a block, stop execution.
  • Out of Memory: Your program couldn't allocate the memory block. While program's should check for this, not all do.
  • Figuring out how your program uses and shares memory is usually quite complicated. TotalView helps by telling you the status of the memory your program's pointers are pointing to. Whenever you stop your application and look at a pointer, TotalView gives you information about the pointer's memory. For example, the memory might be:
  • Dangling--allocated and then freed
  • Allocated--allocated
  • Interior--pointing to the middle of a block
  • Because TotalView displays this information when it displays variables, you'll know instantly if your program is accessing old or incorrect data.
  • Explore the state of any block, find where it was allocated or deallocated, or even tag a block. Tagging tells TotalView to raise an event when the tagged block is freed or reallocated. You can also tell the Memory Debugger to remember a block. This makes it easy to look at the block's state whenever you want. TotalView provides detailed information about the pointers that direct you to memory blocks in the heap. If you are viewing a pointer to a heap block, you can bring up the Block Properties Window to see detailed information about this block.
  • Baselines let you see what has changed from one point in your program to another. After setting a baseline, you let your program execute. After you stop execution, the Memory Debugger can generate a summary of your program's changes or of any leaks that have occurred. You can then let your program execute for a while, then halt it again to continue to see information from the baseline. If you need to obtain more details, just open the Memory Debugger and display a Leak Detection or Heap Status View. While these views normally show all information that the Memory Debugger has collected, each of these views has a Relative to Baseline checkbox that limits the information being displayed to the allocations and leaks that occurred since you set the baseline.
  • The Memory Debugger lets you save memory information to disk. At a later time, you can read this information back in and compare that old state with the current state or with two older states. In most cases, you can create views of this saved information exactly as if it were the data for an executing program. In addition, you can create a memory compare view that shows you the differences between two memory states. Comparing the current state to a baseline is valuable when trying to understand how your program is using memory.
  • If you need to look at information with a different tool, in a different way, or in a different context, use the View Export feature. Export various memory debugging views to text or HTML for later viewing or printing. You can export most views.
  • The Memory Debugger can surround allocations with a small amount of additional memory. It will also write a pattern into this memory. If your program overwrites this memory, you can tell that a problem occurred either by asking for a report or by an event notification when your program deallocates a guarded block.
  • The toughest memory bugs are those that cause wrong answers. For these kinds of bugs, you'd much rather have your program crash and then analyze what caused the problem. For these and other reasons, TotalView offers many advanced features, including:
  • Memory block painting, which helps you see if your program is accessing uninitialized areas of memory. Painting is used most often to detect when your program is using deallocated memory.
  • Memory hoarding, which tells the Memory Debugger to hold onto memory after your program frees it. This lets your program keep running and often lets you discover code that is trying to write into memory that it thinks is freed.
  • TotalView makes remote debugging as easy as local. Your complex MPI code can have hundreds of MPI processes running in parallel and perhaps distributed across several machines. TotalView automatically detects that a new MPI process has started and automatically attaches to it. MPI provides a mechanism for us to know which processes on what hosts are part of a parallel job, and TotalView makes it a simple operation to attach to them all. And advanced users can debug an arbitrary subset of the MPI processes.
  • TotalView lets you easily create custom process groups. Then, when you select that custom group to control, all TotalView commands will act on that group. The Processes tab provides visual feedback, making it easy to keep track of which processes you are controlling at any given time.
  • Our Message Queue Graph gives you a visual representation of the message queue information, making it easy to see where interprocess communication has gone wrong. Simply choose Tools > Message Queue Graph from the Process Window, select the types of messages you would like to see, and click Update. TotalView will show you an easy-to-understand graph. A click on any process provides more detail.
  • TotalView provides visibility and insight into how your MPI processes are communicating with one another. Since MPI process communication problems are both common and often hard to detect, the TotalView Message State Window is an essential feature for your MPI debugging. This window makes it easy to see when processes aren't communicating as you intended, and to get the details you need to fix the problem.
  • TotalView lets you control your MPI processes any way you like. Special breakpoints called barrier points put you in control of synchronizing groups of processes at strategic points in your debugging session. Using barrier points, you won't lose control of all your processes you're in the driver's seat.
  • TotalView supports many flavors of MPI, such as MPICH, LAM-MPI, and vendor-specific version. Yours is probably on our list! To find out, consult our platforms document.
  • OpenMP provides a powerful and easy way to introduce threads-based parallelism into your program. TotalView brings you the same advantages in debugging OpenMP programs as it does in MPI. You can control individual OpenMP threads as you would individual MPI processes. You can set breakpoints and barriers, which can stop a single thread or the entire OpenMP program.
  • Using TotalView's "laminate" command, you can view common variables across all threads in your process, just as you can across all the processes of an MPI group.
  • Some developers are using both OpenMP with MPI in the same application, a technique called "hybrid programming." TotalView handles hybrid programs as easily as it handles non-hybrid MPI or OpenMP programs. Chapter 6 of the TotalView Users Guide has more information on debugging OpenMP programs.
  • See through the complexity
  • Essential to solving 'race condition' problems
  • Control a single thread or step them all together - your choice
  • Switch between threads easily
  • Dynamically manage thread groups and add newly spawned threads to groups in the CLI
  • Multithreaded core file support
  • View thread-specific and shared data
  • Easily and automatically acquires threads as they are created and according to type
  • Given the choice between a sharp stick in the eye and debugging multi-threaded code, many developers would think long and hard. The use of threads has become a necessity for many of today's mission critical applications. As a result, many programmers now face a maze of threads too complex to follow using traditional debuggers. TotalView helps you see through this complexity. TotalView was built from the ground up to understand parallelism; that heritage makes it particularly well-suited to debugging threaded code. Its built-in features make it easier than ever to untangle and control threads. For example, TotalView easily and automatically acquires threads as they are created, and dynamically groups them according to type. That makes debugging threaded code as easy as serial code. And TotalView takes threads support all the way down to the single thread level (on most platforms).
  • Here are just a few of the benefits of debugging threaded code with TotalView:
  • Control individual threads and set breakpoints at the thread level
  • Control groups of threads if you want to
  • Dig into critical mutexes, queues and sections of your code
  • Dynamically manage thread groups and add newly spawned threads to groups in the CLI
  • Switch between threads, view objects, and control execution
  • View data for an individual thread or for a specific object across all threads.
  • TotalView gives you a single window for many threads of execution. You can control (e.g., step, run) a single thread individually, or create a group of threads and control them in lockstep. It's your choice. Track, step, and control threads to meet your debugging needs. If your code is threaded, you owe it to yourself to try TotalView.
  • TotalView also supports debugging of multithreaded core files. It shows you in which thread the error occurred and lets you view state information about other threads. (Multithreaded core file debugging is not available on all platforms.)
  • If you're new to threads, you may want to read our Threads Primer. If you're a seasoned threads programmer, you might still be interested in reviewing Chapter 11 of our Users Guide.
  • On most operating systems, TotalView lets you control your program at the thread level. For example, if you think your problem is in thread 3 of process 2, you can hold all processes and threads in your program except thread 3 of process 2. You can then proceed to debug just that thread.
  • TotalView makes viewing data in a threaded program as easy as viewing data for single process code. You can view data from an individual thread, or you can choose to view data across all threads with TotalView's laminate feature.
  • Navigating among hundreds of threads can feel cumbersome. TotalView simplifies navigation with both the Root Window and the Thread Tab of the Process Window. Both windows display the threads in your program. The Root Window displays all threads in relation to the parent process in a hierarchical manner, so that all threads that comprise a process are grouped together. The Thread Tab displays threads in context of the process that currently is executing in the Process Window. Each window displays the current status as well as other information about the threads. In addition to viewing status at a glance, you can use the thread lists for navigation.
  • The TotalView $tid built-in function lets you write thread-specific conditional breakpoints. For example, if you want your program to stop on thread 5, you can create a conditional breakpoint with the following expression: if ($tid == 5) $stop; When this breakppoint executes, TotalView will only stop thread 5. (figure 3). Other threads will continue running.
  • TotalView is used by leading corporations, research labs, and government institutions around the world that are developing and using applications requiring massive amounts of data, have thousands or millions of lines of code and often employ extensive parallelism. In many cases, TotalView is literally the only debugger that is capable of handling the volume and complexity of these codes or the number of processes they require. TotalView scales transparently up to thousands of processors or processes, so whether you're debugging serial code or massively parallel, TotalView's interface and architecture enhance, not hinder, your debugging session.
  • Though the lists changes frequently these days, the majority of the very top computer systems in the world feature TotalView as one of the few, if not the only application they have in common. This is because, where others boast of their ability to scale, TotalView delivers as no other debugger can. And where other tools sometimes deliver suspect results when debugging challenging and innovative code, TotalView gives trustworthy and accurate results.
  • With over 19 years of continuous development and refinement, a dedicated engineering and support staff and an entire company are dedicated to this product as its core bread and butter product. TotalView resembles the world's leading business applications far more than it does other development tools. And TotalView Technologies is committed to continuing to widen its substantial leadership position in debugging technology.

last updated on:
August 27th, 2009, 7:46 GMT
file size:
60.7 MB
license type:
developed by:
TotalView Technologies LLC
operating system(s):
Mac OS X 10.4 or later
binary format:
Intel only
Home \ Developer Tools
TotalView Debugger

In a hurry? Add it to your Download Basket!

user rating 15



Rate it!
3 Screenshots
TotalView DebuggerTotalView Debugger
What's New in version 8.5.0-0
  • This new version adds support for the IBM Cell Broadband Engine.
read full changelog

Add your review!