Index: doc/theses/colby_parsons_MMAth/text/CFA_concurrency.tex
===================================================================
--- doc/theses/colby_parsons_MMAth/text/CFA_concurrency.tex	(revision 11e3e9716a020c080bfcb5641ca602a24d2f9ec5)
+++ doc/theses/colby_parsons_MMAth/text/CFA_concurrency.tex	(revision deeda09e4da31bcb6a76ac4488cbe1aa05b02640)
@@ -1,35 +1,38 @@
 \chapter{Concurrency in \CFA}\label{s:cfa_concurrency}
 
-The groundwork for concurrency in \CFA was laid by Thierry Delisle in his Master's Thesis\cite{Delisle18}. 
-In that work he introduced coroutines, user level threading, and monitors. 
-Not listed in that work were the other concurrency features that were needed as building blocks, such as locks, futures, and condition variables which he also added to \CFA.
+The groundwork for concurrency in \CFA was laid by Thierry Delisle in his Master's Thesis~\cite{Delisle18}. 
+In that work, he introduced generators, coroutines, monitors, and user-level threading. 
+Not listed in that work were basic concurrency features needed as building blocks, such as locks, futures, and condition variables, which he also added to \CFA.
 
 \section{Threading Model}\label{s:threading}
-\CFA has user level threading and supports a $M:N$ threading model where $M$ user threads are scheduled on $N$ cores, where both $M$ and $N$ can be explicitly set by the user. 
-Cores are used by a program by creating instances of a \code{processor} struct. 
-User threads types are defined using the \code{thread} keyword, in the place where a \code{struct} keyword is typically used. 
-For each thread type a corresponding main must be defined, which is where the thread starts running once it is created. 
-Listing~\ref{l:cfa_thd_init} shows an example of processor and thread creation. 
-When processors are added, they are added alongside the existing processor given to each program. 
-Thus if you want $N$ processors you need to allocate $N-1$. 
-To join a thread the thread must be deallocated, either deleted if it is allocated on the heap, or go out of scope if stack allocated. 
-The thread performing the deallocation will wait for the thread being deallocated to terminate before the deallocation can occur. 
-A thread terminates by returning from the main routine where it starts.
+\CFA provides user-level threading and supports an $M$:$N$ threading model where $M$ user threads are scheduled on $N$ kernel threads, where both $M$ and $N$ can be explicitly set by the user. 
+Kernel threads are created by instancing a @processor@ structure. 
+User-thread types are defined by creating a @thread@ aggregate-type, \ie replace @struct@ with @thread@. 
+For each thread type a corresponding @main@ routine must be defined, which is where the thread starts running once it is created. 
+Examples of \CFA  user thread and processor creation are shown in \VRef[Listing]{l:cfa_thd_init}. 
 
-\begin{cfa}[tabsize=3,caption={\CFA user thread and processor creation},label={l:cfa_thd_init}]
-
-thread my_thread {}     // user thread type
-void main( my_thread & this ) { // thread start routine
-    printf("Hello threading world\n");
+\begin{cfa}[caption={Example of \CFA user thread and processor creation},label={l:cfa_thd_init}]
+@thread@ my_thread {...};			$\C{// user thread type}$
+void @main@( my_thread & this ) {	$\C{// thread start routine}$
+	sout | "Hello threading world";
 }
 
 int main() {
-    // add 2 processors, now 3 total
-    processor p[2];    
-    {
-        my_thread t1;
-        my_thread t2;
-    } // waits for threads to end before going out of scope
+	processor p[2];					$\C{// add 2 processors = 3 total with starting processor}$
+	{
+		my_thread t[2], * t3 = new();	$\C{// create 3 user threads, running in main routine}$
+		... // execute concurrently
+		delete( t3 );				$\C{// wait for thread to end and deallocate}$
+	} // waits for threads to end and deallocate
 }
+\end{cfa}
 
-\end{cfa}
+When processors are added, they are added alongside the existing processor given to each program. 
+Thus, for $N$ processors, allocate $N-1$ processors. 
+A thread is implicitly joined at deallocated, either implicitly at block exit for stack allocation or explicitly at @delete@ for heap allocation. 
+The thread performing the deallocation must wait for the thread to terminate before the deallocation can occur. 
+A thread terminates by returning from the main routine where it starts.
+
+% Local Variables: %
+% tab-width: 4 %
+% End: %