Changeset d54ede6

Timestamp:

Aug 1, 2023, 10:52:34 PM (16 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

a867622

Parents:

d5f5eb7 (diff), 2cb15b0 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• doc/theses/colby_parsons_MMAth/text/waituntil.tex (modified) (2 diffs)

doc/theses/colby_parsons_MMAth/text/waituntil.tex

@@ -321 +321 @@
 Note, the expression inside a @waituntil@ clause is evaluated once at the start of the @waituntil@ algorithm.
 
+\section{Waituntil Semantics}
+
+The @waituntil@ semantics has two parts: the semantics of the statement itself, \ie @and@, @or@, @when@ guards, and @else@ semantics, and the semantics of how the @waituntil@ interacts with types like locks, channels, and futures.
+
+\subsection{Statement Semantics}
+
+The @or@ semantics are the most straightforward and nearly match those laid out in the ALT statement from Occam.
+The clauses have an exclusive-or relationship where the first available one is run and only one clause is run.
+\CFA's @or@ semantics differ from ALT semantics: instead of randomly picking a clause when multiple are available, the first clause in the @waituntil@ that is available is executed.
+For example, in the following example, if @foo@ and @bar@ are both available, @foo@ is always selected since it comes first in the order of @waituntil@ clauses.
+\begin{cfa}
+future(int) bar, foo;
+waituntil( foo ) { ... } or waituntil( bar ) { ... } // prioritize foo
+\end{cfa}
+The reason for these semantics is that prioritizing resources can be useful in certain problems, such as shutdown.
+In the rare case where there is a starvation problem with the ordering, it possible to follow a @waituntil@ with its reverse form, alternating which resource has the highest priority:
+\begin{cfa}
+waituntil( foo ) { ... } or waituntil( bar ) { ... } // prioritize foo
+waituntil( bar ) { ... } or waituntil( foo ) { ... } // prioritize bar
+\end{cfa}
+While this approach is not general for many resources, it handles many basic cases.
+
 \begin{figure}
 \begin{cfa}
@@ -337 +359 @@
 \label{f:wu_example}
 \end{figure}
-
-\section{Waituntil Semantics}
-
-The @waituntil@ semantics has two parts: the semantics of the statement itself, \ie @and@, @or@, @when@ guards, and @else@ semantics, and the semantics of how the @waituntil@ interacts with types like locks, channels, and futures.
-
-\subsection{Statement Semantics}
-
-The @or@ semantics are the most straightforward and nearly match those laid out in the ALT statement from Occam.
-The clauses have an exclusive-or relationship where the first available one is run and only one clause is run.
-\CFA's @or@ semantics differ from ALT semantics: instead of randomly picking a clause when multiple are available, the first clause in the @waituntil@ that is available is executed.
-For example, in the following example, if @foo@ and @bar@ are both available, @foo@ is always selected since it comes first in the order of @waituntil@ clauses.
-\begin{cfa}
-future(int) bar, foo;
-waituntil( foo ) { ... } or waituntil( bar ) { ... } // prioritize foo
-\end{cfa}
-The reason for this semantics is that prioritizing resources can be useful in certain problems, such as shutdown.
-In the rare case where there is a starvation problem with the ordering, it possible to follow a @waituntil@ with its reverse form, alternating which resource has the highest priority:
-\begin{cfa}
-waituntil( foo ) { ... } or waituntil( bar ) { ... } // prioritize foo
-waituntil( bar ) { ... } or waituntil( foo ) { ... } // prioritize bar
-\end{cfa}
-While this approach is not general for many resources, it handles many basic cases.
 
 The \CFA @and@ semantics match the @and@ semantics of \uC \lstinline[language=uC++]{_Select}.