Contents

1 TotalView Features

TotalView Advantages

TotalView Windows

Multiprocess Programs

Multithreaded Programs

Controlling Processes and Threads

Using Action Points

Examining and Manipulating Data

Visualizing Array Data

Distributed Debugging

Context-Sensitive Help

2 TotalView Basics

Compiling Programs

Starting TotalView

Using the Mouse Buttons

Using Menu and Keyboard Commands

Getting Help

Using the Primary Windows

Starting a Process

Sizing Process Window Panes

Navigating in the Process Window

Navigating in the Root Window

Scrolling Windows and Fields

Scrolling Windows

Scrolling Multiline Fields

Diving into Objects

Editing Text

Searching for Text

Using the Spelling Corrector

Saving the Contents of Windows

Exiting from TotalView

3 Setting Up a Debugging Session

Compiling Programs

Starting the TotalView Debugger

Loading Executables

Loading a New Executable

Reloading a Recompiled Executable

Attaching to Processes

Attaching Using Show All Unattached Processes

Attaching Using the New Program Window

Detaching from Processes

Examining a Core File

Determining the Status of Processes and Threads

Process Status

Thread Status

Unattached Process States

Attached Process States

Handling Signals

Setting Search Paths

Setting Command Arguments

Setting Environment Variables

Setting Input and Output Files

Monitoring TotalView Sessions

4 Setting Up Remote Debugging Sessions

Debugging Remote Processes

Loading a Remote Executable

Attaching to a Remote Process

Connecting to Remote Machines

Starting the Debugger Server for Remote Debugging

Single Process Server Launch Options

Bulk Launch Window Options

Starting the Debugger Server Manually

Single Process Server Launch Command

Bulk Server Launch on an SGI MIPs Machine

Bulk Server Launch on an IBM RS/6000 AIX Machine

Disabling Auto-Launch

Changing the Remote Shell Command

Changing the Arguments

Auto-launch Sequence

Debugging Over a Serial Line

Start the TotalView Debugger Server

Starting TotalView on a Serial Line

New Program Window

5 Setting Up Parallel Debugging Sessions

Debugging MPI Applications

Debugging MPICH Applications

Starting TotalView on an MPICH Job

Attaching to an MPICH Job

MPICH P4 procgroup Files

Debugging Compaq MPI Applications

Attaching to a Compaq MPI Job

Debugging HP MPI Applications

Attaching to an HP MPI Job

Debugging IBM MPI (PE) Applications

Preparing to Debug a PE Application

Starting TotalView on a PE Job

Setting Breakpoints

Starting Parallel Tasks

Attaching to a PE Job

Attaching From a Node Running poe

Attach From a Node Not Running poe

Debugging SGI MPI Applications

Attaching to an SGI MPI Job

Debugging QSW RMS2 Applications

Attaching to an RMS2 Job

Displaying Message Queue State

Message Queue Display Basics

Message Operations

MPI Process Diving

MPI Buffer Diving

Pending Receive Operations

Unexpected Messages

Pending Send Operations

MPI Debugging Troubleshooting

Debugging OpenMP Applications

Debugging an OpenMP Program

OpenMP Private and Shared Variables

OpenMP THREADPRIVATE Common Blocks

OpenMP Stack Parent Token Line

Debugging PVM and DPVM Applications

Setting Up ORNL PVM Debugging

Starting an ORNL PVM Session

Starting a DPVM Session

PVM/DPVM Automatic Process Acquisition

Attaching to PVM/DPVM Tasks

Shared Memory Code

Debugging Portland Group, Inc. HPF Applications

Starting TotalView with HPF

Dynamically Loaded Library

Setting Up PGI HPF Compiler Defaults

Setting Up MPICH

Setting TotalView Defaults for HPF

Compiling HPF for Debugging

Starting HPF Programs

PGI HPF smp and rpm libraries

Starting HPF Programs with MPICH

Workstation Clusters Using MPICH

IBM Parallel Environment

Parallel Debugging Tips

General Parallel Debugging Tips

MPICH Debugging Tips

IBM PE Debugging Tips

6 Debugging Programs

Finding the Source Code for Functions

Resolving Ambiguous Names

Finding the Source Code for Files

Examining Source and Assembler Code

Current Stack Frame

Editing Source Text

Interpreting Status and Control Registers

Stopping Processes and Threads

Holding and Releasing Processes

Examining Process Groups

Displaying Process Groups

Changing Program Groups

Finding Active Processes

Starting Processes and Threads

Creating a Process without Starting it

Creating a Process by Single-Stepping

Single Stepping

Process-level Single Stepping

Group-level Single Stepping

Thread-level Single Stepping

Thread-level Control

Selecting Source Lines

Single-Step Commands

Stepping Into Function Calls

Stepping Over Function Calls

Executing to a Selected Line

Executing to the Completion of a Function

Displaying Thread and Process Locations

Continuing with a Specific Signal

Setting the Program Counter

Deleting Programs

Restarting Programs

7 Examining and Changing Data

Displaying Variable Windows

Displaying Local Variables and Registers

Displaying a Global Variable

Displaying All Global Variables

Displaying Areas of Memory

Displaying Machine Instructions

Closing Variable Windows

Diving in Variable Windows

Changing the Values of Variables

Changing the Data Type of Variables

How TotalView Displays C Data Types

C Cast Syntax

Pointers to Arrays

Arrays

Typedefs

Structures

Unions

Built-In Types

Character arrays (<string> Data Type)

Areas of memory (<void> Data Type)

Instructions (<code> Data Type)

Type Casting Examples

Example: Displaying the argv Array

Example: Displaying Declared Arrays

Example: Displaying Allocated Arrays

Opaque Type Definitions

Changing the Address of Variables

Changing Types to Display Machine Instructions

Displaying C++ Types

Classes

Changing Class Types in C++

Displaying Fortran Types

Displaying Fortran Common Blocks

Displaying Fortran Module Data

Debugging Fortran 90 Modules

Fortran 90 User Defined Type

Fortran 90 Deferred Shape Array Type

Fortran 90 Pointer Type

Arrays

Displaying Array Slices

Slice Definitions

Example 1

Example 2

Example 3

Example 4

Using Slices in the Variable Command

Array Data Filtering

Filtering by Comparison

Filtering for IEEE Values

Filtering by Range of Values

Array Filter Expressions

Filter Comparisons

Filtering Array Data

Sorting Array Data

Array Statistics

Displaying a Variable in All Processes or Threads

Diving in a Laminated Pane

Editing a Laminated Variable

Visualizing Array Data

Visualizing a Laminated Data Pane

Displaying Thread Objects

Displaying Mutex Information

Displaying Condition Variable Information

Displaying Read-Write Lock Information

Displaying PThread-Specific Data Key Information

8 Setting Action Points

Action Points Overview

Setting Breakpoints and Barriers

Setting Source-Level Breakpoints

Selecting Ambiguous Source Lines

Diving into Ambiguous Source Lines

Toggling Breakpoints at Locations

Ambiguous Locations

Setting Machine-Level Breakpoints

Thread-Specific Breakpoints

Breakpoints for Multiple Processes

Breakpoint when using fork()/execve()

Processes That Call fork()

Processes That Call execve()

Example: Multiprocess Breakpoint

Process Barrier Breakpoints

Process Barrier Breakpoint States

Setting a Process Barrier Breakpoint

Releasing Processes from Process Barrier Points

Deleting a Process Barrier Point

Changes when Setting and Clearing a Barrier Point

Toggling Between a Breakpoint and a Process Barrier Point

Displaying the Action Points Window

Displaying and Controlling Action Points

Defining Evaluation Points

Setting Evaluation Points

Setting Conditional Breakpoints

Patching Programs

Conditionally Patching Out Code

Patching In a Function Call

Correcting Code

Interpreted Versus Compiled Expressions

Interpreted Expressions

Compiled expressions

Interpreted Versus Compiled Expression Performance

Allocating Patch Space for Compiled Expressions

Dynamic Patch Space Allocation

Static Patch Space Allocation

Controlling Evaluation Points

Using Watchpoints

Architectures

Creating Watchpoints

Displaying Watchpoints using the Action Points Window

Watching Memory

Triggering Watchpoints

The Program Counter after a Watchpoint Triggers

Multiple Watchpoints

Data Copies

Conditional Watchpoints

Saving Action Points in a File

Evaluating Expressions

Writing Code Fragments

Intrinsic Variables

Built-In Statements

C Constructs Supported

Data Types and Declarations

Statements

Fortran Constructs Supported

Data Types and Declarations

Statements

Writing Assembler Code

9 Visualizing Data

How the Visualizer Works

Configuring TotalView to Launch the Visualizer

Data Types that TotalView Can Visualize

Visualizing Data from the Variable Window

Visualizing Data in Expressions

Visualizer Animation

The TotalView Visualizer

Directory Window

Data Windows

Views of Data

Graph Data Window

Displaying Graphs

Manipulating Graphs

Surface Data Window

Displaying Surface Data

Manipulating Surface Data

Launching the Visualizer from Command Line

Adapting a Third Party Visualizer

10 Troubleshooting

Overview

The Problems

11 X Resources

TotalView X Resources

Visualizer X Resources

12 TotalView Command Syntax

Syntax

Options

13 TotalView Debugger Server Command Syntax

Replacement Characters

A Compilers and Environments

Compiling with Debugging Symbols

AIX on RS/6000 Systems

Compaq Tru64 UNIX

HP-UX

IRIX on SGI MIPS Systems

SunOS 5 on SPARC

Using Exception Data on Compaq Tru64 UNIX

Linking with the dbfork Library

AIX on RS/6000 Systems

Linking C++ Programs with dbfork

Compaq Tru64 UNIX

HP-UX

SunOS 5 SPARC

IRIX6-MIPS

B Operating Systems

Supported Operating Systems

Mounting the /proc File System

Compaq Tru64 UNIX, SunOS 5, and IRIX

Compaq Tru64 UNIX and SunOS 5

IRIX

Swap Space

Compaq Tru64 UNIX

AIX

HP HP-UX

Maximum data size

SunOS 5

IRIX

Linux

Shared Libraries

Using Shared Libraries on HP-UX

Debugging Dynamically Loaded Libraries

Known Limitations

Remapping Keys

Expression System

IBM AIX

Compaq Tru64 UNIX

SGI IRIX

C Architectures

Power

Power General Registers

Power MSR Register

Power Floating-Point Registers

Power FPSCR Register

Using the Power FPSCR Register

Power Floating-Point Format

HP PA-RISC

PA-RISC General Registers

PA-RISC Process Status Word

PA-RISC Floating-Point Registers

PA-RISC Floating-Point Format

SPARC

SPARC General Registers

SPARC PSR Register

SPARC Floating-Point Registers

SPARC FPSR Register

Using the SPARC FPSR Register

SPARC Floating-Point Format

Alpha

Alpha General Registers

Alpha Floating-Point Registers

Alpha FPCR Register

Alpha Floating-Point Format

MIPS

MIPS General Registers

MIPS SR Register

MIPS Floating-Point Registers

MIPS FCSR Register

Using the MIPS FCSR Register

MIPS Floating-Point Format

MIPS Delay Slot Instructions

Intel-x86

Intel-x86 General Registers

Intel-x86 Floating-Point Registers

Intel-x86 FPCR Register

Using the Intel-x86 FPCR Register

Intel-x86 FPSR Register

Intel-x86 Floating-Point Format

Glossary

Index

support@etnus.com Version 4.1 Copyright © 2000, Etnus, LLC. All rights reserved.