510.226.7366 | sales@exxactcorp.com |

Workstation Graphics and HPC Solutions  

Contact Us

Have questions about our products and solutions? Just ask. Call to talk with a knowledgeable Sales Specialist at 510.226.7366.

Send Inquiry

social media top
Exxact_social media 1 Exxact_facebook Exxact_youtube Exxact_twitter Exxact_social media2
visit Exxact on soical media
TotalView® - A comprehensive debugging solution for parallel and multi-core applications
Dynamic source code and memory debugging for C, C++ and Fortran applications on LINUX
Traditional tools and methods for debugging and analyzing code, like simple command line debuggers, are not appropriate for the challenges of complex application development. Parallel,multi-core processing technology demands a reevaluation of the art of software development. Writing applications for distributed and multi-core environments requires more complex code, with ever more complicated interactions and timings. With TotalView, developers can debug programs on small multi-core workstations running a couple of threads, or massive applications on supercomputers running thousands of processes. Save effort and time while confidently producing higher quality code. With flexible licensing options that meet organizations’ evolving needs, TotalView is the perfect tool for every size development team.
C and C++: Comprehensive support for objects, templates, and user data display in STL collection objects
Fortran and Fortran 90: First class support for common blocks, user defined types, pointers,and modules
Data visualization: Unparalleled visibility into program data: structures, objects, variables, and arrays
Multi-process: Debug parallel applications in a single session. View and control individual processes or groups of processes
Unattended batch debugging with TVScript: Troubleshoot bugs in regular non-interactive batch environments
Long distance remote display: Connect from a Linux, Mac or Windows system – from down the hall or across the globe
TotalView Product Highlights:
Parallel and Multithreaded Debugging
Advanced Memory Debugging
CUDA and OpenACC Debugging
Reverse Debugging
Intel® Xeon Phi™ Coprocessor Debugging
Parallel and Multithreaded Debugging
TotalView is a source code debugger for troubleshooting complex, multithreaded,or multi-process programs. TotalView technology providescomprehensive support for OpenMP, MPI, UPC and GA. Because today’s processor architectures are characterized by multi-core and manycore designs, building a multi-threaded application or transitioning from a serial application to a parallel application presents significant challenges. TotalView is designed to help you manage the challenges presented by concurrency, parallelism and threads.
• Operate with equal ease on single threads/processes or with groups of threads/processes
• Set breakpoints with thread or process width to synchronize or use barrier constructs
• Control the execution of threads or processes individually or in groups
• View program data and threads/processes in a simple tree view with parallel backtrace
• Troubleshoot deadlocks and race conditions using TotalView’s asynchronous thread control
• Work with automatically defined ‘lockstep groups’, define custom groups based on characteristics, or enumerate arbitrary groups
MPI Support: With support for more than 20 implementations of MPI, TotalView has been the debugger of choice in HPC environments and parallel programming courses.
• View variables across the threads of a process or the MPI tasks of a parallel job
• View MPI message queues by text or graphical depiction
• Identify deadlocks based on automatic cycle detection in the message queue graph
• Computational cluster support for all major MPI implementations, interconnects and batch systems
• Support for hybrid applications that combine MPI together with OpenMP, Xeon Phi and/ or CUDA
Advanced Memory Debugging
TotalView includes MemoryScape, a powerful, easy-to-use memory debugging tool that can be used in a variety of ways:
1. Interactively – explore memory usage visually and diagnose memory errors, exercising the perfect combination of visibility and control when analyzing memory problems
2. Scripted – validate code as part of a high-productivity and qualityfocused development and testing methodology; detect and diagnose parallel memory errors in unattended batch sessions
3. Stand-alone – use MemoryScape on its own as a parallel-aware, lowoverhead replacement for other memory debugging tools
4. As part of TotalView – exercise the perfect combination of visibility and control when analyzing memory problems
5. Collaboratively – share rich and useful information about memory errors that are identified with collaborators or library vendors
No matter how it is used, MemoryScape provides powerful memory error detection and analysis tools that have a low performance overhead. Stateof- the-art, interactive interfaces allow exploration and identification of heap memory status in programs.
• Support for multi-process and hybrid applications in clusters using MPI and/or OpenMP, and for multi-threaded applications using OpenMP and pthreads on workstations and servers
• Low runtime overhead
• No need to recompile applications
• Detect leaks and errors in vendor libraries (or filter them out of your analysis)
• Track and interpret allocated, deallocated, and leaked memory blocks
• Detect memory leaks and events early – even a single leaked allocation can be detected, and events can be flagged before they crash your application
• Detect corrupted memory – bounds errors and buffer overruns can generate invalid results or lead to program instability
• Analyze memory usage patterns – optimize applications or scale them up to run on the latest supercomputers
CUDA and OpenACC Debugging
TotalView on Linux includes CUDA-based, NVIDIA accelerator debugging and early access support for debugging OpenACC code compiled with Cray CCE compilers. The graphical presentation makes it easier to step through either host code, CUDA kernels, or OpenACC outlined regions to diagnose issues.
CUDA specific features supported in TotalView include the following:
• Linux and GPU device thread visibility
• Debugging host and device code in the same session
• Linux and GPU device thread visibility
• Full visibility to the hierarchical device, block, and thread memory
• Navigating device threads by logical and device coordinates
• CUDA function calls, host pinned memory regions and CUDA contexts
• Handling CUDA functions inline and on the stack
• Command line interface (CLI) commands for CUDA functions
• Applications that use multiple NVIDIA devices simultaneously
• MPI applications on CUDA-accelerated clusters
• Unified Virtual Addressing and GPUDirect
• CUDA C++ and inline PTX
• Reporting memory errors and handling CUDA exceptions
Reverse Debugging
With ReplayEngine, an integral component of TotalView on x86 Linux systems, scientists and developers can streamline and simplify the troubleshooting process by deterministically replaying a program’s behavior, going back to the root cause of the failure without repetitive restarts and stops. This new approach-working back from a failure, error, or crash to its origin - eliminates the need to restart a program repeatedly with different breakpoint locations. The ability to do reverse debugging, stepping freely both forwards and backwards through program execution, drastically reduces the amount of time invested in troubleshooting your code.
• Freedom to explore application execution either backwards or forwards
• Record: capture function calls, network applications, file I/O, thread behavior, and context switches
• Replay: step back through execution history and review all variables and program behavior at any point
• Switch seamlessly between Record and Replay
• Analyze race conditions and other hard-to-reproduce bugs in a deterministic session
• Go back and look at functions and variables in the context of the crash or error
• Easily follow the logic of unfamiliar routines – great for both code reviews and legacy code
• Set a watchpoint and run back to find the source of unexpected data in variables or arrays
• Enable recording in the middle of a debugging session without needing to detach
• Record and replay MPI programs using Ethernet, Infiniband, or the Cray Gemini series interconnects
Intel® Xeon Phi™ Coprocessor Debugging
Intel® Many Integrated Core (MIC) architecture, the heart of the Intel Xeon Phi coprocessors, ushers in a new era of supercomputing speed, performance, and compatibility. TotalView's tools and libraries are designed to help developers create high performance, highly parallel applications - making the Intel Xeon Phi coprocessor a natural platform to support. TotalView debugger provides developers the ability to view, control, and debug codes running on both the host processors and the Intel Xeon Phi coprocessors.
Key Capabilities:
• Full asynchronous thread control on both the host and Intel Xeon Phi coprocessor
• Simultaneously view what is happening in both the host and offload processes
• Certain breakpoints are shared across the host and Intel Xeon Phi coprocessor code
• Support for clusters and multi-device configurations
• Support for launching MPI and hybrid MPI + OpenMP applications natively into one or many
• Remote debugging of Intel Xeon Phi coprocessor native applications
• Asynchronous thread control on both Intel Xeon processors and Intel Xeon Phi coprocessors
One debugging session for Intel Xeon Phi coprocessor accelerated code: