Changeset aae9c17 for doc/theses/colby_parsons_MMAth/text/channels.tex

Timestamp:

Sep 5, 2023, 5:48:31 PM (11 months ago)

Author:

caparsons <caparson@…>

Branches:

master

Children:

1f10959, efe39bb

Parents:

f54e6ec

Message:

edited thesis to incorporate Gregors comments

File:

• doc/theses/colby_parsons_MMAth/text/channels.tex (modified) (6 diffs)

doc/theses/colby_parsons_MMAth/text/channels.tex

@@ -39 +39 @@
 Zero sized implies the communication is synchronous, \ie the producer must wait for the consumer to arrive or vice versa for a value to be communicated.
 \item
-Fixed sized (bounded) implies the communication is asynchronous, \ie the producer can proceed up to the buffer size and vice versa for the consumer with respect to removal.
+Fixed sized (bounded) implies the communication is mostly asynchronous, \ie the producer can proceed up to the buffer size and vice versa for the consumer with respect to removal, at which point the producer/consumer would wait.
 \item
 Infinite sized (unbounded) implies the communication is asynchronous, \ie the producer never waits but the consumer waits when the buffer is empty.
@@ -66 +66 @@
 
 \section{Channel Implementation}\label{s:chan_impl}
-Currently, only the Go programming language provides user-level threading where the primary communication mechanism is channels.
-Experiments were conducted that varied the producer-consumer algorithm and lock type used inside the channel.
+Currently, only the Go and Erlang programming languages provide user-level threading where the primary communication mechanism is channels.
+Both Go and Erlang have user-level threading and preemptive scheduling, and both use channels for communication.
+Go provides multiple homogeneous channels; each have a single associated type.
+Erlang, which is closely related to actor systems, provides one heterogeneous channel per thread (mailbox) with a typed receive pattern.
+Go encourages users to communicate via channels, but provides them as an optional language feature.
+On the other hand, Erlang's single heterogeneous channel is a fundamental part of the threading system design; using it is unavoidable.
+Similar to Go, \CFA's channels are offered as an optional language feature.
+
+While iterating on channel implementation, experiments were conducted that varied the producer-consumer algorithm and lock type used inside the channel.
 With the exception of non-\gls{fcfs} or non-\gls{fifo} algorithms, no algorithm or lock usage in the channel implementation was found to be consistently more performant that Go's choice of algorithm and lock implementation.
 Performance of channels can be improved by sharding the underlying buffer \cite{Dice11}. 
@@ -82 +89 @@
 As a result, contention on the internal lock is decreased; only entering threads compete for the lock since unblocking threads do not reacquire the lock.
 The other advantage of Go's wait-morphing approach is that it eliminates the bottleneck of waiting for signalled threads to run.
-Note, the property of acquiring/releasing the lock only once can also be achieved with a different form of cooperation, called \Newterm{baton passing}.
+Note that the property of acquiring/releasing the lock only once can also be achieved with a different form of cooperation, called \Newterm{baton passing}.
 Baton passing occurs when one thread acquires a lock but does not release it, and instead signals a thread inside the critical section, conceptually ``passing'' the mutual exclusion from the signalling thread to the signalled thread.
 The baton-passing approach has threads cooperate to pass mutual exclusion without additional lock acquires or releases;
@@ -147 +154 @@
 Thus, improperly handled \gls{toctou} issues with channels often result in deadlocks as threads performing the termination may end up unexpectedly blocking in their attempt to help other threads exit the system.
 
-\paragraph{Go channels} provide a set of tools to help with concurrent shutdown~\cite{go:chan} using a @close@ operation in conjunction with the \Go{select} statement.
+Go channels provide a set of tools to help with concurrent shutdown~\cite{go:chan} using a @close@ operation in conjunction with the \Go{select} statement.
 The \Go{select} statement is discussed in \ref{s:waituntil}, where \CFA's @waituntil@ statement is compared with the Go \Go{select} statement.
 
@@ -159 +166 @@
 These design choices fit Go's paradigm of error management, where users are expected to explicitly check for errors, rather than letting errors occur and catching them.
 If errors need to occur in Go, return codes are used to pass error information up call levels.
-Note, panics in Go can be caught, but it is not the idiomatic way to write Go programs.
+Note that panics in Go can be caught, but it is not the idiomatic way to write Go programs.
 
 While Go's channel-closing semantics are powerful enough to perform any concurrent termination needed by a program, their lack of ease of use leaves much to be desired.
@@ -451 +458 @@
 The results of the benchmark are shown in Figure~\ref{f:chanPerf}.
 The performance of Go and \CFA channels on this microbenchmark is comparable.
-Note, the performance should decline as the number of cores increases as the channel operations occur in a critical section, so increasing cores results in higher contention with no increase in parallelism.
+Note that the performance should decline as the number of cores increases as the channel operations occur in a critical section, so increasing cores results in higher contention with no increase in parallelism.
+
+The performance of \CFA and Go's shutdown mechanisms is not measured, as shutdown is an exceptional case that does not occur frequently in most programs. Additionally, it is difficult to measure channel shutdown performance; threads need to be synchronized between each subsequent shutdown, which is likely more expensive than the shutdown mechanism itself.
 
 \begin{figure}
         \centering
-        \subfloat[AMD \CFA Channel Benchmark]{
+        \subfloat[AMD Channel Benchmark]{
                 \resizebox{0.5\textwidth}{!}{\input{figures/nasus_Channel_Contention.pgf}}
                 \label{f:chanAMD}
         }
-        \subfloat[Intel \CFA Channel Benchmark]{
+        \subfloat[Intel Channel Benchmark]{
                 \resizebox{0.5\textwidth}{!}{\input{figures/pyke_Channel_Contention.pgf}}
                 \label{f:chanIntel}