| OPENMP API Specification: Version 5.1 November 2020
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,1,...,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++:
-
The
base
expression
for
x[i]
and
for
x[i:n]
is
x,
if
x
is
an
array
or
pointer.
-
The
base
expression
for
x[5][i]
and
for
x[5][i:n]
is
x,
if
x
is
a
pointer
to
an
array
or
x
is
2-dimensional
array.
-
The
base
expression
for
y[5][i]
and
for
y[5][i:n]
is
y[5],
if
y
is
an
array
of
pointers
or
y
is
a
pointer
to
a
pointer.
Examples for Fortran:
-
The
base
expression
for
x(i)
and
for
x(i:j)
is
x.
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.
string literal
For C/C++, a string literal.
For Fortran, a character literal constant.
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. If a variable is privatized, its components are also private.
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. If a variable is made
threadprivate, its components are also threadprivate.
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 address of an object that may be referenced on a target device.
device pointer
An implementation defined handle that refers to 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.
mapper
An operation that defines how variables of given type are to be mapped or updated with respect to a
device data environment.
user-defined mapper
A mapper that is defined by a declare mapper directive.
map-type decay
The process that determines the final map types of the map operations that result from
mapping a variable with a user-defined mapper.
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:
-
All
member
functions
accessed
in
any
target
region
must
appear
in
a
declare
target
directive.
For Fortran, no restrictions on the type except that for derived types:
-
All
type-bound
procedures
accessed
in
any
target
region
must
appear
in
a
declare target
directive.
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.
static storage duration
For C/C++, the lifetime of an object with static storage duration, as defined by the
base language.
For Fortran, the lifetime of a variable with a SAVE attribute, implicit or explicit, a common block object or a
variable declared in a module.