Dynamic Probe Class Library

Dynamic Probe Class Library Programming Guide



abstract syntax tree
A data structure that represents logic removed from a particular syntactic representation of that logic. For example, the abstract syntax tree for the expression a + (b x c) is identical to the abstract syntax tree for the expression a + b x c (where only precedence rules force the multiplication operation to be performed first). Compilers create abstract syntax trees from a program's source code as an intermediary stage before manipulating and converting the data structure into executable instructions. Similarly, in DPCL, probe expressions to be executed within target application processes are first converted into abstract syntax trees. See also Dynamic Probe Class Library (DPCL) and probe expression.

A value, possibly a character or group of characters that identifies a register, a device, a particular part of storage, or some other data source or destination.

analysis tool
See DPCL analysis tool.

Application programming interface.

The use to which a data processing system is put; for example, topayroll application, an airline reservation application.

application programming interface (API)
A software interface that enables applications or program components to communicate with each other. An API is the set of programming language constructs or statements that can be coded in an application program to obtain the specific functions and services provided by an underlying operating system or service program.

A parameter passed between a calling program and a called program or subprogram.

A named property of an entity.


blocking operation
An operation that does not complete until the operation either succeeds or fails. For example, a blocking receive will not return until a message is received or until the channel is closed and no further messages can be received.

A portion of storage used to hold input or output data temporarily.


A general-purpose programming language. It was formalized by Uniforum in 1983 and the ANSI standards committee for the C language in 1984.

A general-purpose programming language that is based on the C language. C++ includes extensions that support an object-oriented programming paradigm. Extensions include:

A function that requests services from a server and makes them available to the user.

To translate a source program into an executable program.


A debugger provides an environment in which you can manually control the execution of a program. It also provides the ability to display the program' data and operation.

See Dynamic Probe Class Library (DPCL).

DPCL analysis tool
A C++ application built on the Dynamic Probe Class Library (DPCL). It links in the DPCL library and uses the DPCL API calls to instrument (create probes and insert them into) one or more target application processes. Typically, an analysis tool is designed to measure the efficiency, confirm the correctness, or monitor the execution of, the target application. An analysis tool could be a complex and general-purpose tool like a debugger, or it might be a simple and specialized tool designed for only one particular program, user, or situation. See also DPCL target application, Dynamic Probe Class Library (DPCL), and probe.

DPCL target application
The executable program that is instrumented by a DPCL analysis tool. It is the process (or processes) into which the DPCL analysis tool inserts probes. A target application could be a serial or parallel program. Furthermore, if the target application is a parallel program, it could follow either the SPMD or the MPMD model, and may be designed for either a message-passing or a shared-memory system. See also DPCL analysis tool, Dynamic Probe Class Library (DPCL), and probe.

dynamic instrumentation
A form of software instrumentation in which instrumentation can be added to or removed from an application while it is running. Unlike traditional forms of software instrumentation, where instrumentation is added to the application prior to execution, dynamic instrumentation is well suited to

The Dynamic Probe Class Library (DPCL) is based on dynamic instrumentation technology. See also Dynamic Probe Class Library (DPCL) and software instrumentation.

Dynamic Probe Class Library (DPCL)
A C++ class library whose application programming interface (API) enables a program to dynamically insert instrumentation code patches, or probes, into an executing program. The DPCL product is an asynchronous software system designed to serve as a foundation for a variety of analysis tools that need to dynamically instrument (insert probes into and remove probes from) target applications. In addition to its API, the DPCL system consists of:

See also DPCL analysis tool, DPCL target application, and probe.


environment variable
1) A variable that describes the operating environment of the process. Common environment variables describe the home directory, command search path, and the current time zone. 2) A variable that is included in the current software environment and is therefore available to any called program that requests it.

An occurrence of significance to a task -- the completion of an asynchronous operation such as an input/output operation, for example.

A program that has been link-edited and therefore can be run in a processor.

To perform the actions specified by a program or a portion of a program.

In programming languages, a language construct for computing a value from one or more operands.


function call tree
A graphical representation of all the functions and calls within an application, which appears in the Xprofiler main window. The functions are represented by green, solid-filled rectangles called function boxes. The size and shape of each function box indicates its CPU usage. Calls between functions are represented by blue arrows, called call arcs, drawn between the function boxes. See also call arcs.

functional decomposition
A method of dividing the work in a program to exploit parallelism. One divides the program into independent pieces of functionality, which are distributed to independent processors. This method is in contrast to data decomposition, which distributes the same work over different data to independent processors.

functional parallelism
Refers to situations where parallel tasks specialize in particular work.


global variable
A variable defined in one portion of a computer program and used in at least one other portion of the computer program.

graphical user interface (GUI)
A type of computer interface consisting of a visual metaphor of a real-world scene, often of a desktop. Within that scene are icons, which represent actual objects, that the user can access and manipulate with a pointing device.

Graphical user interface.


home node
The node from which an application developer compiles and runs his program. The home node can be any workstation on the LAN.

A computer connected to a network that provides an access method to that network. A host provides end-user services.

host list file
A file that contains a list of host names, and possibly other information, that was defined by the application which reads it.

host name
The name used to uniquely identify any computer on a network.


IBM Parallel Environment (PE) for AIX
A licensed program that provides an execution and development environment for parallel C, C++, and FORTRAN programs. It also includes tools for debugging, profiling, and tuning parallel programs.

instrumentation point
In DPCL, a location within a target application process where an analysis tool can install point probes. Instrumentation points are locations at which the DPCL system determines it is safe to insert new code. Such locations are function entry, function exit, and function call sites. See also DPCL analysis tool, DPCL target application, and Dynamic Probe Class Library (DPCL).

Internet Protocol (IP)
1) The TCP/IP protocol that provides packet delivery between the hardware and user processes. 2) The SP Switch library, provided with the Parallel System Support Programs, that follows the IP protocol of TCP/IP.

Internet Protocol.


The time interval between the instant at which an instruction control unit initiates a call for data transmission, and the instant at which the actual transfer of data (or receipt of data at the remote end) begins. Latency is related to the hardware characteristics of the system and to the different layers of software that are involved in initiating the task of packing and transmitting the data.

local variable
A variable that is defined and used only in one specified portion of a computer program.


message passing
Refers to the process by which parallel tasks explicitly exchange program data.

Multiple instruction stream, multiple data stream.

Multiple instruction stream, multiple data stream (MIMD)
A parallel programming model in which different processors perform different instructions on different sets of data.

Multiple program, multiple data.

Multiple program, multiple data (MPMD)
A parallel programming model in which different, but related, programs are run on different sets of data.

Message Passing Interface.


An interconnected group of nodes, lines, and terminals. A network provides the ability to transmit data to and receive data from other systems and users.

(1) In a network, the point where one or more functional units interconnect transmission lines. A computer location defined in a network. (2) In terms of the IBM RS/6000 SP, a single location or workstation in a network. An SP node is a physical entity (a processor).

node ID
A string of unique characters that identifies the node on a network.

nonblocking operation
An operation, such as sending or receiving a message, that returns immediately whether or not the operation was completed. For example, a nonblocking receive will not wait until a message is sent, but a blocking receive will wait. A nonblocking receive will return a status value that indicates whether or not a message was received.


one-shot probe
In DPCL, a probe that is executed by the DPCL system immediately upon request, regardless of what the application happens to be doing. See also Dynamic Probe Class Library (DPCL), phase probe, point probe, and probe.

A widely-used (though not strictly accurate) term for program performance improvement, especially for performance improvement done by a compiler or other program translation software. An optimizing compiler is one that performs extensive code transformations in order to obtain an executable that runs faster but gives the same answer as the original. Such code transformations, however, can make code debugging and performance analysis very difficult because complex code transformations obscure the correspondence between compiled and original source code.

option flag
Arguments or any other additional information that a user specifies with a program name. Also referred to as parameters or command line options.


The degree to which parts of a program may be concurrently executed.

To convert a serial program for parallel execution.

Parallel Operating Environment (POE)
An execution environment that smooths the differences between serial and parallel execution. It lets you submit and manage parallel jobs. It is abbreviated and commonly known as POE.

(1) In FORTRAN, a symbol that is given a constant value for a specified application. (2) An item in a menu for which the operator specifies a value or for which the system provides a value when the menu is interpreted. (3) A name in a procedure that is used to refer to an argument that is passed to the procedure. (4) A particular piece of information that a system or application program needs to process a request.

The IBM Parallel Environment for AIX licensed program.

phase probe
In DPCL, a probe that is executed periodically, upon expiration of a timer, regardless of what part of the target application's code is executing. As opposed to one-shot probes and point probes, a phase probe must refer to a probe module function. A phase probe cannot be a simple probe expression that does not refer to a probe module function. The control mechanism for invoking these time-initiated phase probes is called a phase. See also Dynamic Probe Class Library (DPCL), one-shot probe, point probe, and probe.

Process identifier.

Parallel Operating Environment.

point probe
In DPCL, a probe that the analysis tool places at particular locations within one or more target application processes. When placed in an activated state by the analysis tool, a point probe will run as part of a target application process whenever execution reaches its installed location in the code. The fact that point probes are associated with particular locations within the target application code makes them markedly different from the other two types of probes (phase probes and one-shot probes), which are executed at a particular time regardless of what code the target application is executing. See also Dynamic Probe Class Library (DPCL), one-shot probe, phase probe, and probe.

In DPCL, the software instrumentation code patch that a DPCL analysis tool can insert into one or more processes of the DPCL target application. Probes are created by the analysis tool code (using a combination of probe expressions and probe modules), and therefore are able to perform any work required by the tool. For example, depending on the needs of the analysis tool, probes could be inserted into the target application to collect and report performance information (such as execution time), keep track of pass counts for test coverage tools, or report or modify the contents of variables for debuggers. There are three types of probes: one-shot probes, phase probes, and point probes. These three types of probes are differentiated by the manner in which their execution is triggered. See also DPCL analysis tool, DPCL target application, Dynamic Probe Class Library (DPCL), one-shot probe, phase probe, point probe, probe expression, and probe module.

probe expression
In DPCL, an abstract syntax tree that represents a simple instruction or sequence of instructions to be executed as a probe within one or more target application processes. See also abstract syntax tree, Dynamic Probe Class Library (DPCL), probe, and probe module.

probe module
In DPCL, a compiled object file containing one or more functions written in C. Once an analysis tool loads a particular probe module into a target application, a probe is able to call any of the functions contained in the module. See also Dynamic Probe Class Library (DPCL) and probe.

(1) In a programming language, a block, with or without formal parameters, whose execution is invoked by means of a procedure call. (2) A set of related control statements that cause one or more programs to be performed.

A program or command that is actually running the computer. It consists of a loaded version of the executable file, its data, its stack, and its kernel data structures that represent the process's state within a multitasking environment. The executable file contains the machine instructions (and any calls to shared objects) that will be executed by the hardware. A process can contain multiple threads of execution.

The process is created via a fork() system call and ends using an exit() system call. Between fork and exit, the process is known to the system by a unique process identifier (PID).

Each process has its own virtual memory space and cannot access another process's memory directly. Communication methods across processes include pipes, sockets, shared memory, and message passing.

The act of determining how much CPU time is used by each function or subroutine in a program. The histogram or table produced is called the execution profile.


remote host
Any host on a network except the one at which a particular operator is working.


A functional unit that provides shared services to workstations over a network -- a file server, a print server, or a mail server, for example.

signal handling
A type of communication that is used by message passing libraries. Signal handling involves using UNIX signals as an asynchronous way to move data in and out of message buffers.

Single program, multiple data (SPMD)
A parallel programming model in which different processors execute the same program on different sets of data.

software instrumentation
Code that is inserted into a program to gather information regarding the program's run. As the instrumented application executes, the instrumented code then generates the desired information, which could include performance, trace, test coverage, diagnostic, or other data. See also dynamic instrumentation.

source code
The input to a compiler or assembler, written in a source language. Contrast with object code.

source line
A line of source code.

source object
In DPCL, an object that provides a coarse, source-code-level view of a target application process, and enables an analysis tool to display or navigate a hierarchical representation of a particular target application process. See also DPCL target application and Dynamic Probe Class Library (DPCL).

IBM RS/6000 SP; a scalable system arranged in various physical configurations, that provides a high-powered computing environment.

Single program, multiple data.

standard error
In a UNIX operating system, the secondary destination of data produced by a command. Standard error goes to the display unless redirection or piping is used, in which case standard error can go to a file or to another command.

standard input
In a UNIX operating system, the primary source of data entered into a command. Standard input comes from the keyboard unless redirection or piping is used, in which case standard input can be from a file or the output from another command.

standard output
In a UNIX operating system, the primary destination of data produced by a command. Standard output goes to the display unless redirection or piping is used, in which case standard output can go to a file or to another command.

Standard error.

Standard input.

Standard output.

(1) A sequence of instructions whose execution is invoked by a call. (2) A sequenced set of instructions or statements that may be used in one or more computer programs and at one or more points in a computer program. (3) A group of instructions that can be part of another routine or can be called by another program or routine.

The action of forcing certain points in the execution sequences of two or more asynchronous procedures to coincide in time.


target application
See DPCL target application.

A unit of computation analogous to a UNIX process.

A single, separately dispatchable, unit of execution. There may be one or more threads in a process, and each thread is executed by the operating system concurrently.


(1) A person who requires the services of a computing system. (2) Any person or any thing that may issue or receive commands and message to or from the information processing system.


(1) In programming languages, a named object that may take different values, one at a time. The values of a variable are usually restricted to one data type. (2) A quantity that can assume any of a given set of values. (3) A name used to represent a data item whose value can be changed while the program is running. (4) A name used to represent data whose value can be changed, while the program is running, by referring to the name of the variable.


X Window System
The UNIX industry's graphics windowing standard that provides simultaneous views of several executing programs or processes on high resolution graphics displays.

[ Top of Page | Previous Page | Next Page | Table of Contents | Index ]