A debugger feature that lets a user request that program execution stop under certain conditions. Action points include breakpoints, watchpoints, eval points, and barriers.
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.
The set of process and threads that are affected by the command. For most commands, this is identical to the target P/T set, but in some cases it might include additional threads. (See
“p/t (process/thread) set” for more information.)
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).
In Fortran, a portion of an array that is also an array. The elements of this array is a new unnamed array object with its own indices. Compare this with a TotalView
array 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 you are working with very large arrays. Compare this with a TotalView
array section.
When processes communicate with one another, they send messages. If a process decides that it doesn’t 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 operation is said to be
asynchronous.
When a process begins executing on a remote computer, TotalView can also launch a
tvdsvr (TotalView Debugger Server) process on the computer that will send debugging information back to the TotalView process that you are interacting with.
TotalView automatically detects the many processes that parallel and distributed programs run in, and attaches to them automatically so you don’t have to attach to them manually. If the process is on a remote computer, automatic process acquisition automatically starts the TotalView Debugger Server (
tvdsvr).
An action point specifying that processes reaching a particular location in the source code should stop and wait for other processes to catch up.
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.
A thread state in which the thread is no longer executing because it is waiting for an event to occur. In most cases, the thread is blocked because it is waiting for a mutex or condition state.
A higher-level view of stack memory, interpreted in terms of source program variables and locations. This is where your program places stack frames.
A function reference stored as a pointer. By using the function reference, this function can be invoked. For example, a program can hand off the function reference to an event processor. When the event occurs, the function can be called.
A process created by another process (see “parent process”) when that other process calls the
fork() function.
The action of debugging a program that is running on a cluster of hosts in a network. Typically, the hosts are of the same type and have the same operating system version.
A breakpoint containing an expression. If the expression evaluates to true, program stops. TotalView does not have conditional breakpoints. Instead, you must explicitly tell TotalView to end execution by using the $stop directive.
In a multitasking operating system, the ability of the CPU to move from one task to another. As a switch is made, the operating system must save and restore task states.
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.
All the processes that a program creates. These processes can be local or remote. If your program uses processes that it did not create, TotalView places them in separate control groups. For example, a client/server program has two distinct executables that run independently of one another. Each would be in a separate control group. In contrast, processes created by the
fork() function are in the same control group.
A file that contains 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).
A debugging session that examines a core file image. Commands that modify program state are not permitted in this mode.
Central Processing Unit. The component within the computer that most people think of as “the computer”. This is where computation and activities related to computing occur.
The current portion of stack memory, in the sense that it contains information about the subprocedure invocation that is currently executing.
A library of routines for creating event points and generating event logs from TotalView. To use event points, you must link your program with both the
dbelog and
elog libraries.
A library of special versions of the fork() and
execve() calls used by TotalView to debug multi-process programs. If you link your program with the TotalView
dbfork library, TotalView can automatically attach to newly spawned processes.
A condition where two or more processes are simultaneously waiting for a resource such that none of the waiting processes can execute.
Information that TotalView or the CLI maintains to interpret and respond to user commands. This includes debugger modes, user-defined commands, and debugger variables.
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.
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.
Dynamic Link Library. A shared library whose functions can be dynamically added to a process when a function with the library is needed. In contrast, a statically linked library is brought into the program when it is created.
This is a run time 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:
iptr is 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).
A library that uses dynamic loading to load information in an external file at runtime. Dynamic loading implies dynamic linking, which is a process that does not copy a program and its data into the executable at compile time.
A black line that appears when you select a TotalView GUI field for editing. You use field editor commands to move the editing cursor.
A condition generated at runtime that indicates that a non-standard event has occurred. The program usually creates a method to handle the event. If the event is not handled, either the program's result will be inaccurate or the program will stop executing.
A part of TotalView that evaluates C, C++, and Fortran expressions. An expression consists of symbols (possibly qualified), constants, and operators, arranged in the syntax of a source language. Not all Fortran 90, C, and C++ operators are supported.
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).
The set of groups, processes, and threads upon which a CLI command acts. The current focus is indicated in the CLI prompt (if you’re using the default prompt).
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.
Examining memory to determine if it is still be referenced. If it is not, it sent back to the program's memory manager so that it can be reused.
(from a definition on the Global Arrays web site) The Global Arrays (GA) toolkit provides an efficient and portable “shared-memory” programming interface for distributed-memory computers. Each process in a MIMD parallel program can asynchronously access logical blocks of physically distributed dense multi-dimensional arrays, without need for explicit cooperation by other processes. For more information, see
http://www.emsl.pnl.gov/docs/global/.
The primary group that is affected by a command. This is the group that TotalView uses when it is trying to determine what to step, stop, and so on.
The process created as part of a load operation, or that already existed in the runtime environment and was attached by TotalView or the CLI.
An optional file that establishes 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.
A program that reads programming language statements and translates the statements into machine code, then executes this code.
A program that takes all the object files creates by the compiler and combines them and libraries required by the program into the executable program.
All threads that are at the same PC (program counter). This group is a subset of a workers group. A lockstep group only exists for stopped threads. All threads in the lockstep group are also in a workers group. By definition, all members of a lockstep group are in the same workers group. That is, a lockstep group cannot have members in more than one workers group or more than one control group.
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.
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.
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
http://www.mcs.anl.gov/mpi.
An acronym for Multiple Program, Multiple Data, which describes programs that involve multiple executables, executed by multiple threads and processes.
In the context of high performance computing, this is the ability to divide a program into smaller pieces or tasks that execute separately.
The ability of a program to spawn off separate programs, each having its own context and memory. multi-process programs can (and most often do) run processes on more than one computer. They can also run multiple processes an one computer. In this case, memory can be shared
The ability of a program to spawn off separate tasks that use the same memory. Switching from task to task is controlled by the operating system.
Techniques for sharing resources so that different users do not conflict and cause unwanted interactions.
TotalView lets you dive into pointers, structures, or arrays in a variable. When you dive into one of these elements, TotalView updates the display so that the new element appears. A nested dive is a
dive within a dive. You can return to the previous display by selecting the left arrow in the top-right corner of the window.
(from a definition on the OpenMP web site) OpenMP is a specification for a set of compiler directives, library routines, and environment variables that can be used to specify shared memory parallelism in Fortran and C/C++ programs. The MP in OpenMP stands for Multi Processing. We provide Open specifications for Multi Processing via collaborative work with interested parties from the hardware and software industry, government and academia. For more information, see
http://www.openmp.org/.
When symbol lookup is performed for a particular symbol name and it isn’t found in the current scope or any that contains scopes, the symbol is said to be out-of-scope.
The ability to segregate memory pages so that one process cannot access pages owned by another process. It can also be used to generate an exception when a process tries to access the page.
Tasks whose computations are independent of each other, so that all such tasks can be performed simultaneously with correct results.
A problem that can be divided into parallel tasks. This type of program might require changes in the code and/or the underlying algorithm.
A process that calls the fork() function to spawn other processes (usually called child processes).
A message-passing library for creating distributed programs that was developed by the German National Research Centre for Computer Science.
A symbol name that includes only some of the levels of source code organization (for example, file name and procedure, but not executable). This is permitted as long as the resulting name can be associated unambiguously with a single entity.
Inserting code in a breakpoint that is executed immediately preceding the breakpoint's line. The patch can contain a GOTO command to branch around incorrect code.
An interface that allows debuggers and other programs to control or obtain information from running processes. ptrace also does this, but /proc is more general.
A group of processes associated with a multi-process program. A process group includes program control groups and share groups.
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 the
execve() function (processes that don’t share the same source code as the parent). Contrast this with
share group.
A higher-level view of the machine state, where addresses, instructions, registers, and such are interpreted in terms of source program variables and statements.
This is the ID assigned by the Posix pthreads package. If this differs from the system TID, it is a pointer value that points to the pthread ID.
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.
A data structure whose data is accessed in the order in which it was entered. This is like a line at a tollbooth where the first in is the first out.
A problem that occurs when threads try to simultaneously access a resource. The result can be a deadlock, data corruption, or a program fault.
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.
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.
A condition that indicates 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 be run. Prior to this event, they could not run.
The region in your program in which a variable or a function exists or is defined. This region begins with its declaration and extends to the end of the current block.
A list that contains places that software looks to locate files contained within the file system. In TotalView, the search path contains locations containing your program’s source code.
A thread whose purpose is to service or manage other threads. For example, queue managers and print spoolers are service threads. There are two kinds of service threads: those created by the operating system or runtime system and those created by your program.
All the processes in a control group that share the same code. In most cases, your program has more than one share group. Share groups, like control groups, can be local or remote.
Messages informing processes of asynchronous events, such as serious errors. The action that the process takes in response to the signal depends on the type of signal and whether the program includes a signal handler routine, a routine that traps certain signals and determines appropriate actions to be taken by the program.
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 you are working with very large arrays. Compare this with a TotalView
array section.
An acronym for symbol object ID. A SOID uniquely identifies all TotalView information. It also represents a handle by which you can access this information.
Program file that contains source language statements. TotalView lets you debug FORTRAN 77, Fortran 90, Fortran 95, C, C++, and assembler files.
For each thread, the source code line it executes next. This is a static location, indicating the file and line number; it does not, however, indicate which invocation of the subprocedure is involved.
An acronym for Single Program, Multiple Data, which describe a type of parallel computing that involves just one executable, executed by multiple threads and processes.
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.
Whenever your program calls a function, it creates a set of information that includes 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. The information for one function is called a “stack frame” as it is placed on your program’s stack.
When your program begins executing, it has only one frame: the one allocated for function
main(). As your program calls functions, new frames are allocated. When a function returns to the function from which it is called, the frame is deallocated.
A pointer to the area of memory where subprocedure arguments, return addresses, and similar information is stored. This is also called a frame pointer.
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.
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) is required before it is capable of continuing execution.
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.
The state of a process that is no longer executing, but will eventually execute again. This is subdivided into stopped/runnable and stopped/held.
The interval between array elements in a slice and the order in which TotalView displays these elements. If the stride is 1, TotalView displays every element between the lower bound and upper bound of the slice. If the stride is 2, TotalView displays every other element. If the stride is –1, TotalView displays every element between the upper bound and lower bound (reverse order).
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 contains scopes are searched in an outward progression.
A table of symbolic names used in a program (such as variables or functions) 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.
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.
The target set for those occasions when operations can only be applied to entire processes, not to individual threads in a process.
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.
The convention of describing the operations available for a thread, and the effects of the operation, in terms of a set of predefined states.
An acronym for Three-Letter Acronym. So many things from computer hardware and software vendors are referred to by a three-letter acronym that yet another acronym was created to describe these terms.
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.
This is abbreviated as TTF. A TotalView subsystem that allows you to change the way information appears. For example, an STL vector can appear as an array.
The action of displaying the previous contents of a window, instead of the contents displayed for the current dive. To undive, you click the
undive icon in the upper-right corner of the window.
(from a definition on the UPC web site) The Unified Parallel C language, which is an extension to the C programming language that is designed for high performance computing on large-scale parallel machines. The language provides a uniform programming model for both shared and distributed memory hardware. The programmer is presented with a single shared, partitioned address space, where variables may be directly read and written by any processor, but each variable is physically associated with a single processor. See
http://upc.nersc.gov/ for more information.
A process that works with TotalView in a separate window, allowing you to see a graphic representation of program array data.
A thread in a workers group. These are threads created by your program that performs the task for which you’ve written the program.
Copyright © 2012, Rogue Wave Software, Inc. All Rights Reserved.
TotalView® Version 8.10