Changes in doc/theses/colby_parsons_MMAth/text/CFA_concurrency.tex [9509d67a:aae9c17]

File:

• doc/theses/colby_parsons_MMAth/text/CFA_concurrency.tex (modified) (1 diff)

doc/theses/colby_parsons_MMAth/text/CFA_concurrency.tex

@@ -1 +1 @@
 \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 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.
+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 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 declaring 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}. 
 
-\CFA provides user-level threading and supports an $M$:$N$ threading model where $M$ user threads are scheduled on $N$ kernel threads and both $M$ and $N$ can be explicitly set by the programmer.
-Kernel threads are created by declaring processor objects;
-user threads are created by declaring a thread objects.
-\VRef[Listing]{l:cfa_thd_init} shows a typical examples of creating a \CFA user-thread type, and then as declaring processor ($N$) and thread objects ($M$).
 \begin{cfa}[caption={Example of \CFA user thread and processor creation},label={l:cfa_thd_init}]
-@thread@ my_thread {                            $\C{// user thread type (like structure)}$
-        ... // arbitrary number of field declarations
-};
-void @main@( @my_thread@ & this ) {     $\C{// thread start routine}$
+@thread@ my_thread {...};                       $\C{// user thread type}$
+void @main@( my_thread & this ) {       $\C{// thread start routine}$
         sout | "Hello threading world";
 }
-int main() {                                            $\C{// program starts with a processor (kernel thread)}$
+
+int main() {
         @processor@ p[2];                               $\C{// add 2 processors = 3 total with starting processor}$
         {
-                @my_thread@ t[2], * t3 = new(); $\C{// create 2 stack allocated, 1 dynamic allocated user threads}$
+                my_thread t[2], * t3 = new();   $\C{// create 3 user threads, running in main routine}$
                 ... // execute concurrently
-                delete( t3 );                           $\C{// wait for t3 to end and deallocate}$
-    } // wait for threads t[0] and t[1] to end and deallocate
-} // deallocate additional kernel threads
+                delete( t3 );                           $\C{// wait for thread to end and deallocate}$
+        } // wait for threads to end and deallocate
+}
 \end{cfa}
-A thread type is are defined using the aggregate kind @thread@.
-For each thread type, a corresponding @main@ routine must be defined, which is where the thread starts running once when a thread object are is created.
-The @processor@ declaration adds addition kernel threads alongside the existing processor given to each program.
-Thus, for $N$ processors, allocate $N-1$ processors.
-A thread is implicitly joined at deallocation, 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.
+
+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 deallocation, 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.
 
-\section{Existing and New Concurrency Features}
-
+\section{Existing Concurrency Features}
 \CFA currently provides a suite of concurrency features including futures, locks, condition variables, generators, coroutines, monitors.
 Examples of these features are omitted as most of them are the same as their counterparts in other languages.
 It is worthwhile to note that all concurrency features added to \CFA are made to be compatible each other.
-The laundry list of features above and the ones introduced in this thesis can be used in the same program without issue, and the features are designed to interact in meaningful ways.
-For example, a thread can inteact with a monitor, which can interact with a coroutine, which can interact with a generator.
+The laundry list of features above and the ones introduced in this thesis can be used in the same program without issue.
 
 Solving concurrent problems requires a diverse toolkit.