OpenMP Language Terminology

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

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

A program written in a 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 C11 and C++11, 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 block of executable statements with a single entry at the top and a single exit at the bottom, or an OpenMP construct.

COMMENT: See Section 2.1 on page 104 for restrictions on structured blocks.

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.

For C/C++, a #pragma, and for Fortran, a comment, that specifies OpenMP program behavior.

COMMENT: See Section 2.1 on page 104 for a description of OpenMP directive syntax.

A directive that conditionally resolves to another directive at compile time.

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.

An OpenMP directive that may only be placed in a declarative context. A declarative directive results in one or more declarations only; it is not associated with the immediate execution of any user code.

An OpenMP directive that is not declarative. That is, it may be placed in an executable context.

An OpenMP executable directive that has no associated user code except for that which appears in clauses in the directive.

An OpenMP executable directive (and for Fortran, the paired enddirective, if any) and the associated statement, loop 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 the nesting of the one construct inside the other is not conforming.

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 or of an OpenMP library routine. A region includes any code in called routines as well as any implicit code introduced by the OpenMP implementation. 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 corresponding 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 corresponding 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 master 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 master 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 master thread and at least one additional thread.

For an inactive parallel region, the team comprises only the master 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 (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.20 on page 992 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 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 device, all threads in a contention group, all master 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.

COMMENTS:

The binding region for an ordered region is the innermost enclosing loop region.

The binding region for a taskwait region is the innermost enclosing task region.

The binding region for a cancel region is the innermost enclosing region corresponding to the construct-type-clause of the cancel construct.

The binding region for a cancellation point region is the innermost enclosing region corresponding to the construct-type-clause of the cancellation point construct.

For all other regions for which the binding thread set is the current team or the binding task set is the current team tasks, the binding region is the innermost enclosing parallel region.

For regions for which the binding task set is the generating task, the binding region is the region of the generating task.

A parallel region need not be active nor explicit to be a binding region.

A task region need not be explicit to be a binding region.

A region never binds to any region outside of the innermost enclosing parallel region.

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 giving rise to the binding region.

A construct that defines units of work, each of which is executed exactly once by one of the threads in the team executing the construct.

For C/C++, worksharing constructs are for, sections, and single.

For Fortran, worksharing constructs are do, sections, single and workshare.

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.

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