Changeset deeda09 for doc/theses/colby_parsons_MMAth/text/CFA_concurrency.tex

Timestamp:

Apr 4, 2023, 11:58:50 AM (15 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master

Children:

9586d22

Parents:

11e3e97

Message:

proofread CFA-concurrency chapter

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 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: %