HOME
| OPENMP API Specification: Version 5.0 November 2018

1.2.6  Data Terminology

variable
A named data storage block, for which the value can be defined and redefined during the execution of a program.

COMMENT: An array element or structure element is a variable that is part of another variable.

scalar variable
For C/C++, a scalar variable, as defined by the base language.

For Fortran, a scalar variable with intrinsic type, as defined by the base language, excluding character type.

aggregate variable
A variable, such as an array or structure, composed of other variables.

array section
A designated subset of the elements of an array that is specified using a subscript notation that can select more than one element.

array item
An array, an array section, or an array element.

shape-operator
For C/C++, an array shaping operator that reinterprets a pointer expression as an array with one or more specified dimensions.

implicit array
For C/C++, the set of array elements of non-array type T that may be accessed by applying a sequence of [] operators to a given pointer that is either a pointer to type T or a pointer to a multidimensional array of elements of type T.

For Fortran, the set of array elements for a given array pointer.

COMMENT: For C/C++, the implicit array for pointer p with type T (*)[10] consists of all accessible elements p[i][j], for all i and j=0..9.

base pointer
For C/C++, an lvalue pointer expression that is used by a given lvalue expression or array section to refer indirectly to its storage, where the lvalue expression or array section is part of the implicit array for that lvalue pointer expression.

For Fortran, a data pointer that appears last in the designator for a given variable or array section, where the variable or array section is part of the pointer target for that data pointer.

COMMENT: For the array section (*p0).x0[k1].p1->p2[k2].x1[k3].x2[4][0:n], where identifiers pi have a pointer type declaration and identifiers xi have an array type declaration, the base pointer is: (*p0).x0[k1].p1->p2.

named pointer
For C/C++, the base pointer of a given lvalue expression or array section, or the base pointer of one of its named pointers.

For Fortran, the base pointer of a given variable or array section, or the base pointer of one of its named pointers.

COMMENT: For the array section (*p0).x0[k1].p1->p2[k2].x1[k3].x2[4][0:n], where identifiers pi have a pointer type declaration and identifiers xi have an array type declaration, the named pointers are: p0, (*p0).x0[k1].p1, and (*p0).x0[k1].p1->p2.

containing array
For C/C++, a non-subscripted array (a containing array) that appears in a given lvalue expression or array section, where the lvalue expression or array section is part of that containing array.

For Fortran, an array (a containing array) without the POINTER attribute and without a subscript list that appears in the designator of a given variable or array section, where the variable or array section is part of that containing array.

COMMENT: For the array section (*p0).x0[k1].p1->p2[k2].x1[k3].x2[4][0:n], where identifiers pi have a pointer type declaration and identifiers xi have an array type declaration, the containing arrays are: (*p0).x0[k1].p1->p2[k2].x1 and (*p0).x0[k1].p1->p2[k2].x1[k3].x2.

base array
For C/C++, a containing array of a given lvalue expression or array section that does not appear in the expression of any of its other containing arrays.

For Fortran, a containing array of a given variable or array section that does not appear in the designator of any of its other containing arrays.

COMMENT: For the array section (*p0).x0[k1].p1->p2[k2].x1[k3].x2[4][0:n], where identifiers pi have a pointer type declaration and identifiers xi have an array type declaration, the base array is: (*p0).x0[k1].p1->p2[k2].x1[k3].x2.

named array
For C/C++, a containing array of a given lvalue expression or array section, or a containing array of one of its named pointers.

For Fortran, a containing array of a given variable or array section, or a containing array of one of its named pointers.

COMMENT: For the array section (*p0).x0[k1].p1->p2[k2].x1[k3].x2[4][0:n], where identifiers pi have a pointer type declaration and identifiers xi have an array type declaration, the named arrays are: (*p0).x0, (*p0).x0[k1].p1->p2[k2].x1, and (*p0).x0[k1].p1->p2[k2].x1[k3].x2.

base expression
The base array of a given array section or array element, if it exists; otherwise, the base pointer of the array section or array element.

COMMENT: For the array section (*p0).x0[k1].p1->p2[k2].x1[k3].x2[4][0:n], where identifiers pi have a pointer type declaration and identifiers xi have an array type declaration, the base expression is: (*p0).x0[k1].p1->p2[k2].x1[k3].x2.

More examples for C/C++:

Examples for Fortran:

attached pointer
A pointer variable in a device data environment to which the effect of a map clause assigns the address of an object, minus some offset, that is created in the device data environment. The pointer is an attached pointer for the remainder of its lifetime in the device data environment.

simply contiguous array section
An array section that statically can be determined to have contiguous storage or that, in Fortran, has the CONTIGUOUS attribute.

structure
A structure is a variable that contains one or more variables.

For C/C++: Implemented using struct types.

For C++: Implemented using class types.

For Fortran: Implemented using derived types.

private variable
With respect to a given set of task regions or SIMD lanes that bind to the same parallel region, a variable for which the name provides access to a different block of storage for each task region or SIMD lane.

A variable that is part of another variable (as an array or structure element) cannot be made private independently of other components.

shared variable
With respect to a given set of task regions that bind to the same parallel region, a variable for which the name provides access to the same block of storage for each task region.

A variable that is part of another variable (as an array or structure element) cannot be shared independently of the other components, except for static data members of C++ classes.

threadprivate variable
A variable that is replicated, one instance per thread, by the OpenMP implementation. Its name then provides access to a different block of storage for each thread.

A variable that is part of another variable (as an array or structure element) cannot be made threadprivate independently of the other components, except for static data members of C++ classes.

threadprivate memory
The set of threadprivate variables associated with each thread.

data environment
The variables associated with the execution of a given region.

device data environment
The initial data environment associated with a device.

device address
An implementation-defined reference to an address in a device data environment.

device pointer
A variable that contains a device address.

mapped variable
An original variable in a data environment with a corresponding variable in a device data environment.

COMMENT: The original and corresponding variables may share storage.


Table 1.1: Map-Type Decay of Map Type Combinations
alloc to from tofrom release delete







alloc alloc alloc alloc alloc release delete
to alloc to alloc to release delete
from alloc alloc from from release delete
tofrom alloc to from tofrom release delete

map-type decay
The process used to determine the final map type when mapping a variable with a user defined mapper. Table 1.1 shows the final map type that the combination of the two map types determines.

mappable type
A type that is valid for a mapped variable. If a type is composed from other types (such as the type of an array or structure element) and any of the other types are not mappable then the type is not mappable.

COMMENT: Pointer types are mappable but the memory block to which the pointer refers is not mapped.

For C, the type must be a complete type.

For C++, the type must be a complete type.

In addition, for class types:

For Fortran, no restrictions on the type except that for derived types:

defined
For variables, the property of having a valid value.

For C, for the contents of variables, the property of having a valid value.

For C++, for the contents of variables of POD (plain old data) type, the property of having a valid value.

For variables of non-POD class type, the property of having been constructed but not subsequently destructed.

For Fortran, for the contents of variables, the property of having a valid value. For the allocation or association status of variables, the property of having a valid status.

COMMENT: Programs that rely upon variables that are not defined are non-conforming programs.

class type
For C++, variables declared with one of the class, struct, or union keywords.