OpenMP Language Terminology

A programming language that serves as the foundation of the OpenMP specification.

COMMENT: See Section 1.7 for a listing of current base languages for the OpenMP API.

A program written in a base language.

For C/C++, a sequence of preprocessing tokens that result from the first six phases of translation, as defined by the base language.

An ordering of operations performed by the same thread as determined by the execution sequence of operations specified by the base language.

COMMENT: For versions of C and C++ that include base language support for threading, program order corresponds to the sequenced before relation between operations performed by the same thread.

For C/C++, an executable statement, possibly compound, with a single entry at the top and a single exit at the bottom, or an OpenMP construct.

For Fortran, a strictly structured block, or a loosely structured block.

A structured block, or, for C/C++, a sequence of two or more executable statements that together have a single entry at the top and a single exit at the bottom.

A single Fortran BLOCK construct, with a single entry at the top and a single exit at the bottom.

A block of executable constructs, where the first executable construct is not a Fortran BLOCK construct, with a single entry at the top and a single exit at the bottom, or an OpenMP construct.

COMMENT: In Fortran code, when a strictly structured block appears within an OpenMP construct, that OpenMP construct does not usually require a paired end directive to define the range of the OpenMP construct, while an OpenMP construct that contains a loosely structured block relies on the paired end directive to define the range of the OpenMP construct.

For C/C++, a translation unit.

For Fortran, a program unit.

For C/C++, the innermost scope enclosing an OpenMP directive.

For Fortran, the innermost scoping unit enclosing an OpenMP directive.

A base language mechanism to specify OpenMP program behavior.

COMMENT: See Section 2.1 for a description of OpenMP directive syntax in each base language.

A non-empty sequence of space and/or horizontal tab characters.

A program that consists of a base program that is annotated with OpenMP directives or that calls OpenMP API runtime library routines.

An OpenMP program that follows all rules and restrictions of the OpenMP specification.

Implicit code that is introduced by the OpenMP implementation.

A directive that conditionally resolves to another directive.

An OpenMP directive that may only be placed in a declarative context and results in one or more declarations only; it is not associated with the immediate execution of any user code or implementation code. For C++, if a declarative directive applies to a function declaration or definition and it is specified with one or more C++ attribute specifiers, the specified attributes must be applied to the function as permitted by the base language. For Fortran, a declarative directive must appear after any USE, IMPORT, and IMPLICIT statements in a declarative context.

An OpenMP directive that appears in an executable context and results in implementation code and/or prescribes the manner in which associated user code must execute.

An OpenMP directive that is neither declarative nor executable, but otherwise conveys user code properties to the compiler.

An OpenMP directive that is neither declarative nor executable, but otherwise facilitates interactions with the compiler and/or supports code readability.

An OpenMP executable directive that has no associated user code, but may produce implementation code resulting from clauses in the directive.

An OpenMP executable directive (and for Fortran, the paired enddirective, if any) and the associated statement, loop nest or structured block, if any, not including the code in any called routines. That is, the lexical extent of an executable directive.

A construct that is a shortcut for specifying one construct immediately nested inside another construct. A combined construct is semantically identical to that of explicitly specifying the first construct containing one instance of the second construct and no other statements.

A construct that is composed of two constructs but does not have identical semantics to specifying one of the constructs immediately nested inside the other. A composite construct either adds semantics not included in the constructs from which it is composed or provides an effective nesting of the one construct inside the other that would otherwise be non-conforming.

For a given combined or composite construct, a construct from which it, or any one of its constituent constructs, is composed.

COMMENT: The constituent constructs of a target teams distribute parallel for simd construct are the following constructs: target, teams distribute parallel for simd, teams, distribute parallel for simd, distribute, parallel for simd, parallel, for simd, for, and simd.

For a given combined or composite construct, a constituent construct that is not itself a combined or composite construct.

COMMENT: The leaf constructs of a target teams distribute parallel for simd construct are the following constructs: target, teams, distribute, parallel, for, and simd.

A combined construct that is composed of a target construct along with another construct.

All code encountered during a specific instance of the execution of a given construct, structured block sequence or OpenMP library routine. A region includes any code in called routines as well as any implementation code. The generation of a task at the point where a task generating construct is encountered is a part of the region of the encountering thread. However, an explicit task region that corresponds to a task generating construct is not part of the region of the encountering thread unless it is an included task region. The point where a target or teams directive is encountered is a part of the region of the encountering thread, but the region that corresponds to the target or teams directive is not.

COMMENTS:

A region may also be thought of as the dynamic or runtime extent of a construct or of an OpenMP library routine.

During the execution of an OpenMP program, a construct may give rise to many regions.

A parallelregion that is executed by a team consisting of more than one thread.

A parallelregion that is executed by a team of only one thread.

A targetregion that is executed on a device other than the device that encountered the targetconstruct.

A targetregion that is executed on the same device that encountered the target construct.

All code encountered during the execution of an initial task region that is not part of a parallelregion corresponding to a parallelconstruct or a taskregion corresponding to a task construct.

COMMENTS:

A sequential part is enclosed by an implicit parallel region.

Executable statements in called routines may be in both a sequential part and any number of explicit parallel regions at different points in the program execution.

An OpenMP thread that has thread number 0. A primary thread may be an initial thread or the thread that encounters a parallelconstruct, creates a team, generates a set of implicit tasks, and then executes one of those tasks as thread number 0.

The thread that encountered the parallelconstruct and generated a parallelregion is the parent thread of each of the threads in the team of that parallelregion. The primary thread of a parallelregion is the same thread as its parent thread with respect to any resources associated with an OpenMP thread.

When a thread encounters a parallel construct, each of the threads in the generated parallel region’s team are child threads of the encountering thread. The target or teams region’s initial thread is not a child thread of the thread that encountered the target or teams construct.

For a given thread, its parent thread or one of its parent thread’s ancestor threads.

For a given thread, one of its child threads or one of its child threads’ descendent threads.

A set of one or more threads participating in the execution of a parallelregion.

COMMENTS:

For an active parallel region, the team comprises the primary thread and at least one additional thread.

For an inactive parallel region, the team comprises only the primary thread.

The set of teams created by a teams construct.

An initial thread and its descendent threads.

An inactive parallel region that is not generated from a parallelconstruct. Implicit parallel regions surround the whole OpenMP program, all targetregions, and all teams regions.

The thread that executes an implicit parallel region.

The team that comprises an initial thread executing an implicit parallel region.

A construct (lexically) enclosed by another construct.

A construct nested inside another construct with no other construct nested between them.

A region that corresponds to either a construct of the same name or a library routine call that explicitly appears in the program.

A region (dynamically) enclosed by another region. That is, a region generated from the execution of another region or one of its nested regions.

COMMENT: Some nestings are conforming and some are not. See Section 2.22 for the restrictions on nesting.

A region nested inside another region with no parallelregion nested between them.

A region nested inside another region with no other explicit region nested between them.

All OpenMP threads participating in the OpenMP program.

All threads in the team executing the innermost enclosing parallelregion.

For a given region, the thread that encounters the corresponding construct.

All tasks participating in the OpenMP program.

All tasks encountered by the corresponding team. The implicit tasks constituting the parallelregion and any descendent tasks encountered during the execution of these implicit tasks are included in this set of tasks.

For a given region, the task for which execution by a thread generated the region.

The set of threads that are affected by, or provide the context for, the execution of a region.

The binding thread set for a given region can be all threads on a specified set of devices, all threads in a contention group, all primary threads executing an enclosing teamsregion, the current team, or the encountering thread.

COMMENT: The binding thread set for a particular region is described in its corresponding subsection of this specification.

The set of tasks that are affected by, or provide the context for, the execution of a region.

The binding task set for a given region can be all tasks, the current team tasks, all tasks of the current team that are generated in the region, the binding implicit task, or the generating task.

COMMENT: The binding task set for a particular region (if applicable) is described in its corresponding subsection of this specification.

The enclosing region that determines the execution context and limits the scope of the effects of the bound region is called the binding region.

Binding region is not defined for regions for which the binding thread set is all threads or the encountering thread, nor is it defined for regions for which the binding task set is all tasks.

A construct that gives rise to a region for which the binding thread set is the current team, but is not nested within another construct that gives rise to the binding region.

A construct that divides the work within its structured block into partitions, each of which is executed exactly once by one of the threads in the team executing the construct.

An OpenMP construct that accepts the device clause.

A function (for C/C++ and Fortran) or subroutine (for Fortran) that can be executed on a target device, as part of a target region.

A runtime environment that exists outside the OpenMP runtime with which the OpenMP implementation may interoperate.

A context that is instantiated from a foreign runtime environment in order to facilitate execution on a given device.

A unit of work executed in a foreign execution context.

An indirect call to the device version of a procedure on a device other than the host device, through a function pointer (C/C++), a pointer to a member function (C++) or a procedure pointer (Fortran) that refers to the host version of the procedure.

An unordered set of processors on a device.

The ordered list that describes all OpenMP places available to the execution environment.

An ordered list that corresponds to a contiguous interval in the OpenMP place list. It describes the places currently available to the execution environment for a given parallel region.

A number that uniquely identifies a place in the place list, with zero identifying the first place in the place list, and each consecutive whole number identifying the next place in the place list.

A binding of threads to places within the current place partition.

A single machine instruction that can operate on multiple data elements.

A software or hardware mechanism capable of processing one data element from a SIMD instruction.

A set of iterations executed concurrently, each by a SIMD lane, by a single thread by means of SIMD instructions.

A storage resource to store and to retrieve variables accessible by OpenMP threads.

A representation of storage resources from which memory can be allocated or deallocated. More than one memory space may exist.

An OpenMP object that fulfills requests to allocate and to deallocate memory for program variables from the storage resources of its associated memory space.

An opaque reference that uniquely identifies an abstraction.

1.2.2 OpenMP Language Terminology