Changeset 0f8b1a7


Ignore:
Timestamp:
Sep 7, 2023, 10:36:06 AM (14 months ago)
Author:
caparsons <caparson@…>
Branches:
master
Children:
3ee8853
Parents:
154672d
Message:

merged in Peter's edits with a few small changes

Location:
doc/theses/colby_parsons_MMAth/text
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • doc/theses/colby_parsons_MMAth/text/conclusion.tex

    r154672d r0f8b1a7  
    66
    77The goal of this thesis is to expand concurrent support in \CFA to fill in gaps and increase support for writing safe and efficient concurrent programs.
    8 The presented features achieves this goal and provide users with the means to write scalable concurrent programs in \CFA through multiple avenues.
    9 Additionally, the tools presented provide safety and productivity features that support detection of deadlock and other common concurrency errors, easy concurrent shutdown, and toggleable performance statistics.
     8The presented features achieve this goal and provide users with the means to write scalable concurrent programs in \CFA through multiple avenues.
     9Additionally, the tools presented provide safety and productivity features including: detection of deadlock and other common concurrency errors, easy concurrent shutdown, and toggleable performance statistics.
    1010
    1111For locking, the mutex statement provides a safe and easy-to-use interface for mutual exclusion.
    12 If programmers have a preference for a message-passing paradigm, \CFA now supports it in the form of channels and/or actors.
    13 The @waituntil@ statement simplifies writing concurrent programs in both the message passing and shared memory paradigms of concurrency.
     12If programmers prefer the message-passing paradigm, \CFA now supports it in the form of channels and actors.
     13The @waituntil@ statement simplifies writing concurrent programs in both the message-passing and shared-memory paradigms of concurrency.
    1414Finally, no other programming language provides a synchronous multiplexing tool that is polymorphic over resources like \CFA's @waituntil@.
    1515This work successfully provides users with familiar concurrent-language support, but with additional value added over similar utilities in other popular languages.
     
    2020\item Channels with comparable performance to Go, which have safety and productivity features including deadlock detection and an easy-to-use exception-based channel @close@ routine.
    2121\item An in-memory actor system, which achieves the lowest latency message send of systems tested due to the novel copy-queue data structure.
    22 \item As well, the actor system has built-in detection of six common actor errors, with comparable performance to other systems across all benchmarks.
     22\item As well, the actor system has built-in detection of six common actor errors, with excellent performance compared to other systems across all benchmarks.
    2323\item A @waituntil@ statement, which tackles the hard problem of allowing a thread to safely wait synchronously for an arbitrary set of concurrent resources.
    2424\end{enumerate}
    2525
    26 The add features are now commonly used to solve concurrent problems in \CFA.
     26The added features are now commonly used to solve concurrent problems in \CFA.
    2727The @mutex@ statement sees use across almost all concurrent code in \CFA, as it is the simplest mechanism for providing thread-safe input and output.
    2828The channels and the @waituntil@ statement see use in programs where a thread operates as a server or administrator, which accepts and distributes work among channels based on some shared state.
     
    3232From 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.
    3333Performance results verify that each new feature is comparable or better than similar features in other programming languages.
    34 All in all, this suite of concurrent tools expands a \CFA programmers' ability to easily write safe and performant multi-threaded programs.
     34All in all, this suite of concurrent tools expands a \CFA programmer's ability to easily write safe and performant multi-threaded programs.
    3535
    3636\section{Future Work}
     
    3838\subsection{Further Implicit Concurrency}
    3939
    40 This thesis only scratches the surface of implicit concurrency by providing a channels and actors.
     40This thesis only scratches the surface of implicit concurrency by providing an actor system.
    4141There is room for more implicit concurrency tools in \CFA.
    4242User-defined implicit concurrency in the form of annotated loops or recursive concurrent functions exists in other languages and libraries~\cite{uC++,OpenMP}.
  • doc/theses/colby_parsons_MMAth/text/intro.tex

    r154672d r0f8b1a7  
    2929\item Livelock, where threads constantly attempt a concurrent operation unsuccessfully, resulting in no progress being made.
    3030\item Starvation, where \emph{some} threads constantly attempt a concurrent operation unsuccessfully, resulting in partial progress being made.
    31 % where some threads may be deprived access to some shared resource due to unfairness and never make progress.
    3231\item Deadlock, where some threads wait for an event that cannot occur, blocking them indefinitely, resulting in no progress being made.
    3332\end{enumerate}
    34 Even with the guiding hand of concurrent tools these pitfalls still catch unwary programmers, but good language support help significantly to prevent, detect, and mitigate these problems.
     33Even with the guiding hand of concurrent tools these pitfalls still catch unwary programmers, but good language support helps significantly to prevent, detect, and mitigate these problems.
    3534
    3635\section{Thesis Overview}
     
    3837Chapter~\ref{s:cfa} of this thesis aims to familiarize the reader with the language \CFA.
    3938In this chapter, syntax and features of the \CFA language that appear in this work are discussed.
    40 Chapter~\ref{s:cfa_concurrency} briefly discusses prior concurrency work in \CFA, and how the work in this thesis builds on top of this existing framework.
    41 Each remaining chapter introduces an additional \CFA concurrent-language feature, which includes discussing prior related work for this feature, extensions over prior features, and using benchmarks to compare the performance this feature with corresponding or similar features in other languages and systems.
     39Chapter~\ref{s:cfa_concurrency} briefly discusses prior concurrency work in \CFA, and how the work in this thesis builds on top of the existing framework.
     40Each remaining chapter introduces an additional \CFA concurrent-language feature, which includes discussing prior related work for the feature, extensions over prior features, and uses benchmarks to compare the performance the feature with corresponding or similar features in other languages and systems.
    4241
    4342Chapter~\ref{s:mutexstmt} discusses the @mutex@ statement, a language feature that provides safe and simple lock usage.
     
    4847An actor system is a close cousin of channels, as it also belongs to the message passing paradigm of concurrency.
    4948However, an actor system provides a greater degree of abstraction and ease of scalability, making it useful for a different range of problems than channels.
    50 The actor system in \CFA is compared with a variety of other systems on a suite of benchmarks. %, where it achieves significant performance gains over other systems due to its design.
     49The actor system in \CFA is compared with a variety of other systems on a suite of benchmarks.
    5150Chapter~\ref{s:waituntil} discusses the \CFA @waituntil@ statement, which provides the ability to synchronize while waiting for a resource, such as acquiring a lock, accessing a future, or writing to a channel.
    5251The \CFA @waituntil@ statement provides greater flexibility and expressibility than similar features in other languages.
Note: See TracChangeset for help on using the changeset viewer.