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 unique integer ID associated with an action point.

See stack frame.

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.

A set of instructions that tell TotalView where to find information. These expressions are only used within the type transformation facility.

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 collection of data elements. For example, a structure or an array is an aggregate.

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

Application Program Interface. The formal interface by which programs communicate with libraries.

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.

The ability for TotalView to gain control of an already running process on the same machine or a remote machine.

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 point in a program where execution can be suspended to permit examination and manipulation of data.

A programming error. Finding them is why you’re using TotalView.

A TotalView procedure that launches multiple tvdsvr processes simultaneously.

 

See CoArray Fortran.

The memory area that contains the variables belonging to a function, subroutine, or other scope division, such as a block.

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.

See closed loop.

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 variation of Fortran with array syntax augmented to depict arrays distributed across processes.

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

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

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.

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

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

 

The source code language used by the file that contains the current source location.

The location governing what source code appears in response to a list command.

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

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 relating an executable to the source code from which it was generated.

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

See tvdsvr process.

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

A feature that is still available but might be eliminated in a future release.

A symbolic translation of binary code into assembler language.

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 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:

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

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 point in the program where TotalView evaluates a code fragment without stopping the execution of the program.

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

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

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 compiled and linked version of source files

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).

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

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).

An area in stack memory that contains the information corresponding to a single invocation of a subprocedure. See stack frame.

See stack pointer.

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.

The TotalView group ID.

(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://hpc.pnl.gov/globalarrays/.

A collection of distributed computing resources available over a local or wide area network that appears as if it were one large virtual computing system.

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

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

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.

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

The computer on which TotalView is running.

All of the programs, libraries, and other components that make up your executable.

See loop, infinite.

See program counter.

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 process that combines variables contained in separate processes or threads into a unified array for display purposes.

This is a synonym for lvalue.

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.

See infinite loop.

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.

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

A thread created by the operating system. In most cases, you do not want to manage or examine manager threads.

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

An acronym for Multiple Instruction, Multiple Data, which describes a type of parallel computing.

An acronym for Multiple Instruction, Single Data, which describes a type of parallel computing.

An acronym for “Message Passing Interface.”

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 https://www.mcs.anl.gov/research/projects/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.

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

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.

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

A breakpoint expression that, when reevaluated, points to an invalid address block.

An error usually caused by forgetting that arrays begin with element 0 in C and C++.

(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 https://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.

A program whose execution involves multiple threads and processes.

 

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 abbreviation for Program Counter.

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

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

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.

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

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

 

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

The primary process that TotalView uses when it is trying to determine what to step, stop, and so on.

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 program occurrence that is being monitored by TotalView or the CLI, such as a breakpoint.

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

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

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.

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.

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

This is a synonym for 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.

 

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

 

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.

 

Execution of a program sequentially, one statement at a time.

 

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

 

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.

 

A compiled and linked set of source files that are dynamically loaded by other executables.

 

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.

 

An acronym for Single Instruction, Multiple Data, which describes a type of parallel computing.

 

A TotalView procedure that individually launches tvdsvr processes.

 

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

 

An acronym for Single Instruction, Single Data, which describes a type of parallel computing.

 

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.

 

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

 

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.

 

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 sequential list of each currently active routine called by a program, and the frame pointer that points to its stack frame.

 

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.

 

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

 

An acronym for Standard Template Library.

 

A set of threads that TotalView stops after an action point triggers.

 

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).

 

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

 

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.

 

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

 

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 computer on which the process to be debugged is running.

 

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

 

The executing program that is the target of debugger operations.

 

The set of processes and threads that a CLI command acts on.

 

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

 

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.

 

The primary thread affected by a command. This is abbreviated as TOI.

 

The thread ID. On some systems (such as AIX where the threads have no obvious meaning), TotalView uses its own IDs.

 

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 thread of interest. This is the primary thread affected by a command.

 

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

 

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

 

See type transformation facility.

 

An instruction that stops program execution and which allows a debugger to gain control over your program.

 

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.

 

A symbol that is referred to by another symbol. For example, a typedef is a reference to the aliased type.

 

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.lbl.gov/ for more information.

 

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

 

A thread created by your program.

 

A keystroke used to interrupt commands, most commonly defined as Ctrl+C.

 

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

 

In TotalView, visualization means graphically displaying an array’s values.

 

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

 

An action point that tells TotalView to stop execution when the value of a memory location changes.

 

A thread in a workers group. These are threads created by your program that performs the task for which you’ve written the program.

 

All the worker threads in a control group. Worker threads can reside in more than one share group.