Changeset f3f009f for doc/theses/colby_parsons_MMAth/text/intro.tex

Timestamp:

Sep 6, 2023, 3:44:40 PM (10 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

01510fe

Parents:

4894239 (diff), 4a40fca7 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• doc/theses/colby_parsons_MMAth/text/intro.tex (modified) (2 diffs)

doc/theses/colby_parsons_MMAth/text/intro.tex

@@ -16 +16 @@
 All of these features exist in other programming languages in some shape or form, however this thesis extends the original ideas by improving performance, productivity, and safety.
 
+\section{The Need For Concurrent Features}
+Asking a programmer to write a complex concurrent program without any concurrent language features is asking them to undertake a very difficult task.
+They would only be able to rely on the atomicity that their hardware provides and would have to build up from there.
+This would be like asking a programmer to write a complex sequential program only in assembly.
+Both are doable, but would often be easier and less error prone with higher level tooling.
+
+Concurrent programming has many pitfalls that are unique and do not show up in sequential code:
+\begin{enumerate}
+\item Deadlock, where threads cyclically wait on resources, blocking them indefinitely.
+\item Livelock, where threads constantly attempt a concurrent operation unsuccessfully, resulting in no progress being made.
+\item Race conditions, where thread orderings can result in differing behaviours and correctness of a program execution.
+\item Starvation, where threads may be deprived of access to some shared resource due to unfairness and never make progress.
+\end{enumerate}
+Even with the guiding hand of concurrent tools these pitfalls can still catch unwary programmers, but good language support can prevent, detect, and mitigate these problems.
+
+\section{A Brief Overview}
 
 The first chapter of this thesis aims to familiarize the reader with the language \CFA.
@@ -31 +47 @@
 The @waituntil@ statement presented provides greater flexibility and expressibility than similar features in other languages.
 All in all, the features presented aim to fill in gaps in the current \CFA concurrent language support, and enable users to write a wider range of complex concurrent programs with ease.
+
+\section{Contributions}
+This work presents the following contributions:
+\begin{enumerate}
+\item The @mutex@ statement which:
+\begin{itemize}[itemsep=0pt]
+\item
+provides deadlock-free multiple lock acquisition,
+\item
+clearly denotes lock acquisition and release,
+\item
+and has good performance irrespective of lock ordering.
+\end{itemize}
+\item Channels which:
+\begin{itemize}[itemsep=0pt]
+    \item
+    achieves comparable performance to Go, the gold standard for concurrent channels,
+    \item
+    has deadlock detection,
+    \item
+    introduces easy-to-use exception-based @close@ semantics,
+    \item
+    and provides toggle-able statistics for performance tuning.
+\end{itemize}
+\item An in-memory actor system that:
+\begin{itemize}[itemsep=0pt]
+    \item
+    achieves the lowest latency message send of all tested systems,
+    \item
+    is the first inverted actor system to introduce queue stealing,
+    \item
+    attains zero-victim-cost stealing through a carefully constructed stealing mechanism,
+    \item
+    gains performance through static-typed message sends, eliminating the need for dynamic dispatch,
+    \item
+    introduces the copy queue, an array based queue specialized for the actor use case to minimize calls to the memory allocator,
+    \item
+    has robust detection of six tricky, but common actor programming errors,
+    \item
+    achieves very good performance on a diverse benchmark suite compared to other actor systems,
+    \item
+    and provides toggle-able statistics for performance tuning.
+\end{itemize}
+
+\item A @waituntil@ statement which:
+\begin{itemize}[itemsep=0pt]
+    \item
+    is the only known polymorphic synchronous multiplexing language feature,
+    \item
+    provides greater expressibility of waiting conditions than other languages,
+    \item
+    and achieves comparable performance to similar features in two other languages,
+\end{itemize}
+\end{enumerate}