\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, 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 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}[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() {
	@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}$
	} // wait for threads to end and deallocate
}
\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: %
