tasks.tex

\clause{Task execution}

\pnum
A task is permitted to execute
either in the invoking thread
or in a worker thread implicitly created by the implementation.
Independent tasks executing in the same thread
are indeterminately sequenced with respect to one another.
Independent tasks executing in different threads
are unsequenced with respect to one another.

\pnum
When execution of an independent task completes,
execution
\defn{joins}
with its parent task.
The completion of a task synchronizes
with the completion of the associated task block,
or with the next execution of a sync statement
within the associated task block.

\pnum
It is unspecified whether a worker thread is reused
for multiple tasks
during the execution of a program.
The lifetimes (creation and termination points)
of worker threads are unspecified.
An attempt by the program
to terminate, detach or join with 
a worker thread
results in undefined behavior.

\pnum
\added{%
The mapping of tasks to worker threads is unspecified,
except that the code immediately following a task block
is guaranteed to be executed by the same thread
as that which executed the code
immediately preceding that task block.
The mapping of a task to a worker thread is stable,
except at spawn or join points.%
}%
\footnote{%
Should the statements of a task block be allowed to execute
on a different thread than the one that entered the task block?
}

\begin{note}
\added{%
This means, for example,
that a mutex acquired outside of a task block
can be neither acquired nor released within the task block,
since there is no assurance that such an action
would occur on the same thread (for unlock)
or on a different thread (for lock).
}
\end{note}