Changeset 1f10959

Timestamp:

Sep 6, 2023, 11:48:16 AM (8 months ago)

Author:

caparsons <caparson@…>

Branches:

master

Children:

92d8cda

Parents:

aae9c17

Message:

expanded upon intro and conclusion

Location:

doc/theses/colby_parsons_MMAth/text

Files:

• conclusion.tex (modified) (2 diffs)
• intro.tex (modified) (2 diffs)

doc/theses/colby_parsons_MMAth/text/conclusion.tex

@@ -5 +5 @@
 % ======================================================================
 
-This thesis presented a suite of safe and efficient concurrency tools that provide users with the means to write scalable programs in \CFA through multiple avenues.
-If users prefer the message passing paradigm of concurrency, \CFA now provides message passing tools in the form of a performant actor system and channels.
+The goal of this thesis was to expand the concurrent support that \CFA offers to fill in gaps and support language users' ability to write safe and efficient concurrent programs.
+The presented features achieves this goal, and provides users with the means to write scalable programs in \CFA through multiple avenues.
+Additionally, the tools presented include safety and productivity features from deadlock detection, to detection of common programming errors, easy concurrent shutdown, and toggleable performance statistics.
+Programmers often have preferences between computing paradigms and concurrency is no exception.
+If users prefer the message passing paradigm of concurrency, \CFA now provides message passing utilities in the form of an actor system and channels.
 For shared memory concurrency, the mutex statement provides a safe and easy-to-use interface for mutual exclusion.
 The @waituntil@ statement aids in writing concurrent programs in both the message passing and shared memory paradigms of concurrency.
 Furthermore, no other language provides a synchronous multiplexing tool polymorphic over resources like \CFA's @waituntil@.
-
-These features are commonly used in conjunction to solve concurrent problems.
-The @waituntil@ statement, the @mutex@ statement, and channels will all likely see use in a program where a thread operates as an administrator or server which accepts and distributes work among channels based on some shared state.
-The @mutex@ statement sees use across almost all concurrent code in \CFA, since it is used with the stream operator @sout@ to provide thread-safe output.
-While not yet implemented, the polymorphic support of the @waituntil@ statement could see use in conjunction with the actor system to enable user threads outside the actor system to wait for work to be done, or for actors to finish.
-A user of \CFA does not have to solely subscribe to the message passing or shared memory concurrent paradigm.
-As such, channels in \CFA are often used to pass pointers to shared memory that may still need mutual exclusion, requiring the @mutex@ statement to also be used.
+This work successfully provides users with familiar concurrent language support, but with additional value added over similar utilities in other popular languages.
 
 On overview of the contributions in this thesis include the following:
@@ -25 +22 @@
 \item A @waituntil@ statement which tackles the hard problem of allowing a thread to safely synch\-ronously wait for some set of concurrent resources.
 \end{enumerate}
+
+The features presented are commonly used in conjunction to solve concurrent problems.
+The @waituntil@ statement, the @mutex@ statement, and channels will all likely see use in a program where a thread operates as an administrator or server which accepts and distributes work among channels based on some shared state.
+The @mutex@ statement sees use across almost all concurrent code in \CFA, since it is used with the stream operator @sout@ to provide thread-safe output.
+While not yet implemented, the polymorphic support of the @waituntil@ statement could see use in conjunction with the actor system to enable user threads outside the actor system to wait for work to be done, or for actors to finish.
+A user of \CFA does not have to solely subscribe to the message passing or shared memory concurrent paradigm.
+As such, channels in \CFA are often used to pass pointers to shared memory that may still need mutual exclusion, requiring the @mutex@ statement to also be used.
 
 From the novel copy-queue data structure in the actor system and the plethora of user-supporting safety features, all these utilities build upon existing concurrent tooling with value added.

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}