Glossary

action point

A debugger feature that allows a user to request that program execution stop under certain conditions. Action points include breakpoints, watchpoints, evaluation points, and barriers.

action point identifier

A unique integer ID associated with an action point.

address space

A region of memory that contains code and data from a program. One or more threads can run in an address space. A process normally contains an address space.

affected p/t set

The set of process and threads that will be affected by the command. For most commands, this is identical to the target P/T set, but in some cases it may include additional threads. (See P/T (process/thread) set for more information.)

aggregated output

The CLI compresses output from multiple threads when they would be identical except for the P/T identifier.

arena

A specifier that indicates the processes, threads, and groups upon which a command executes. Arena specifiers are p (process), t (thread), g (group), d (default), and a (all).

asynchronous

IWhen processeses communicate with one another, they send messages. If a process decides that it does not want to wait for an answer, it is said to run "asynchronously". For example, in most client/server programs, one program sends an RPC request to a second program and then waits to receive a response from the second program. This is the normal synchronous mode of operation. If, however, the first program sends a message and then continues executing, not waiting for a reply, the first mode of operations is said to be asynchronous.

automatic process acquisition

TotalView automatically detects the many processes that parallel and distributed programs run in, and attaches to them automatically so you do not have to attach to them manually. This process is called automatic process acquisition. If the process is on a remote machine, automatic process acquisition automatically starts the TotalView Debugger Server (the tvdsvr).

barrier

An action point specifying that processes reaching a particular location in the source code should stop and wait for other processes to catch up.

base window

The original Process Window or Variable Window before you dive into routines or variables. After diving, you can use a Reset or Undive command to restore this original window.

blocked

A thread state where the thread is no longer executing because it is wating for an event to occur. In most cases, the thread is blocked because it is waiting for a mutex or condition state.

breakpoint

A point in a program where execution can be suspended to permit examination and manipulation of data.

call stack

A higher-level view of stack memory, interpreted in terms of source program variables and locations.

child process

A process created by another process (see parent process) when that other process calls fork().

closed loop

see closed loop.

cluster debugging

The action of debugging a program that is running on a cluster of hosts in a network. Typically, the hosts are homogeneous.

command history list

A debugger-maintained list storing copies of the most recent commands issued by the user.

condition synchronizaton

A process that delays thread execution until a condition is satisfied.

contextually qualified (symbol)

A symbol that is described in terms of its dynamic context, rather than its static scope. This includes process identifier, thread identifier, frame number, and variable or subprocedure name.

core file

A file containing the contents of memory and a list of thread registers. The operating system dumps (creates) a core file whenever a program exits because of a severe error (such as an attempt to store into an invalid address).

core-file debugging

A debugging session that examines a core file image. Commands that modify program state are not permitted in this mode.

cross-debugging

A special case of remote debugging where the host platform and the target platform are different types of machines.

current frame

The current portion of stack memory, in the sense that it contains information about the subprocedure invocation that is currently executing.

current language

The source code language used by the file containing the current source location.

current list location

The location governing what source code will be displayed in response to a list command.

dataset

A set of array elements generated by TotalView and sent to the Visualizer. (See visualizer process.)

dbelog library

A library of routines for creating event points and generating event logs from within TotalView. To use event points, you must link your program with both the dbelog and elog libraries.

dbfork library

A library of special versions of the fork() and execve() calls used by the TotalView debugger to debug multiprocess programs. If you link your program with TotalView's dbfork library, TotalView will be able to automatically attach to newly spawned processes.

debugging information

Information relating an executable to the source code from which it was generated.

debugger initialization file

An optional file establishing initial settings for debugger state variables, user-defined commands, and any commands that should be executed whenever TotalView or the CLI is invoked. Must be called .tvdrc.

debugger prompt

A string printed by the CLI that indicates that it is ready to receive another user command.

debugger server

See tvdsvr process.

debugger state

Information that TotalView or the CLI maintains in order to interpret and respond to user commands. Includes debugger modes, user-defined commands, and debugger variables.

distributed debugging

The action of debugging a program that is running on more than one host in a network. The hosts can be homogeneous or heterogeneous. For example, programs written with message-passing libraries such as Parallel Virtual Machine (PVM) or Parallel Macros (PARMACS) run on more than one host.

dive stack

A series of nested dives that were performed in the same variable window. The number of greater-than symbols (>) in the upper left-hand corner of a Variable Window indicates the number of nested dives on the dive stack. Each time that you undive, TotalView pops a dive from the dive stack and decrements the number of greater-than symbols shown in the Variable Window.

diving

The action of displaying more information about an item. For example, if you dive into a variable in TotalView, a window appears with more information about the variable.

dope vector

This is a runtime descriptor that contains all information about an object that requires more information than is available as a single pointer or value. For example, you might declare a Fortran 90 pointer variable that is a pointer to some other object but which has its own upper bound as follows:

integer, pointer, dimension (:) :: iptr

Assume that you initialize it as follows:

iptr => iarray (20:1:-2)

iptr is now a synonym for every other element in the first twenty elements of iarray and this pointer array is in reverse order. For example, iptr(1) maps to iarray(20), iptr(2) maps to iarray(18), and so on.

A compiler represents an iptr object using a run time descriptor) that contains (at least) elements such as a pointer to the first element of the actual data, a stride value, and a count of the number of elements (or equivalently an upper bound).

dpid:

Debugger ID. This is the ID TotalView uses for processes.

editing cursor

A black rectangle that appears when a TotalView GUI field is selected for editing. You use field editor commands to move the editing cursor.

evaluation point

A point in the program where TotalView evaluates a code fragment without stopping the execution of the program.

event log

A file containing a record of events for each process in a program.

event point

A point in the program where TotalView writes an event to the event log for later analysis with TimeScan.

executable

A compiled and linked version of source files, containing a "main" entry point.

expression

An expression consists of symbols (possibly qualified), constants, and operators, arranged in the syntax of the current source language. Not all Fortran 90, C, and C++ operators are supported.

extent

The number of elements in the dimension of an array. For example, a Fortran array of integer(7,8) has an extent of 7 in one dimension (7 rows) and an extent of 8 in the other dimension (8 columns).

field editor

A basic text editor that is part of TotalView's interface. The field editor supports a subset of GNU Emacs commands.

focus

The set of groups, processes, and threads upon which a CLI command acts. The current focus is indicated in the CLI prompt (if you are using the default prompt).

frame

An area in stack memory containing the information corresponding to a single invocation of a subprocedure.

fully qualified (symbol)

A symbol is fully qualified when each level of source code organization is included. For variables, those levels are executable or library, file, procedure or line number, and variable name.

gid

The TotalView group ID.

goi

The group of interest. This is the group that TotalView uses when it is trying to determine what to step, stop, and the like.

gridget

A dotted grid in the tag field that indicates you can set an action point on the instruction.

group

When TotalView starts processes, it places related processes in families. These families are called "groups."

group of interest

The primary group that is affected by a command.

heap

An area of memory that your program uses when it dynamically allocates blocks of memory. It is also how people describe my car.

host machine

The machine on which the TotalView debugger is running.

initial process

The process created as part of a load operation, or that already existed in the run-time environment and was attached by TotalView or the CLI.

infinite loop

See loop, infinite.

lvalue

A symbol name or expression suitable for use on the left-hand side of an assignment statement in the corresponding source language. That is, the expression must be appropriate as the target of an assignment.

lhs expression

This is a synonym for lvalue.

loop, infinite

see infinite loop.

lower bound

The first element in the dimension of an array or the slice of an array. By default, the lower bound of an array is 0 in C and 1 in Fortran, but the lower bound can be any number, including negative numbers.

machine state

Convention for describing the changes in memory, registers, and other machine elements as execution proceeds.

message queue

A list of messages sent and received by message-passing programs.

mpich

MPI/Chameleon (Message Passing Interface/Chameleon) is a freely available and portable MPI implementation. MPICH was written as a collaboration between Argonne National Lab and Mississippi State University. For more information, see www.mcs.anl.gov/mpi.

mpmd (multiple program multiple data) programs

A program involving multiple executables, executed by multiple threads and processes.

mutex (mutual exclusion)

Techniques for sharing resources so that different users do not conflict and cause unwanted interactions.

native debugging

The action of debugging a program that is running on the same machine as TotalView.

nested dive

TotalView lets you dive into pointers, structures, or arrays within a variable. When you dive into one of these elements, TotalView updates the display so that the new element is displayed. So, a nested dive is a dive within a dive. You can return to the previous display by selecting the left-facing arrow in the top right corner of the window.

node

A machine on a network. Each machine has a unique network name and address.

out of scope

When symbol lookup is performed for a particular symbol name and it is not found in the current scope or any containing scopes, the symbol is said to be out of scope.

parallel program

A program whose execution involves multiple threads and processes.

parallel tasks

Tasks whose computations are independent of each other, so that all such tasks can be performed simultaneously with correct results. (llnl)

parallelizable problem

A problem that can be divided into parallel tasks. This may require changes in the code and/or the underlying algorithm. (llnl)

parcel

The number of bytes required to hold the shortest instruction for the target architecture.

parent process

A process that calls fork() to spawn other processes (usually called "child processes").

parmacs library

A message-passing library for creating distributed programs that was developed by the German National Research Centre for Computer Science.

partially qualified (symbol)

A symbol name that includes only some of the levels of source code organization (for example, filename and procedure, but not executable). This is permitted as long as the resulting name can be associated unambiguously with a single entity.

pc

This is an abbreviation for Program Counter.

pid

Depending on context, this is either the "process ID" or the the "program ID". In most cases, this will be a process ID.

poi

The process of interest. This is the process that TotalView uses when it is trying to determine what to step, stop, and the like.

process

An executable that is loaded into memory and is running (or capable of running).

process group

A group of processes associated with a multiprocess program. A process group includes program control groups and share groups.

process/thread identifier

A unique integer ID associated with a particular process and thread.

process of interest

The primary process that is affected by a command.

program event

A program occurrence that is being monitored by TotalView or the CLI, such as a breakpoint.

program control group

A group of processes that includes the parent process and all related processes. A program control group includes children that were forked (processes that share the same source code as the parent) and children that were forked with a subsequent call to execve() (processes that do not share the same source code as the parent). Contrast with share group.

program state

A higher-level view of the machine state, where addresses, instructions, registers, and such, are interpreted in terms of source program variables and statements.

P/T (process/thread) set

The set of threads drawn from all threads in all processes of the target program.

pvm library

Parallel Virtual Machine library. A message-passing library for creating distributed programs that was developed by the Oak Ridge National Laboratory and the University of Tennessee.

race condition

A problem that occurs when threads try to simultaneously access a resource. The result can be a deadlock, data corruption, or a program fault.

remote debugging

The action of debugging a program that is running on a different machine than TotalView. The machine on which the program is running can be located many miles away from the machine on which TotalView is running.

resume commands

Commands that cause execution to restart from a stopped state: dstep, dgo, dcont, dwait.

rhs expression

This is a synonym for rvalue.

rvalue

An expression suitable for inclusion on the right-hand side of an assignment statement in the corresponding source language. In other words, an expression that evaluates to a value or collection of values.

satisfaction set

The set of processes and threads that must be held before a barrier can be satisfied.

satisfied

A condition indicating that all processes or threads in a group have reached a barrier. Prior to this event, all executing processes and threads are either running because they have not yet hit the barrier or are being held at the barrier because not all of the processes or threads have reached it. After the barrier is satisfied, the held processes or threads are released, which means they can now be run. Prior to this event, they could not be run.

serial execution

Execution of a program sequentially, one statement at a time. (llnl)

serial line debugging

A form of remote debugging where TotalView and the TotalView Debugger Server communicate over a serial line.

share group

A group of processes that includes the parent process and any related processes that share the same source code as the parent. Contrast with program control group.

shared library

A compiled and linked set of source files that are dynamically loaded by other executables--and have no "main" entry point.

signals

Messages informing processes of asynchronous events, such as serious errors. The action the process takes in response to the signal depends on the type of signal and whether or not the program includes a signal handler routine, a routine that traps certain signals and determines appropriate actions to be taken by the program.

single step

The action of executing a single statement and stopping (as if at a breakpoint).

slice

A subsection of an array, which is expressed in terms of a lower bound, upper bound, and stride. Displaying a slice of an array can be useful when working with very large arrays, which is often the case in Fortran programs.

source file

Program file containing source language statements. TotalView allows you to debug FORTRAN 77, Fortran 90, Fortran 95, C, C++, and assembler.

source location

For each thread, the source code line it will execute next. This is a static location, indicating the file and line number; it does not, however, indicate which invocation of the subprocedure is involved.

spawned process

The process created by a user process executing under debugger control.

spmd (single program multiple data) programs

A program involving just one executable, executed by multiple threads and processes.

stack

A portion of computer memory and registers used to hold information temporarily. The stack consists of a linked list of stack frames that holds return locations for called routines, routine arguments, local variables, and saved registers.

stack frame

A section of the stack that contains the local variables, arguments, contents of the registers used by an individual routine, a frame pointer pointing to the previous stack frame, and the value of the program counter (PC) at the time the routine was called.

stack pointer

A pointer to the area of memory where subprocedure arguments, return addresses, and similar information is stored.

stack trace

A sequential list of each currently active routine called by a program and the frame pointer pointing to its stack frame.

static (symbol) scope

A region of a program's source code that has a set of symbols associated with it. A scope can be nested inside another scope.

stepping

Advancing program execution by fixed increments, such as by source code statements.

stop set

A set of threads that should be stopped once an action point has been triggered.

stopped/held state

The state of a process whose execution has paused in such a way that another program event (for example, arrival of other threads at the same barrier) will be required before it is capable of continuing execution.

stopped/runnable state

The state of a process whose execution has been paused (for example, when a breakpoint triggered or due to some user command) but can continue executing as soon as a resume command is issued.

stopped state

The state of a process that is no longer executing, but will eventually execute again. This is subdivided into stopped/runnable and stopped/held.

stride

The interval between array elements in a slice and the order in which the elements are displayed. If the stride is 1, every element between the lower bound and upper bound of the slice is displayed. If the stride is 2, every other element is displayed. If the stride is -1, every element between the upper bound and lower bound (reverse order) is displayed.

symbol

Entities within program state, machine state, or debugger state.

symbol lookup

Process whereby TotalView consults its debugging information to discover what entity a symbol name refers to. Search starts with a particular static scope and occurs recursively so that containing scopes are searched in an outward progression.

symbol name

The name associated with a symbol known to TotalView (for example, function, variable, data type, and such).

symbol table

A table of symbolic names (such as variables or functions) used in a program and their memory locations. The symbol table is part of the executable object generated by the compiler (with the -g option) and is used by debuggers to analyze the program.

synchronization

A mechanism that prevents problems caused by concurrent threads manipulating shared resources. The two most common mechanisms for synchronizing threads are mutual exclusion and condition synchronization.

tag field

The left margin in the Source Pane of the TotalView Process Window containing boxed line numbers marking the lines of source code that actually generate executable code.

target machine

The machine on which the process to be debugged is running.

target process set

The target set for those occasions when operations can only be applied to entire processes, not to individual threads within a process.

target program

The executing program that is the target of debugger operations.

target p/t set

The set of processes and threads upon which a CLI command will act.

task

A logically discrete section of computational work. (This is an informal definition.) (llnl)

thread

An execution context that normally contains a set of private registers and a region of memory reserved for an execution stack. A thread runs in an address space.

thread execution state

The convention of describing the operations available for a thread, and the effects of the operation, in terms of a set of predefined states.

thread of interest

The primary thread that will be affected by a command.

tid

The thread ID.

toi

The thread of interest. This is the primary thread that will be affected by a command.

trigger set

The set of threads that can trigger an action point (that is, the threads upon which the action point was defined).

triggers

The effect during execution when program operations cause an event to occur (such as, arriving at a breakpoint).

tvdsvr process

The TotalView Debugger Server process, which facilitates remote debugging by running on the same machine as the executable and communicating with TotalView over a TCP/IP port or serial line.

undiving

The action of displaying the previous contents of a window, instead of the contents displayed for the current dive. To undive, you dive on the undive icon in the upper right-hand corner of the window.

upper bound

The last element in the dimension of an array or the slice of an array.

user interrupt key

A keystroke used to interrupt commands, most commonly defined as ^C (Ctrl-C).

variable window

A TotalView window displaying the name, address, data type, and value of a particular variable.

visualizer process

A process that works with TotalView in a separate window, allowing you to see a graphical representation of program array data.

watchpoint

An action point specifying that execution should stop whenever the value of a particular variable is updated.