Diff [61accc5c6c10982782355b908a789b97fc95a130:c2b10fa74f15db4154889e9e95bf2605b55726e3] for / – Cforall

doc/papers/concurrency/Paper.tex

-              r61accc5
+              rc2b10fa
 \newcommand{\Textbf}[2][red]{{\color{#1}{\textbf{#2}}}}
 \newcommand{\Emph}[2][red]{{\color{#1}\textbf{\emph{#2}}}}
+\newcommand{\R}[1]{\Textbf{#1}}
+\newcommand{\B}[1]{{\Textbf[blue]{#1}}}
+\newcommand{\G}[1]{{\Textbf[OliveGreen]{#1}}}
 \newcommand{\uC}{$\mu$\CC}
+\newcommand{\TODO}[1]{{\Textbf{#1}}}
+\newcommand{\cit}{\textsuperscript{[Citation Needed]}\xspace}
+\newcommand{\TODO}{{\Textbf{TODO}}}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \section{Introduction}
 This paper provides a minimal concurrency \newterm{Application Program Interface} (API) that is simple, efficient and can be used to build other concurrency features.
+This paper provides a minimal concurrency \newterm{Abstract Program Interface} (API) that is simple, efficient and can be used to build other concurrency features.
 While the simplest concurrency system is a thread and a lock, this low-level approach is hard to master.
 An easier approach for programmers is to support higher-level constructs as the basis of concurrency.
 …
 \subsection{\protect\CFA's Thread Building Blocks}
 An important missing feature in C is threading\footnote{While the C11 standard defines a \protect\lstinline@threads.h@ header, it is minimal and defined as optional.
+An important missing feature in C is threading\footnote{While the C11 standard defines a ``threads.h'' header, it is minimal and defined as optional.
 As such, library support for threading is far from widespread.
 At the time of writing the paper, neither \protect\lstinline@gcc@ nor \protect\lstinline@clang@ support \protect\lstinline@threads.h@ in their standard libraries.}.
 In modern programming languages, a lack of threading is unacceptable~\cite{Sutter05, Sutter05b}, and therefore existing and new programming languages must have tools for writing efficient concurrent programs to take advantage of parallelism.
+At the time of writing the paper, neither \protect\lstinline|gcc| nor \protect\lstinline|clang| support ``threads.h'' in their standard libraries.}.
+On modern architectures, a lack of threading is unacceptable~\cite{Sutter05, Sutter05b}, and therefore existing and new programming languages must have tools for writing efficient concurrent programs to take advantage of parallelism.
 As an extension of C, \CFA needs to express these concepts in a way that is as natural as possible to programmers familiar with imperative languages.
 Furthermore, because C is a system-level language, programmers expect to choose precisely which features they need and which cost they are willing to pay.
 …
 \newbox\myboxA
 \begin{lrbox}{\myboxA}
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+\begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 `int f1, f2, state = 1;`   // single global variables
 int fib() {
 …
+        }
+}
 \end{cfa}
+\end{lstlisting}
 \end{lrbox}
 \newbox\myboxB
 \begin{lrbox}{\myboxB}
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+\begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 #define FIB_INIT `{ 0, 1 }`
 typedef struct { int f2, f1; } Fib;
 …
+        }
+}
 \end{cfa}
+\end{lstlisting}
 \end{lrbox}
 …
 \newbox\myboxA
 \begin{lrbox}{\myboxA}
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+\begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 `coroutine` Fib { int fn; };
 void main( Fib & fib ) with( fib ) {
 …
+        }
+}
 \end{cfa}
+\end{lstlisting}
 \end{lrbox}
 \newbox\myboxB
 \begin{lrbox}{\myboxB}
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+\begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 `coroutine` Fib { int ret; };
 void main( Fib & f ) with( fib ) {
 …
 \end{cfa}
+\end{lstlisting}
 \end{lrbox}
 \subfloat[3 States, internal variables]{\label{f:Coroutine3States}\usebox\myboxA}
 …
 \newbox\myboxA
 \begin{lrbox}{\myboxA}
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+\begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 `coroutine` Format {
         char ch;   // used for communication
 …
+        }
+}
 \end{cfa}
+\end{lstlisting}
 \end{lrbox}
 \newbox\myboxB
 \begin{lrbox}{\myboxB}
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+\begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 struct Format {
         char ch;
 …
         format( &fmt );
+}
 \end{cfa}
+\end{lstlisting}
 \end{lrbox}
 \subfloat[\CFA Coroutine]{\label{f:CFAFmt}\usebox\myboxA}
 …
 };
 \end{cfa}
+&
+{\Large $\Rightarrow$}
+&
+& {\Large $\Rightarrow$} &
 \begin{tabular}{@{}ccc@{}}
 \begin{cfa}
 …
+}
 \end{cfa}
 A consequence of the strongly typed approach to main is that memory layout of parameters and return values to/from a thread are now explicitly specified in the \textbf{API}.
+A consequence of the strongly typed approach to main is that memory layout of parameters and return values to/from a thread are now explicitly specified in the \textbf{api}.
 \end{comment}
 …
 \label{s:InternalScheduling}
+While monitor mutual-exclusion provides safe access to shared data, the monitor data may indicate that a thread accessing it cannot proceed.
+For example, Figure~\ref{f:GenericBoundedBuffer} shows a bounded buffer that may be full/empty so produce/consumer threads must block.
+While monitor mutual-exclusion provides safe access to shared data, the monitor data may indicate that a thread accessing it cannot proceed, \eg a bounded buffer, Figure~\ref{f:BoundedBuffer}, may be full/empty so produce/consumer threads must block.
 Leaving the monitor and trying again (busy waiting) is impractical for high-level programming.
 Monitors eliminate busy waiting by providing internal synchronization to schedule threads needing access to the shared data, where the synchronization is blocking (threads are parked) versus spinning.
 Synchronization is generally achieved with internal~\cite{Hoare74} or external~\cite[\S~2.9.2]{uC++} scheduling, where \newterm{scheduling} defines which thread acquires the critical section next.
 \newterm{Internal scheduling} is characterized by each thread entering the monitor and making an individual decision about proceeding or blocking, while \newterm{external scheduling} is characterized by an entering thread making a decision about proceeding for itself and on behalf of other threads attempting entry.
+The synchronization is generally achieved with internal~\cite{Hoare74} or external~\cite[\S~2.9.2]{uC++} scheduling, where \newterm{scheduling} is defined as indicating which thread acquires the critical section next.
+\newterm{Internal scheduling} is characterized by each thread entering the monitor and making an individual decision about proceeding or blocking, while \newterm{external scheduling} is characterized by an entering thread making a decision about proceeding for itself and behalf of other threads attempting entry.
 Figure~\ref{f:BBInt} shows a \CFA bounded-buffer with internal scheduling, where producers/consumers enter the monitor, see the buffer is full/empty, and block on an appropriate condition lock, @full@/@empty@.
 …
 \begin{enumerate}
 \item
 The signalling thread returns immediately, and the signalled thread continues.
+The signalling thread leaves immediately, and the signalled thread continues.
 \item
 The signalling thread continues and the signalled thread is marked for urgent unblocking at the next scheduling point (exit/wait).
+The signalling thread continues and the signalled thread is marked for urgent unblocking at subsequent scheduling points (exit/wait).
 \item
 The signalling thread blocks but is marked for urgrent unblocking at the next scheduling point and the signalled thread continues.
+The signalling thread blocks but is marked for urgrent unblocking and the signalled thread continues.
 \end{enumerate}
 The first approach is too restrictive, as it precludes solving a reasonable class of problems (\eg dating service).
 \CFA supports the next two semantics as both are useful.
 Finally, while it is common to store a @condition@ as a field of the monitor, in \CFA, a @condition@ variable can be created/stored independently.
-Furthermore, a condition variable is tied to a \emph{group} of monitors on first use (called \newterm{branding}), which means that using internal scheduling with distinct sets of monitors requires one condition variable per set of monitors.
 \begin{figure}
 …
 \newbox\myboxA
 \begin{lrbox}{\myboxA}
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+\begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 forall( otype T ) { // distribute forall
         monitor Buffer {
 …
+        }
+}
 \end{cfa}
+\end{lstlisting}
 \end{lrbox}
 \newbox\myboxB
 \begin{lrbox}{\myboxB}
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+\begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 forall( otype T ) { // distribute forall
         monitor Buffer {
 …
+        }
+}
 \end{cfa}
+\end{lstlisting}
 \end{lrbox}
 …
 \subfloat[External Scheduling]{\label{f:BBExt}\usebox\myboxB}
 \caption{Generic Bounded-Buffer}
 \label{f:GenericBoundedBuffer}
+\label{f:BoundedBuffer}
 \end{figure}
 …
 External scheduling is controlled by the @waitfor@ statement, which atomically blocks the calling thread, releases the monitor lock, and restricts the routine calls that can next acquire mutual exclusion.
 If the buffer is full, only calls to @remove@ can acquire the buffer, and if the buffer is empty, only calls to @insert@ can acquire the buffer.
+Threads making calls to routines that are currently excluded block outside (external) of the monitor on a calling queue, versus blocking on condition queues inside (internal) of the monitor.
+For internal scheduling, non-blocking signalling (as in the producer/consumer example) is used when the signaller is providing the cooperation for a waiting thread;
+the signaller enters the monitor and changes state, detects a waiting threads that can use the state, performs a non-blocking signal on the condition queue for the waiting thread, and exits the monitor to run concurrently.
+The waiter unblocks next, takes the state, and exits the monitor.
+Blocking signalling is the reverse, where the waiter is providing the cooperation for the signalling thread;
+the signaller enters the monitor, detects a waiting thread providing the necessary state, performs a blocking signal to place it on the urgent queue and unblock the waiter.
+The waiter changes state and exits the monitor, and the signaller unblocks next from the urgent queue to take the state.
+Figure~\ref{f:DatingService} shows a dating service demonstrating the two forms of signalling: non-blocking and blocking.
+The dating service matches girl and boy threads with matching compatibility codes so they can exchange phone numbers.
+A thread blocks until an appropriate partner arrives.
+The complexity is exchanging phone number in the monitor,
+While the non-barging monitor prevents a caller from stealing a phone number, the monitor mutual-exclusion property
+The dating service is an example of a monitor that cannot be written using external scheduling because:
+The example in table \ref{tbl:datingservice} highlights the difference in behaviour.
+As mentioned, @signal@ only transfers ownership once the current critical section exits; this behaviour requires additional synchronization when a two-way handshake is needed.
+To avoid this explicit synchronization, the @condition@ type offers the @signal_block@ routine, which handles the two-way handshake as shown in the example.
+This feature removes the need for a second condition variables and simplifies programming.
+Like every other monitor semantic, @signal_block@ uses barging prevention, which means mutual-exclusion is baton-passed both on the front end and the back end of the call to @signal_block@, meaning no other thread can acquire the monitor either before or after the call.
+Threads making calls to routines that are currently excluded wait outside (externally) of the monitor on a calling queue.
+An important aspect of monitor implementation is barging, \ie can calling threads barge ahead of signalled threads?
+If barging is allowed, synchronization between a singller and signallee is difficult, often requiring multiple unblock/block cycles (looping around a wait rechecking if a condition is met).
+\CFA scheduling does \emph{not} have barging, which simplifies synchronization among threads in the monitor.
+Supporting barging prevention as well as extending internal scheduling to multiple monitors is the main source of complexity in the design and implementation of \CFA concurrency.
+Indeed, like the bulk acquire semantics, internal scheduling extends to multiple monitors in a way that is natural to the user but requires additional complexity on the implementation side.
+First, here is a simple example of internal scheduling:
+\begin{cfa}
+monitor A {
+        condition e;
+}
+void foo(A& mutex a1, A& mutex a2) {
+        ...
+        // Wait for cooperation from bar()
+        wait(a1.e);
+        ...
+}
+void bar(A& mutex a1, A& mutex a2) {
+        // Provide cooperation for foo()
+        ...
+        // Unblock foo
+        signal(a1.e);
+}
+\end{cfa}
+% ======================================================================
+% ======================================================================
+\subsection{Internal Scheduling - Multi-Monitor}
+% ======================================================================
+% ======================================================================
+It is easy to understand the problem of multi-monitor scheduling using a series of pseudo-code examples.
+Note that for simplicity in the following snippets of pseudo-code, waiting and signalling is done using an implicit condition variable, like Java built-in monitors.
+Indeed, @wait@ statements always use the implicit condition variable as parameters and explicitly name the monitors (A and B) associated with the condition.
+Note that in \CFA, condition variables are tied to a \emph{group} of monitors on first use (called branding), which means that using internal scheduling with distinct sets of monitors requires one condition variable per set of monitors.
+The example below shows the simple case of having two threads (one for each column) and a single monitor A.
+\begin{multicols}{2}
+thread 1
+\begin{cfa}
+acquire A
+        wait A
+release A
+\end{cfa}
+\columnbreak
+thread 2
+\begin{cfa}
+acquire A
+        signal A
+release A
+\end{cfa}
+\end{multicols}
+One thread acquires before waiting (atomically blocking and releasing A) and the other acquires before signalling.
+It is important to note here that both @wait@ and @signal@ must be called with the proper monitor(s) already acquired.
+This semantic is a logical requirement for barging prevention.
+A direct extension of the previous example is a bulk acquire version:
+\begin{multicols}{2}
+\begin{cfa}
+acquire A & B
+        wait A & B
+release A & B
+\end{cfa}
+\columnbreak
+\begin{cfa}
+acquire A & B
+        signal A & B
+release A & B
+\end{cfa}
+\end{multicols}
+\noindent This version uses bulk acquire (denoted using the {\sf\&} symbol), but the presence of multiple monitors does not add a particularly new meaning.
+Synchronization happens between the two threads in exactly the same way and order.
+The only difference is that mutual exclusion covers a group of monitors.
+On the implementation side, handling multiple monitors does add a degree of complexity as the next few examples demonstrate.
+While deadlock issues can occur when nesting monitors, these issues are only a symptom of the fact that locks, and by extension monitors, are not perfectly composable.
+For monitors, a well-known deadlock problem is the Nested Monitor Problem~\cite{Lister77}, which occurs when a @wait@ is made by a thread that holds more than one monitor.
+For example, the following cfa-code runs into the nested-monitor problem:
+\begin{multicols}{2}
+\begin{cfa}
+acquire A
+        acquire B
+                wait B
+        release B
+release A
+\end{cfa}
+\columnbreak
+\begin{cfa}
+acquire A
+        acquire B
+                signal B
+        release B
+release A
+\end{cfa}
+\end{multicols}
+\noindent The @wait@ only releases monitor @B@ so the signalling thread cannot acquire monitor @A@ to get to the @signal@.
+Attempting release of all acquired monitors at the @wait@ introduces a different set of problems, such as releasing monitor @C@, which has nothing to do with the @signal@.
+However, for monitors as for locks, it is possible to write a program using nesting without encountering any problems if nesting is done correctly.
+For example, the next cfa-code snippet acquires monitors {\sf A} then {\sf B} before waiting, while only acquiring {\sf B} when signalling, effectively avoiding the Nested Monitor Problem~\cite{Lister77}.
+\begin{multicols}{2}
+\begin{cfa}
+acquire A
+        acquire B
+                wait B
+        release B
+release A
+\end{cfa}
+\columnbreak
+\begin{cfa}
+acquire B
+        signal B
+release B
+\end{cfa}
+\end{multicols}
+\noindent However, this simple refactoring may not be possible, forcing more complex restructuring.
+% ======================================================================
+% ======================================================================
+\subsection{Internal Scheduling - In Depth}
+% ======================================================================
+% ======================================================================
+A larger example is presented to show complex issues for bulk acquire and its implementation options are analyzed.
+Figure~\ref{f:int-bulk-cfa} shows an example where bulk acquire adds a significant layer of complexity to the internal signalling semantics, and listing \ref{f:int-bulk-cfa} shows the corresponding \CFA code to implement the cfa-code in listing \ref{f:int-bulk-cfa}.
+For the purpose of translating the given cfa-code into \CFA-code, any method of introducing a monitor is acceptable, \eg @mutex@ parameters, global variables, pointer parameters, or using locals with the @mutex@ statement.
 \begin{figure}
+\centering
+\newbox\myboxA
+\begin{lrbox}{\myboxA}
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+enum { CCodes = 20 };
+monitor DS {
+        int GirlPhNo, BoyPhNo;
+        condition Girls[CCodes], Boys[CCodes];
+        condition exchange;
+};
+int girl( DS & mutex ds, int phNo, int ccode ) {
+        if ( is_empty( Boys[ccode] ) ) {
+                wait( Girls[ccode] );
+                GirlPhNo = phNo;
+                exchange.signal();
+        } else {
+                GirlPhNo = phNo;
+                signal( Boys[ccode] );
+                exchange.wait();
+        } // if
+        return BoyPhNo;
+}
+int boy( DS & mutex ds, int phNo, int ccode ) {
+        // as above with boy/girl interchanged
+}
+\end{cfa}
+\end{lrbox}
+\newbox\myboxB
+\begin{lrbox}{\myboxB}
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+monitor DS {
+        int GirlPhNo, BoyPhNo;
+        condition Girls[CCodes], Boys[CCodes];
+};
+int girl( DS & mutex ds, int phNo, int ccode ) {
+        if ( is_empty( Boys[ccode] ) ) { // no compatible
+                wait( Girls[ccode] ); // wait for boy
+                GirlPhNo = phNo; // make phone number available
+        } else {
+                GirlPhNo = phNo; // make phone number available
+                signal_block( Boys[ccode] ); // restart boy
+        } // if
+        return BoyPhNo;
+}
+int boy( DS & mutex ds, int phNo, int ccode ) {
+        // as above with boy/girl interchanged
+}
+\end{cfa}
+\end{lrbox}
+\subfloat[\lstinline@signal@]{\label{f:DatingSignal}\usebox\myboxA}
+\qquad
+\subfloat[\lstinline@signal_block@]{\label{f:DatingSignalBlock}\usebox\myboxB}
+\caption{Dating service. }
+\label{f:DatingService}
+\begin{multicols}{2}
+Waiting thread
+\begin{cfa}[numbers=left]
+acquire A
+        // Code Section 1
+        acquire A & B
+                // Code Section 2
+                wait A & B
+                // Code Section 3
+        release A & B
+        // Code Section 4
+release A
+\end{cfa}
+\columnbreak
+Signalling thread
+\begin{cfa}[numbers=left, firstnumber=10,escapechar=|]
+acquire A
+        // Code Section 5
+        acquire A & B
+                // Code Section 6
+                |\label{line:signal1}|signal A & B
+                // Code Section 7
+        |\label{line:releaseFirst}|release A & B
+        // Code Section 8
+|\label{line:lastRelease}|release A
+\end{cfa}
+\end{multicols}
+\begin{cfa}[caption={Internal scheduling with bulk acquire},label={f:int-bulk-cfa}]
+\end{cfa}
+\begin{center}
+\begin{cfa}[xleftmargin=.4\textwidth]
+monitor A a;
+monitor B b;
+condition c;
+\end{cfa}
+\end{center}
+\begin{multicols}{2}
+Waiting thread
+\begin{cfa}
+mutex(a) {
+        // Code Section 1
+        mutex(a, b) {
+                // Code Section 2
+                wait(c);
+                // Code Section 3
+        }
+        // Code Section 4
+}
+\end{cfa}
+\columnbreak
+Signalling thread
+\begin{cfa}
+mutex(a) {
+        // Code Section 5
+        mutex(a, b) {
+                // Code Section 6
+                signal(c);
+                // Code Section 7
+        }
+        // Code Section 8
+}
+\end{cfa}
+\end{multicols}
+\begin{cfa}[caption={Equivalent \CFA code for listing \ref{f:int-bulk-cfa}},label={f:int-bulk-cfa}]
+\end{cfa}
+\begin{multicols}{2}
+Waiter
+\begin{cfa}[numbers=left]
+acquire A
+        acquire A & B
+                wait A & B
+        release A & B
+release A
+\end{cfa}
+\columnbreak
+Signaller
+\begin{cfa}[numbers=left, firstnumber=6,escapechar=|]
+acquire A
+        acquire A & B
+                signal A & B
+        release A & B
+        |\label{line:secret}|// Secretly keep B here
+release A
+// Wakeup waiter and transfer A & B
+\end{cfa}
+\end{multicols}
+\begin{cfa}[caption={Figure~\ref{f:int-bulk-cfa}, with delayed signalling comments},label={f:int-secret}]
+\end{cfa}
 \end{figure}
+Both internal and external scheduling extend to multiple monitors in a natural way.
+\begin{cquote}
+\begin{tabular}{@{}l@{\hspace{3\parindentlnth}}l@{}}
+\begin{cfa}
+monitor M { `condition e`; ... };
+void foo( M & mutex m1, M & mutex m2 ) {
+        ... wait( `e` ); ...   // wait( e, m1, m2 )
+        ... wait( `e, m1` ); ...
+        ... wait( `e, m2` ); ...
+}
+\end{cfa}
+&
+\begin{cfa}
+void rtn$\(_1\)$( M & mutex m1, M & mutex m2 );
+void rtn$\(_2\)$( M & mutex m1 );
+void bar( M & mutex m1, M & mutex m2 ) {
+        ... waitfor( `rtn` ); ...       // $\LstCommentStyle{waitfor( rtn\(_1\), m1, m2 )}$
+        ... waitfor( `rtn, m1` ); ... // $\LstCommentStyle{waitfor( rtn\(_2\), m1 )}$
+}
+\end{cfa}
+\end{tabular}
+\end{cquote}
+For @wait( e )@, the default semantics is to atomically block the signaller and release all acquired mutex types in the parameter list, \ie @wait( e, m1, m2 )@.
+To override the implicit multi-monitor wait, specific mutex parameter(s) can be specified, \eg @wait( e, m1 )@.
+Wait statically verifies the released monitors are the acquired mutex-parameters so unconditional release is safe.
+Finally, a signaller,
+\begin{cfa}
+void baz( M & mutex m1, M & mutex m2 ) {
+        ... signal( e ); ...
+}
+\end{cfa}
+must have acquired monitor locks that are greater than or equal to the number of locks for the waiting thread signalled from the front of the condition queue.
+In general, the signaller does not know the order of waiting threads, so in general, it must acquire the maximum number of mutex locks for the worst-case waiting thread.
+Similarly, for @waitfor( rtn )@, the default semantics is to atomically block the acceptor and release all acquired mutex types in the parameter list, \ie @waitfor( rtn, m1, m2 )@.
+To override the implicit multi-monitor wait, specific mutex parameter(s) can be specified, \eg @waitfor( rtn, m1 )@.
+Waitfor statically verifies the released monitors are the same as the acquired mutex-parameters of the given routine or routine pointer.
+To statically verify the released monitors match with the accepted routine's mutex parameters, the routine (pointer) prototype must be accessible.
+Given the ability to release a subset of acquired monitors can result in a \newterm{nested monitor}~\cite{Lister77} deadlock.
+\begin{cfa}
+void foo( M & mutex m1, M & mutex m2 ) {
+        ... wait( `e, m1` ); ...                                $\C{// release m1, keeping m2 acquired )}$
+void baz( M & mutex m1, M & mutex m2 ) {        $\C{// must acquire m1 and m2 )}$
+        ... signal( `e` ); ...
+\end{cfa}
+The @wait@ only releases @m1@ so the signalling thread cannot acquire both @m1@ and @m2@ to  enter @baz@ to get to the @signal@.
+While deadlock issues can occur with multiple/nesting acquisition, this issue results from the fact that locks, and by extension monitors, are not perfectly composable.
+Finally, an important aspect of monitor implementation is barging, \ie can calling threads barge ahead of signalled threads?
+If barging is allowed, synchronization between a singller and signallee is difficult, often requiring multiple unblock/block cycles (looping around a wait rechecking if a condition is met).
+\begin{quote}
+However, we decree that a signal operation be followed immediately by resumption of a waiting program, without possibility of an intervening procedure call from yet a third program.
+It is only in this way that a waiting program has an absolute guarantee that it can acquire the resource just released by the signalling program without any danger that a third program will interpose a monitor entry and seize the resource instead.~\cite[p.~550]{Hoare74}
+\end{quote}
+\CFA scheduling \emph{precludes} barging, which simplifies synchronization among threads in the monitor and increases correctness.
+For example, there are no loops in either bounded buffer solution in Figure~\ref{f:GenericBoundedBuffer}.
+Supporting barging prevention as well as extending internal scheduling to multiple monitors is the main source of complexity in the design and implementation of \CFA concurrency.
+\subsection{Barging Prevention}
+Figure~\ref{f:BargingPrevention} shows \CFA code where bulk acquire adds complexity to the internal-signalling semantics.
+The complexity begins at the end of the inner @mutex@ statement, where the semantics of internal scheduling need to be extended for multiple monitors.
+The problem is that bulk acquire is used in the inner @mutex@ statement where one of the monitors is already acquired.
+When the signalling thread reaches the end of the inner @mutex@ statement, it should transfer ownership of @m1@ and @m2@ to the waiting threads to prevent barging into the outer @mutex@ statement by another thread.
+However, both the signalling and waiting thread W1 still need monitor @m1@.
+\begin{figure}
+\newbox\myboxA
+\begin{lrbox}{\myboxA}
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+monitor M m1, m2;
+condition c;
+mutex( m1 ) { // $\LstCommentStyle{\color{red}outer}$
+        ...
+        mutex( m1, m2 ) { // $\LstCommentStyle{\color{red}inner}$
+                ... `signal( c )`; ...
+                // m1, m2 acquired
+        } // $\LstCommentStyle{\color{red}release m2}$
+        // m1 acquired
+} // release m1
+\end{cfa}
+\end{lrbox}
+\newbox\myboxB
+\begin{lrbox}{\myboxB}
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+mutex( m1 ) {
+        ...
+        mutex( m1, m2 ) {
+                ... `wait( c )`; // block and release m1, m2
+                // m1, m2 acquired
+        } // $\LstCommentStyle{\color{red}release m2}$
+        // m1 acquired
+} // release m1
+\end{cfa}
+\end{lrbox}
+\newbox\myboxC
+\begin{lrbox}{\myboxC}
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+mutex( m2 ) {
+        ... `wait( c )`; ...
+        // m2 acquired
+} // $\LstCommentStyle{\color{red}release m2}$
+\end{cfa}
+\end{lrbox}
+\begin{cquote}
+\subfloat[Signalling Thread]{\label{f:SignallingThread}\usebox\myboxA}
+\hspace{2\parindentlnth}
+\subfloat[Waiting Thread (W1)]{\label{f:WaitingThread}\usebox\myboxB}
+\hspace{2\parindentlnth}
+\subfloat[Waiting Thread (W2)]{\label{f:OtherWaitingThread}\usebox\myboxC}
+\end{cquote}
+\caption{Barging Prevention}
+\label{f:BargingPrevention}
+\end{figure}
+One scheduling solution is for the signaller to keep ownership of all locks until the last lock is ready to be transferred, because this semantics fits most closely to the behaviour of single-monitor scheduling.
+However, Figure~\ref{f:OtherWaitingThread} shows this solution is complex depending on other waiters, resulting is choices when the signaller finishes the inner mutex-statement.
+The singaller can retain @m2@ until completion of the outer mutex statement and pass the locks to waiter W1, or it can pass @m2@ to waiter W2 after completing the inner mutex-statement, while continuing to hold @m1@.
+In the latter case, waiter W2 must eventually pass @m2@ to waiter W1, which is complex because W2 may have waited before W1 so it is unaware of W1.
+Furthermore, there is an execution sequence where the signaller always finds waiter W2, and hence, waiter W1 starves.
+While a number of approaches were examined~\cite[\S~4.3]{Delisle18}, the solution chosen for \CFA is a novel techique called \newterm{partial signalling}.
+Signalled threads are moved to an urgent queue and the waiter at the front defines the set of monitors necessary for it to unblock.
+Partial signalling transfers ownership of monitors to the front waiter.
+When the signaller thread exits or waits in the monitor the front waiter is unblocked if all its monitors are released.
+This solution has the benefit that complexity is encapsulated into only two actions: passing monitors to the next owner when they should be released and conditionally waking threads if all conditions are met.
+\begin{comment}
+The complexity begins at code sections 4 and 8 in listing \ref{f:int-bulk-cfa}, which are where the existing semantics of internal scheduling needs to be extended for multiple monitors.
+The root of the problem is that bulk acquire is used in a context where one of the monitors is already acquired, which is why it is important to define the behaviour of the previous cfa-code.
+When the signaller thread reaches the location where it should ``release @A & B@'' (listing \ref{f:int-bulk-cfa} line \ref{line:releaseFirst}), it must actually transfer ownership of monitor @B@ to the waiting thread.
+This ownership transfer is required in order to prevent barging into @B@ by another thread, since both the signalling and signalled threads still need monitor @A@.
+There are three options:
+\subsubsection{Delaying Signals}
+The obvious solution to the problem of multi-monitor scheduling is to keep ownership of all locks until the last lock is ready to be transferred.
+It can be argued that that moment is when the last lock is no longer needed, because this semantics fits most closely to the behaviour of single-monitor scheduling.
+This solution has the main benefit of transferring ownership of groups of monitors, which simplifies the semantics from multiple objects to a single group of objects, effectively making the existing single-monitor semantic viable by simply changing monitors to monitor groups.
+This solution releases the monitors once every monitor in a group can be released.
+However, since some monitors are never released (\eg the monitor of a thread), this interpretation means a group might never be released.
+A more interesting interpretation is to transfer the group until all its monitors are released, which means the group is not passed further and a thread can retain its locks.
+However, listing \ref{f:int-secret} shows this solution can become much more complicated depending on what is executed while secretly holding B at line \ref{line:secret}, while avoiding the need to transfer ownership of a subset of the condition monitors.
 Figure~\ref{f:dependency} shows a slightly different example where a third thread is waiting on monitor @A@, using a different condition variable.
 Because the third thread is signalled when secretly holding @B@, the goal  becomes unreachable.
 …
 In both cases, the threads need to be able to distinguish, on a per monitor basis, which ones need to be released and which ones need to be transferred, which means knowing when to release a group becomes complex and inefficient (see next section) and therefore effectively precludes this approach.
 \subsubsection{Dependency graphs}
 \begin{figure}
 …
 \subsubsection{Partial Signalling} \label{partial-sig}
+\end{comment}
+Finally, the solution that is chosen for \CFA is to use partial signalling.
+Again using listing \ref{f:int-bulk-cfa}, the partial signalling solution transfers ownership of monitor @B@ at lines \ref{line:signal1} to the waiter but does not wake the waiting thread since it is still using monitor @A@.
+Only when it reaches line \ref{line:lastRelease} does it actually wake up the waiting thread.
+This solution has the benefit that complexity is encapsulated into only two actions: passing monitors to the next owner when they should be released and conditionally waking threads if all conditions are met.
+This solution has a much simpler implementation than a dependency graph solving algorithms, which is why it was chosen.
+Furthermore, after being fully implemented, this solution does not appear to have any significant downsides.
+Using partial signalling, listing \ref{f:dependency} can be solved easily:
+\begin{itemize}
+        \item When thread $\gamma$ reaches line \ref{line:release-ab} it transfers monitor @B@ to thread $\alpha$ and continues to hold monitor @A@.
+        \item When thread $\gamma$ reaches line \ref{line:release-a}  it transfers monitor @A@ to thread $\beta$  and wakes it up.
+        \item When thread $\beta$  reaches line \ref{line:release-aa} it transfers monitor @A@ to thread $\alpha$ and wakes it up.
+\end{itemize}
+% ======================================================================
+% ======================================================================
+\subsection{Signalling: Now or Later}
+% ======================================================================
+% ======================================================================
+\begin{table}
+\begin{tabular}{|c|c|}
+@signal@ & @signal_block@ \\
+\hline
+\begin{cfa}[tabsize=3]
+monitor DatingService {
+        // compatibility codes
+        enum{ CCodes = 20 };
+        int girlPhoneNo
+        int boyPhoneNo;
+};
+condition girls[CCodes];
+condition boys [CCodes];
+condition exchange;
+int girl(int phoneNo, int cfa) {
+        // no compatible boy ?
+        if(empty(boys[cfa])) {
+                wait(girls[cfa]);               // wait for boy
+                girlPhoneNo = phoneNo;          // make phone number available
+                signal(exchange);               // wake boy from chair
+        } else {
+                girlPhoneNo = phoneNo;          // make phone number available
+                signal(boys[cfa]);              // wake boy
+                wait(exchange);         // sit in chair
+        }
+        return boyPhoneNo;
+}
+int boy(int phoneNo, int cfa) {
+        // same as above
+        // with boy/girl interchanged
+}
+\end{cfa}&\begin{cfa}[tabsize=3]
+monitor DatingService {
+        enum{ CCodes = 20 };    // compatibility codes
+        int girlPhoneNo;
+        int boyPhoneNo;
+};
+condition girls[CCodes];
+condition boys [CCodes];
+// exchange is not needed
+int girl(int phoneNo, int cfa) {
+        // no compatible boy ?
+        if(empty(boys[cfa])) {
+                wait(girls[cfa]);               // wait for boy
+                girlPhoneNo = phoneNo;          // make phone number available
+                signal(exchange);               // wake boy from chair
+        } else {
+                girlPhoneNo = phoneNo;          // make phone number available
+                signal_block(boys[cfa]);                // wake boy
+                // second handshake unnecessary
+        }
+        return boyPhoneNo;
+}
+int boy(int phoneNo, int cfa) {
+        // same as above
+        // with boy/girl interchanged
+}
+\end{cfa}
+\end{tabular}
+\caption{Dating service example using \protect\lstinline|signal| and \protect\lstinline|signal_block|. }
+\label{tbl:datingservice}
+\end{table}
+An important note is that, until now, signalling a monitor was a delayed operation.
+The ownership of the monitor is transferred only when the monitor would have otherwise been released, not at the point of the @signal@ statement.
+However, in some cases, it may be more convenient for users to immediately transfer ownership to the thread that is waiting for cooperation, which is achieved using the @signal_block@ routine.
+The example in table \ref{tbl:datingservice} highlights the difference in behaviour.
+As mentioned, @signal@ only transfers ownership once the current critical section exits; this behaviour requires additional synchronization when a two-way handshake is needed.
+To avoid this explicit synchronization, the @condition@ type offers the @signal_block@ routine, which handles the two-way handshake as shown in the example.
+This feature removes the need for a second condition variables and simplifies programming.
+Like every other monitor semantic, @signal_block@ uses barging prevention, which means mutual-exclusion is baton-passed both on the front end and the back end of the call to @signal_block@, meaning no other thread can acquire the monitor either before or after the call.
+% ======================================================================
+% ======================================================================
 \section{External scheduling} \label{extsched}
+% ======================================================================
+% ======================================================================
 An alternative to internal scheduling is external scheduling (see Table~\ref{tbl:sched}).
-\begin{comment}
 \begin{table}
 \begin{tabular}{|c|c|c|}
 …
 \label{tbl:sched}
 \end{table}
-\end{comment}
 This method is more constrained and explicit, which helps users reduce the non-deterministic nature of concurrency.
 Indeed, as the following examples demonstrate, external scheduling allows users to wait for events from other threads without the concern of unrelated events occurring.

doc/proposals/user_conversions.md

-              r61accc5
+              rc2b10fa
 There is also a set of _explicit_ conversions that are only allowed through a
 cast expression.
+I propose that safe, unsafe, and explicit (cast) conversions be expressed as
+constructor variants.
+Based on Glen's notes on conversions [1], I propose that safe and unsafe
+conversions be expressed as constructor variants, though I make explicit
+(cast) conversions a constructor variant as well rather than a dedicated
+operator.
 Throughout this article, I will use the following operator names for
 constructors and conversion functions from `From` to `To`:
+        void ?{} ( To&, To );            // copy constructor
+        void ?{} ( To&, From );          // explicit constructor
+        void ?{explicit} ( To&, From );  // explicit cast conversion
+        void ?{safe} ( To&, From );      // implicit safe conversion
+        void ?{unsafe} ( To&, From );    // implicit unsafe conversion
+It has been suggested that all constructors would define unsafe implicit
+        void ?{} ( To*, To );            // copy constructor
+        void ?{} ( To*, From );          // explicit constructor
+        void ?{explicit} ( To*, From );  // explicit cast conversion
+        void ?{safe} ( To*, From );      // implicit safe conversion
+        void ?{unsafe} ( To*, From );    // implicit unsafe conversion
+[1] http://plg.uwaterloo.ca/~cforall/Conversions/index.html
+Glen's design made no distinction between constructors and unsafe implicit
 conversions; this is elegant, but interacts poorly with tuples.
 Essentially, without making this distinction, a constructor like the following
 …
 multiplying the space of possible interpretations of all functions:
         void ?{}( Coord& this, int x, int y );
+        void ?{}( Coord *this, int x, int y );
 That said, it would certainly be possible to make a multiple-argument implicit
 …
 used infrequently:
         void ?{unsafe}( Coord& this, int x, int y );
+        void ?{unsafe}( Coord *this, int x, int y );
 An alternate possibility would be to only count two-arg constructors
 `void ?{} ( To&, From )` as unsafe conversions; under this semantics, safe and
+`void ?{} ( To*, From )` as unsafe conversions; under this semantics, safe and
 explicit conversions should also have a compiler-enforced restriction to
 ensure that they are two-arg functions (this restriction may be valuable
 …
 is convertable to `To`.
 If user-defined conversions are not added to the language,
 `void ?{} ( To&, From )` may be a suitable representation, relying on
+`void ?{} ( To*, From )` may be a suitable representation, relying on
 conversions on the argument types to account for transitivity.
+Since `To&` should be an exact match on `To`, this should put all the implicit
+conversions on the RHS.
+On the other hand, under some models (like [1]), implicit conversions are not
+allowed in assertion parameters, so another assertion syntax specific to
+conversions may be required, e.g. `From -> To`.
+It has also been suggested that, for programmer control, no implicit
+conversions (except, possibly, for polymorphic specialization) should be
+allowed in resolution of cast operators.
+[1] ../working/assertion_resolution.md
+On the other hand, `To*` should perhaps match its target type exactly, so
+another assertion syntax specific to conversions may be required, e.g.
+`From -> To`.
 ### Constructor Idiom ###
 …
 that we can use the full range of Cforall features for conversions, including
 polymorphism.
+In an earlier version of this proposal, Glen Ditchfield defines a
+_constructor idiom_ that can be used to create chains of safe conversions
+without duplicating code; given a type `Safe` which members of another type
+`From` can be directly converted to, the constructor idiom allows us to write
+a conversion for any type `To` which `Safe` converts to:
+        forall(otype To | { void ?{safe}( To&, Safe ) })
+        void ?{safe}( To& this, From that ) {
+Glen [1] defines a _constructor idiom_ that can be used to create chains of
+safe conversions without duplicating code; given a type `Safe` which members
+of another type `From` can be directly converted to, the constructor idiom
+allows us to write a conversion for any type `To` which `Safe` converts to:
+        forall(otype To | { void ?{safe}( To*, Safe ) })
+        void ?{safe}( To *this, From that ) {
                 Safe tmp = /* some expression involving that */;
                 this{ tmp }; // initialize from assertion parameter
+                *this = tmp; // uses assertion parameter
+        }
 …
 unsafe conversions.
-Glen's original suggestion said the copy constructor for `To` should also be
-accepted as a resolution for `void ?{safe}( To&, Safe )` (`Safe` == `To`),
-allowing this same code to be used for the single-step conversion as well.
-This proposal does come at the cost of an extra copy initialization of the
-target value, though.
-Contrariwise, if a monomorphic conversion from `From` to `Safe` is written,
-e.g:
-        void ?{safe}( Safe& this, From that ) {
-                this{ /* some parameters involving that */ };
+        }
-Then the code for a transitive conversion from `From` to any `To` type
-convertable from `Safe` is written:
-        forall(otype To | { void ?{safe}( To&, Safe ) })
-        void ?{safe}( To& this, From that ) {
-                Safe tmp = that;  // uses monomorphic conversion
-                this{ tmp };      // initialize from assertion parameter
+        }
-Given the entirely-boilerplate nature of this code, but negative performance
-implications of the unmodified constructor idiom, it might be fruitful to have
-transitive and single step conversion operators, and let CFA build the
-transitive conversions; some possible names:
-        void ?{safe}  (To&, From);    void ?{final safe} (To&, From);  // single-step
-        void ?{safe*} (To&, From);    void ?{safe}       (To&, From);  // transitive
 What selective non-use of the constructor idiom gives us is the ability to
 define a conversion that may only be the *last* conversion in a chain of such.
+One use for this is to solve the problem that `explicit` conversions were
+added to C++ for, that of conversions to `bool` chaining to become conversions
+to any arithmetic type.
+Another use is to unambiguously represent the full hierarchy of implicit
+conversions in C by making sign conversions non-transitive, allowing the
+compiler to resolve e.g. `int -> unsigned long` as
+`int -> long -> unsigned long` over `int -> unsigned int -> unsigned long`.
+See [2] for more details.
+[2] ../working/glen_conversions/index.html#usual
+Constructing a conversion graph able to unambiguously represent the full
+hierarchy of implicit conversions in C is provably impossible using only
+single-step conversions with no additional information (see Appendix A), but
+this mechanism is sufficiently powerful (see [1], though the design there has
+some minor bugs; the general idea is to use the constructor idiom to define
+two chains of conversions, one among the signed integral types, another among
+the unsigned, and to use monomorphic conversions to allow conversions between
+signed and unsigned integer types).
 ### Appendix A: Partial and Total Orders ###
 …
 convert from `int` to `unsigned long`, so we just put in a direct conversion
 and make the compiler smart enough to figure out the costs" - this is the
 approach taken by the existing compiler, but given that in a user-defined
+approach taken by the existing compipler, but given that in a user-defined
 conversion proposal the users can build an arbitrary graph of conversions,
 this case still needs to be handled.
 …
 exists a chain of conversions from `a` to `b` (see Appendix A for description
 of preorders and related constructs).
 This preorder roughly corresponds to a more usual type-theoretic concept of
+This preorder corresponds roughly to a more usual type-theoretic concept of
 subtyping ("if I can convert `a` to `b`, `a` is a more specific type than
 `b`"); however, since this graph is arbitrary, it may contain cycles, so if
 …
 and so is considered to be the nearer type.
 By transitivity, then, the conversion from `X` to `Y2` should be cheaper than
 the conversion from `X` to `W`, but in this case the `Y2` and `W` are
+the conversion from `X` to `W`, but in this case the `X` and `W` are
 incomparable by the conversion preorder, so the tie is broken by the shorter
 path from `X` to `W` in favour of `W`, contradicting the transitivity property

src/Common/SemanticError.cc

-              r61accc5
+              rc2b10fa
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jun  7 08:05:26 2018
 // Update Count     : 10
+// Last Modified On : Wed May 16 15:01:20 2018
+// Update Count     : 9
 //
 …
 void SemanticError( CodeLocation location, std::string error ) {
         SemanticErrorThrow = true;
         throw SemanticErrorException( location, error );
+        throw SemanticErrorException(location, error);
+}

src/Parser/DeclarationNode.cc

-              r61accc5
+              rc2b10fa
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jun  7 12:08:55 2018
 // Update Count     : 1079
+// Last Modified On : Wed Jun  6 15:57:50 2018
+// Update Count     : 1076
 //
 …
                                         type->aggregate.params->appendList( q->type->forall ); // augment forall qualifier
                                 } else {                                                                // not polymorphic
+                                        type->aggregate.params = q->type->forall; // set forall qualifier
+                                        type->aggregate.params = q->type->forall; // make polymorphic type
+                                        // change implicit typedef from TYPEDEFname to TYPEGENname
+                                        typedefTable.changeKind( *type->aggregate.name, TYPEGENname );
                                 } // if
                         } else {                                                                        // not polymorphic

src/Parser/TypedefTable.cc

-              r61accc5
+              rc2b10fa
 // Created On       : Sat May 16 15:20:13 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jun  7 13:17:56 2018
 // Update Count     : 192
+// Last Modified On : Fri Jun  1 16:54:18 2018
+// Update Count     : 155
 //
 …
 #include "TypedefTable.h"
 #include <cassert>                                                                              // for assert
-#include <iostream>
 #if 0
+#include <iostream>
 #define debugPrint( code ) code
 #else
 …
 using namespace std;                                                                    // string, iostream
-debugPrint(
-static const char *kindName( int kind ) {
-        switch ( kind ) {
-          case IDENTIFIER: return "identifier";
-          case TYPEDEFname: return "typedef";
-          case TYPEGENname: return "typegen";
-          default:
-                cerr << "Error: cfa-cpp internal error, invalid kind of identifier" << endl;
-                abort();
-        } // switch
-} // kindName
+)
 TypedefTable::~TypedefTable() {
         if ( ! SemanticErrorThrow && kindTable.currentScope() != 0 ) {
+                cerr << "Error: cfa-cpp internal error, scope failure " << kindTable.currentScope() << endl;
+                abort();
+                std::cerr << "scope failure " << kindTable.currentScope() << endl;
         } // if
 } // TypedefTable::~TypedefTable
 …
 } // TypedefTable::isKind
+void TypedefTable::changeKind( const string & identifier, int kind ) {
+        KindTable::iterator posn = kindTable.find( identifier );
+        if ( posn != kindTable.end() ) posn->second = kind;     // exists => update
+} // TypedefTable::changeKind
 // SKULLDUGGERY: Generate a typedef for the aggregate name so the aggregate does not have to be qualified by
 // "struct". Only generate the typedef, if the name is not in use. The typedef is implicitly (silently) removed if the
 // name is explicitly used.
+void TypedefTable::makeTypedef( const string & name, int kind ) {
+//    Check for existence is necessary to handle:
+//        struct Fred {};
+//        void Fred();
+//        void fred() {
+//           struct Fred act; // do not add as type in this scope
+//           Fred();
+//        }
+void TypedefTable::makeTypedef( const string & name ) {
         if ( ! typedefTable.exists( name ) ) {
                 typedefTable.addToEnclosingScope( name, kind, "MTD" );
+                typedefTable.addToEnclosingScope( name, TYPEDEFname, "MTD" );
         } // if
 } // TypedefTable::makeTypedef
 void TypedefTable::addToScope( const string & identifier, int kind, const char * locn __attribute__((unused)) ) {
+void TypedefTable::addToScope( const std::string & identifier, int kind, const char * locn __attribute__((unused)) ) {
         auto scope = kindTable.currentScope();
         debugPrint( cerr << "Adding current at " << locn << " " << identifier << " as " << kindName( kind ) << " scope " << scope << endl );
+        debugPrint( cerr << "Adding at " << locn << " " << identifier << " as kind " << kind << " scope " << scope << endl );
         auto ret = kindTable.insertAt( scope, identifier, kind );
         if ( ! ret.second ) ret.first->second = kind;           // exists => update
 } // TypedefTable::addToScope
 void TypedefTable::addToEnclosingScope( const string & identifier, int kind, const char * locn __attribute__((unused)) ) {
+void TypedefTable::addToEnclosingScope( const std::string & identifier, int kind, const char * locn __attribute__((unused)) ) {
         assert( kindTable.currentScope() >= 1 );
         auto scope = kindTable.currentScope() - 1;
         debugPrint( cerr << "Adding enclosing at " << locn << " " << identifier << " as " << kindName( kind ) << " scope " << scope << endl );
+        debugPrint( cerr << "Adding+1 at " << locn << " " << identifier << " as kind " << kind << " scope " << scope << endl );
         auto ret = kindTable.insertAt( scope, identifier, kind );
         if ( ! ret.second ) ret.first->second = kind;           // exists => update
 …
                         debugPrint( cerr << endl << "[" << scope << "]" );
                 } // while
                 debugPrint( cerr << " " << (*i).first << ":" << kindName( (*i).second ) );
+                debugPrint( cerr << " " << (*i).first << ":" << (*i).second );
         } // for
         while ( scope > 0 ) {

src/Parser/TypedefTable.h

-              r61accc5
+              rc2b10fa
 // Created On       : Sat May 16 15:24:36 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jun  7 12:10:17 2018
 // Update Count     : 85
+// Last Modified On : Thu May 31 23:23:47 2018
+// Update Count     : 83
 //
 …
         bool exists( const std::string & identifier );
         int isKind( const std::string & identifier ) const;
+        void makeTypedef( const std::string & name, int kind = TYPEDEFname );
+        void changeKind( const std::string & identifier, int kind );
+        void makeTypedef( const std::string & name );
         void addToScope( const std::string & identifier, int kind, const char * );
         void addToEnclosingScope( const std::string & identifier, int kind, const char * );

src/Parser/lex.ll

-              r61accc5
+              rc2b10fa
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
  * Last Modified On : Thu Jun  7 08:27:40 2018
  * Update Count     : 679
+ * Last Modified On : Wed Jun  6 17:31:09 2018
+ * Update Count     : 677
  */
 …
 %%
 // ----end of lexer----
 void yyerror( const char * errmsg ) {
-        SemanticErrorThrow = true;
         cout << (yyfilename ? yyfilename : "*unknown file*") << ':' << yylineno << ':' << column - yyleng + 1
                  << ": " << ErrorHelpers::error_str() << errmsg << " at token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << '"' << endl;

src/Parser/parser.yy

-              r61accc5
+              rc2b10fa
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jun  7 10:07:12 2018
 // Update Count     : 3527
+// Last Modified On : Wed Jun  6 14:53:38 2018
+// Update Count     : 3522
 //
 …
         | aggregate_key attribute_list_opt no_attr_identifier
+                {
                         typedefTable.makeTypedef( *$3, forall ? TYPEGENname : TYPEDEFname ); // create typedef
                         //if ( forall ) typedefTable.changeKind( *$3, TYPEGENname ); // possibly update
+                        typedefTable.makeTypedef( *$3 );                        // create typedef
+                        if ( forall ) typedefTable.changeKind( *$3, TYPEGENname ); // possibly update
                         forall = false;                                                         // reset
+                }
 …
         | aggregate_key attribute_list_opt type_name
+                {
                         typedefTable.makeTypedef( *$3->type->symbolic.name, forall ? TYPEGENname : TYPEDEFname ); // create typedef
                         //if ( forall ) typedefTable.changeKind( *$3->type->symbolic.name, TYPEGENname ); // possibly update
+                        typedefTable.makeTypedef( *$3->type->symbolic.name ); // create typedef
+                        if ( forall ) typedefTable.changeKind( *$3->type->symbolic.name, TYPEGENname ); // possibly update
                         forall = false;                                                         // reset
+                }
 …
         aggregate_key attribute_list_opt no_attr_identifier
+                {
                         typedefTable.makeTypedef( *$3, forall ? TYPEGENname : TYPEDEFname );
                         //if ( forall ) typedefTable.changeKind( *$3, TYPEGENname ); // possibly update
+                        typedefTable.makeTypedef( *$3 );
+                        if ( forall ) typedefTable.changeKind( *$3, TYPEGENname ); // possibly update
                         forall = false;                                                         // reset
                         $$ = DeclarationNode::newAggregate( $1, $3, nullptr, nullptr, false )->addQualifiers( $2 );
 …
 %%
 // ----end of grammar----

src/libcfa/bits/locks.h

-              r61accc5
+              rc2b10fa
         struct __bin_sem_t {
                 bool                    signaled;
                 pthread_mutex_t         lock;
                 pthread_cond_t          cond;
+                int_fast8_t     counter;
+                pthread_mutex_t lock;
+                pthread_cond_t  cond;
         };
         static inline void ?{}(__bin_sem_t & this) with( this ) {
                 signaled = false;
+                counter = 0;
                 pthread_mutex_init(&lock, NULL);
                 pthread_cond_init (&cond, NULL);
 …
                 verify(__cfaabi_dbg_in_kernel());
                 pthread_mutex_lock(&lock);
                         if(!signaled) {   // this must be a loop, not if!
                                 pthread_cond_wait(&cond, &lock);
+                        }
                         signaled = false;
+                if(counter != 0) {   // this must be a loop, not if!
+                        pthread_cond_wait(&cond, &lock);
+                }
+                counter = 1;
                 pthread_mutex_unlock(&lock);
+        }
 …
         static inline void post(__bin_sem_t & this) with( this ) {
                 verify(__cfaabi_dbg_in_kernel());
                 pthread_mutex_lock(&lock);
                         bool needs_signal = !signaled;
                         signaled = true;
+                bool needs_signal = counter == 0;
+                counter = 1;
                 pthread_mutex_unlock(&lock);
+                if (needs_signal)
+                if (!needs_signal)
                         pthread_cond_signal(&cond);
+        }
+                }
 #endif

src/libcfa/concurrency/kernel

-              r61accc5
+              rc2b10fa
         pthread_t kernel_thread;
+        // Termination
+        // Set to true to notify the processor should terminate
+        volatile bool do_terminate;
+        // Termination synchronisation
+        semaphore terminated;
         // RunThread data
         // Action to do after a thread is ran
 …
         // Idle lock
+        __bin_sem_t idleLock;
+        // Termination
+        // Set to true to notify the processor should terminate
+        volatile bool do_terminate;
+        // Termination synchronisation
+        semaphore terminated;
+        sem_t idleLock;
+        // __bin_sem_t idleLock;
         // Link lists fields

src/libcfa/concurrency/kernel.c

-              r61accc5
+              rc2b10fa
         runner.proc = &this;
         idleLock{};
+        sem_init(&idleLock, 0, 0);
         start( &this );
 …
         if( ! __atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) ) {
                 __cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
+                __atomic_store_n(&do_terminate, true, __ATOMIC_RELAXED);
+                wake( &this );
+                terminate(&this);
+                verify( __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
+                verify( kernelTLS.this_processor != &this);
                 P( terminated );
                 verify( kernelTLS.this_processor != &this);
+        }
+        pthread_join( kernel_thread, NULL );
+                pthread_join( kernel_thread, NULL );
+        }
+        sem_destroy(&idleLock);
+}
 …
+}
+// Handles spinning logic
+// TODO : find some strategy to put cores to sleep after some time
+void spin(processor * this, unsigned int * spin_count) {
+        // (*spin_count)++;
+        halt(this);
+}
 // KERNEL_ONLY
 // Context invoker for processors
 …
                 unlock( ready_queue_lock );
                 if(was_empty) {
+                if( was_empty ) {
                         lock      (proc_list_lock __cfaabi_dbg_ctx2);
                         if(idles) {
                                 wake_fast(idles.head);
+                                wake(idles.head);
+                        }
                         unlock    (proc_list_lock);
+                }
-                else if( struct processor * idle = idles.head ) {
-                        wake_fast(idle);
+                }
+        }
 …
 void halt(processor * this) with( *this ) {
         // verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
+        verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
         with( *cltr ) {
 …
         __cfaabi_dbg_print_safe("Kernel : Processor %p ready to sleep\n", this);
+        wait( idleLock );
+        // #ifdef __CFA_WITH_VERIFY__
+        //      int sval = 0;
+        //      sem_getvalue(&this->idleLock, &sval);
+        //      verifyf(sval < 200, "Binary semaphore reached value %d : \n", sval);
+        // #endif
+        verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
+        int __attribute__((unused)) ret = sem_wait(&idleLock);
+        // verifyf(ret >= 0 || errno == EINTR, "Sem_wait returned %d (errno %d : %s\n", ret, errno, strerror(errno));
+        // wait( idleLock );
         __cfaabi_dbg_print_safe("Kernel : Processor %p woke up and ready to run\n", this);
 …
                 unlock    (proc_list_lock);
+        }
+}
+void wake(processor * this) {
+        __cfaabi_dbg_print_safe("Kernel : Waking up processor %p\n", this);
+        int __attribute__((unused)) ret = sem_post(&this->idleLock);
+        // verifyf(ret >= 0 || errno == EINTR, "Sem_post returned %d (errno %d : %s\n", ret, errno, strerror(errno));
+        // #ifdef __CFA_WITH_VERIFY__
+        //      int sval = 0;
+        //      sem_getvalue(&this->idleLock, &sval);
+        //      verifyf(sval < 200, "Binary semaphore reached value %d\n", sval);
+        // #endif
+        // post( this->idleLock );
+}

src/libcfa/concurrency/kernel_private.h

-              r61accc5
+              rc2b10fa
 void finishRunning(processor * this);
 void halt(processor * this);
+static inline void wake_fast(processor * this) {
+        __cfaabi_dbg_print_safe("Kernel : Waking up processor %p\n", this);
+        post( this->idleLock );
+}
+static inline void wake(processor * this) {
+        disable_interrupts();
+        wake_fast(this);
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+void wake(processor * this);
+void terminate(processor * this);
+void spin(processor * this, unsigned int * spin_count);
 struct event_kernel_t {
 …
 extern event_kernel_t * event_kernel;
+//extern thread_local coroutine_desc * volatile this_coroutine;
+//extern thread_local thread_desc *    volatile this_thread;
+//extern thread_local processor *      volatile this_processor;
+// extern volatile thread_local bool preemption_in_progress;
+// extern volatile thread_local bool preemption_enabled;
+// extern volatile thread_local unsigned short disable_preempt_count;
 struct __cfa_kernel_preemption_state_t {

src/libcfa/concurrency/preemption.c

-              r61accc5
+              rc2b10fa
 static void preempt( processor * this ) {
         sigval_t value = { PREEMPT_NORMAL };
+        pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
+}
+// kill wrapper : signal a processor
+void terminate(processor * this) {
+        disable_interrupts();
+        __atomic_store_n(&this->do_terminate, true, __ATOMIC_SEQ_CST);
+        wake( this );
+        sigval_t value = { PREEMPT_TERMINATE };
+        enable_interrupts( __cfaabi_dbg_ctx );
         pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
+}

src/tests/preempt_longrun/Makefile.am

r61accc5	rc2b10fa
34	34
35	35	clean-local:
36		rm -f ${TESTS} ~~core* out.log~~
	36	rm -f ${TESTS}
37	37
38	38	% : %.c ${CC}

src/tests/preempt_longrun/Makefile.in

r61accc5	rc2b10fa
878	878
879	879	clean-local:
880		rm -f ${TESTS} ~~core* out.log~~
	880	rm -f ${TESTS}
881	881
882	882	% : %.c ${CC}

src/tests/preempt_longrun/enter.c

-              r61accc5
+              rc2b10fa
 monitor mon_t {};
+mon_t mon;
 void foo( mon_t & mutex this ) {}
-mon_t mon;
 thread worker_t {};
 void main( worker_t & this ) {
         for( unsigned long i = 0; i < N; i++ ) {
 …
+}
+extern "C" {
+static worker_t * workers;
+}
 int main(int argc, char * argv[] ) {
         processor p;
+        {
                 worker_t w[7];
+                workers = w;
+        }
+}

src/tests/preempt_longrun/processor.c

-              r61accc5
+              rc2b10fa
+}
 static const unsigned long N = 50_000ul;
+static const unsigned long N = 5_000ul;
 int main(int argc, char* argv[]) {
         processor * p[15];
         write(STDOUT_FILENO, "Preparing\n", sizeof("Preparing\n"));
+        write(STDERR_FILENO, "Preparing\n", sizeof("Preparing\n"));
         for ( int pi = 0; pi < 15; pi++ ) {
                 p[pi] = new();
+        }
         write(STDOUT_FILENO, "Starting\n", sizeof("Starting\n"));
+        write(STDERR_FILENO, "Starting\n", sizeof("Starting\n"));
         for ( int i = 0; i < N; i++) {
                 int pi = i % 15;
 …
                 p[pi] = new();
+        }
         write(STDOUT_FILENO, "Stopping\n", sizeof("Stopping\n"));
+        write(STDERR_FILENO, "Stopping\n", sizeof("Stopping\n"));
         for ( int pi = 0; pi < 15; pi++ ) {
                 delete( p[pi] );
+        }
         write(STDOUT_FILENO, "Done\n", sizeof("Done\n"));
+        write(STDERR_FILENO, "Done\n", sizeof("Done\n"));
+}

Context Navigation

Changes in / [61accc5:c2b10fa]

Legend:

doc/papers/concurrency/Paper.tex

doc/proposals/user_conversions.md

src/Common/SemanticError.cc

src/Parser/DeclarationNode.cc

src/Parser/TypedefTable.cc

src/Parser/TypedefTable.h

src/Parser/lex.ll

src/Parser/parser.yy

src/libcfa/bits/locks.h

src/libcfa/concurrency/kernel

src/libcfa/concurrency/kernel.c

src/libcfa/concurrency/kernel_private.h

src/libcfa/concurrency/preemption.c

src/tests/preempt_longrun/Makefile.am

src/tests/preempt_longrun/Makefile.in

src/tests/preempt_longrun/enter.c

src/tests/preempt_longrun/processor.c

Download in other formats: