capture.tex

\clause{Captures}

\sclause{Introduction}

\pnum
A spawn capture allows a spawn statement
to make a copy of a variable
prior to the start of asynchronous execution.
\footnote{DFEP:
This corresponds to the
\tcode{firstprivate}
clause of OpenMP.
Cilk has no corresponding feature;
it isn't needed, because only a function-call can be spawned,
and arguments are guaranteed to be evaluated before the spawn happens.
}
A reduction capture allows a task block or parallel loop
to temporarily associate a reduction object
with an existing object,
to simplify parallel computation of a reduction.

\sclause{Spawn captures}

\ssclause*{Syntax}

\begin{bnf}
\nontermdef{spawn-capture}
\br
\terminal{_Copy_in} \terminal{(} spawn-capture-list \terminal{)}
\end{bnf}

\begin{bnf}
\nontermdef{spawn-capture-list}
\br
spawn-capture-item
\br
spawn-capture-list \terminal{,} spawn-capture-item
\end{bnf}

\begin{bnf}
\nontermdef{spawn-capture-item}
\br
identifier
\br
identifier \terminal{=} expression
\end{bnf}

\ssclause*{Constraints}

\pnum
If no expression is present in a spawn capture item,
the identifier shall be a name that is already in scope
at the beginning of the spawn capture item,
and the effective expression is taken to be the same as the identifier.
Otherwise, the effective expression
is the expression in the spawn capture item.

\pnum
The effective expression shall have complete object type.

\ssclause*{Semantics}

\pnum
Each spawn capture item declares a new object
named by the item's identifier,
having automatic storage duration.
The type of the declared object is that of the effective expression.
The scope of the name extends from the end of the spawn capture item
until the end of the spawn statement with which it is associated.

\pnum
The declared object is initialized
with the value of the effective expression.
The initialization of the declared object
occurs before asynchronous execution
of the spawned compound statement.

\pnum
Change the first sentence of paragraph 3 of subclause 6.3.2.1:

\begin{quote}
Except when it
\added{is the effective expression in a spawn capture item, or}
is the operand of the \tcode{sizeof} operator,
the \tcode{_Alignof} operator,
or the unary \tcode{\&} operator,
or is a string literal used to initialize an array,
an expression that has type ``array of type''
is converted to an expression with type ``pointer to type''
that points to the initial element of the array object
and is not an lvalue. ...
\end{quote}

\begin{example}
Consider the following code:

\begin{verbatim}
// Walk a list and call f() on the value of each element.
// Calls to f() can be done in parallel.
_Task _Block {
    while (p) {
        _Task _Spawn _Copy_in(p) { f(p->value); }
        p = p->next;
    }
}
\end{verbatim}
Without the \tcode{_Copy_in},
there would be a race on the variable \tcode{p},
because the call to \tcode{f}
is allowed to proceed in parallel with the continuation,
including the update.
\end{example}

\sclause{Reduction captures}

\ssclause*{Syntax}

\begin{bnf}
\nontermdef{reduction-capture}
\br
\terminal{_Reduction} \terminal{(} reduction-capture-list \terminal{)}
\end{bnf}

\begin{bnf}
\nontermdef{reduction-capture-list}
\br
reduction-capture-item
\br
reduction-capture-list \terminal{,} reduction-capture-item
\end{bnf}

\begin{bnf}
\nontermdef{reduction-capture-item}
\br
declaration-specifiers declarator
\br
declaration-specifiers declarator \terminal{:} expression
\end{bnf}

\ssclause*{Constraints}

\pnum
A reduction capture item
shall have some reduction type,
and shall not have static or thread storage duration.

\pnum
If no expression is present in a reduction capture item,
the identifier in the declarator
shall be a name that is already in scope
at the beginning of the reduction capture item,
and the effective expression is taken to be the same as the identifier.
Otherwise, the effective expression
is the expression in the reduction capture item.

\pnum
The effective expression shall be a modifiable lvalue,
and shall have a type that is compatible with the proxied type
of the item's reduction type.

\ssclause*{Semantics}

\pnum
Each reduction capture item declares a new object
with reduction type.
The scope of the name extends from the end of the reduction capture item
until the end of the task block or loop with which it is associated.

\pnum
Before execution of the task block or loop,
the new reduction object is initialized
with the value of the object designated by the effective expression.
Upon completion of the task block or loop,
the value of the reduction object is assigned back
to the object designated by the effective expression.

\pnum
Change the first sentence of paragraph 2 of subclause 6.3.2.1:

\begin{quote}
Except when it
\added{is the expression in a reduction capture item, or}
is the operand of the \tcode{sizeof} operator,
the \tcode{_Alignof} operator, the
unary \tcode{\&} operator,
the \tcode{++} operator,
the \tcode{--} operator,
or the left operand of the \tcode{.} operator
or an assignment operator,
an lvalue that does not have array type
is converted to the value stored in the designated object
(and is no longer an lvalue);
this is called
\defn{lvalue conversion}. ...
\end{quote}