source: doc/theses/colby_parsons_MMAth/text/CFA_concurrency.tex @ 91b9e10

Last change on this file since 91b9e10 was 9509d67a, checked in by caparsons <caparson@…>, 14 months ago

Incorporated changes in response to Trevor's comments.

  • Property mode set to 100644
File size: 4.0 KB
Line 
1\chapter{Concurrency in \CFA}\label{s:cfa_concurrency}
2
3The groundwork for concurrency in \CFA was laid by Thierry Delisle in his Master's Thesis~\cite{Delisle18}.
4In that work, he introduced generators, coroutines, monitors, and user-level threading.
5Not listed in that work were basic concurrency features needed as building blocks, such as locks, futures, and condition variables.
6
7\section{Threading Model}\label{s:threading}
8
9\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.
10Kernel threads are created by declaring processor objects;
11user threads are created by declaring a thread objects.
12\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$).
13\begin{cfa}[caption={Example of \CFA user thread and processor creation},label={l:cfa_thd_init}]
14@thread@ my_thread {                            $\C{// user thread type (like structure)}$
15        ... // arbitrary number of field declarations
16};
17void @main@( @my_thread@ & this ) {     $\C{// thread start routine}$
18        sout | "Hello threading world";
19}
20int main() {                                            $\C{// program starts with a processor (kernel thread)}$
21        @processor@ p[2];                               $\C{// add 2 processors = 3 total with starting processor}$
22        {
23                @my_thread@ t[2], * t3 = new(); $\C{// create 2 stack allocated, 1 dynamic allocated user threads}$
24                ... // execute concurrently
25                delete( t3 );                           $\C{// wait for t3 to end and deallocate}$
26    } // wait for threads t[0] and t[1] to end and deallocate
27} // deallocate additional kernel threads
28\end{cfa}
29A thread type is are defined using the aggregate kind @thread@.
30For 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.
31The @processor@ declaration adds addition kernel threads alongside the existing processor given to each program.
32Thus, for $N$ processors, allocate $N-1$ processors.
33A thread is implicitly joined at deallocation, either implicitly at block exit for stack allocation or explicitly at @delete@ for heap allocation.
34The thread performing the deallocation must wait for the thread to terminate before the deallocation can occur.
35A thread terminates by returning from the main routine where it starts.
36
37\section{Existing and New Concurrency Features}
38
39\CFA currently provides a suite of concurrency features including futures, locks, condition variables, generators, coroutines, monitors.
40Examples of these features are omitted as most of them are the same as their counterparts in other languages.
41It is worthwhile to note that all concurrency features added to \CFA are made to be compatible each other.
42The 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.
43For example, a thread can inteact with a monitor, which can interact with a coroutine, which can interact with a generator.
44
45Solving concurrent problems requires a diverse toolkit.
46This work aims to flesh out \CFA's concurrent toolkit to fill in gaps.
47Futures are used when a one-shot result needs to be safely delivered concurrently, and are especially useful when the receiver needs to block until the result is ready.
48When multiple values have to be sent, or more synchronization is needed, futures are not powerful enough, which introduces the need for channels.
49A close cousin of channels is actor systems, which take message passing a step further and go beyond channels to provide a level of abstraction that allows for easy scalability and separation of concerns.
50The @waituntil@ and @mutex@ statements provide utilities allowing for easier use of the existing features.
51All the contributions of this thesis provide the ability to solve concurrent problems that formerly would require a user to either implement a similar feature themselves or construct an ad-hoc solution.
52
53% Local Variables: %
54% tab-width: 4 %
55% End: %
Note: See TracBrowser for help on using the repository browser.