Changeset e02e13f for doc/theses/colby_parsons_MMAth/text/actors.tex

Timestamp:

Apr 4, 2023, 10:12:57 PM (15 months ago)

Author:

Mike Brooks <mlbrooks@…>

Branches:

ADT, ast-experimental, master

Children:

9bb8ee42

Parents:

ff71057 (diff), bb7422a (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/actors.tex (modified) (8 diffs)

doc/theses/colby_parsons_MMAth/text/actors.tex

@@ -88 +88 @@
 Similarly to create a message type a user must define a struct which \code{inline}'s the base \code{message} struct.
 
-\begin{cfacode}
+\begin{cfa}
 struct derived_actor {
     inline actor;       // Plan-9 C inheritance
@@ -118 +118 @@
     return 0;
 }
-\end{cfacode}
+\end{cfa}
 
 The above code is a simple actor program in \CFA. 
@@ -125 +125 @@
 Key things to highlight include the \code{receive} signature, and calls to \code{start_actor_system}, and \code{stop_actor_system}. 
 To define a behaviour for some derived actor and derived message type, one must declare a routine with the signature:
-\begin{cfacode}
+\begin{cfa}
 Allocation receive( derived_actor & receiver, derived_msg & msg )
-\end{cfacode}
+\end{cfa}
 Where \code{derived_actor} and \code{derived_msg} can be any derived actor and derived message types respectively. 
 The return value of \code{receive} must be a value from the \code{Allocation} enum:
-\begin{cfacode}
+\begin{cfa}
 enum Allocation { Nodelete, Delete, Destroy, Finished };
-\end{cfacode}
+\end{cfa}
 The \code{Allocation} enum is a set of actions that dictate what the executor should do with a message or actor after a given behaviour has been completed. 
 In the case of an actor, the \code{receive} routine returns the \code{Allocation} status to the executor which sets the status on the actor and takes the appropriate action. 
 For messages, they either default to \code{Nodelete}, or they can be passed an \code{Allocation} via the \code{message} constructor. 
 Message state can be updated via a call to:
-\begin{cfacode}
+\begin{cfa}
 void set_allocation( message & this, Allocation state )
-\end{cfacode}
+\end{cfa}
 
 The following describes the use of each of the \code{Allocation} values:
@@ -186 +186 @@
 All message sends are done using the left shift operater, \ie <<, similar to the syntax of \CC's output. 
 The signature of the left shift operator is:
-\begin{cfacode}
+\begin{cfa}
 Allocation ?<<?( derived_actor & receiver, derived_msg & msg )
-\end{cfacode}
+\end{cfa}
 
 An astute eye will notice that this is the same signature as the \code{receive} routine which is no coincidence. 
@@ -368 +368 @@
 To first verify sequential correctness, consider the equivalent sequential swap below:
 
-\begin{cfacode}
+\begin{cfa}
 void swap( uint victim_idx, uint my_idx  ) {
     // Step 0:
@@ -380 +380 @@
     request_queues[my_idx] = vic_queue;
 }
-\end{cfacode}
+\end{cfa}
 
 Step 1 is missing in the sequential example since in only matter in the concurrent context presented later. 
@@ -386 +386 @@
 Temporary copies of each pointer being swapped are stored, and then the original values of each pointer are set using the copy of the other pointer.
 
-\begin{cfacode}
+\begin{cfa}
 // This routine is atomic
 bool CAS( work_queue ** ptr, work_queue ** old, work_queue * new ) {
@@ -427 +427 @@
     return true;
 }
-\end{cfacode}\label{c:swap}
+\end{cfa}\label{c:swap}
 
 Now consider the concurrent implementation of the swap.