Changeset f6f0d06f for doc/papers/concurrency

Timestamp:

Jun 7, 2018, 11:12:28 AM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

b4e1876

Parents:

214e8da

Message:

Pass 1 up to 3.1

File:

• doc/papers/concurrency/Paper.tex (modified) (6 diffs)

doc/papers/concurrency/Paper.tex

@@ -217 +217 @@
 \lstMakeShortInline@%
 
+\newcommand{\commenttd}[1]{{\color{red}{Thierry : #1}}}
+
 \let\OLDthebibliography\thebibliography
 \renewcommand\thebibliography[1]{
@@ -308 +310 @@
 `&`r3 = &y; `&&`r3 = &`&`r4;             // change r1, r2: cancel implicit dereferences (&*)**r3, (&(&*)*)*r3, &(&*)r4
 \end{cfa}
-A reference is a handle to an object, like a pointer, but is automatically dereferenced the specified number of levels.
+A reference is a handle to an object, like a pointer, but is automatically dereferenced by the specified number of levels.
 Referencing (address-of @&@) a reference variable cancels one of the implicit dereferences, until there are no more implicit references, after which normal expression behaviour applies.
 
@@ -478 +480 @@
 
 The signature feature of \CFA is parametric-polymorphic routines~\cite{} with routines generalized using a @forall@ clause (giving the language its name), which allow separately compiled routines to support generic usage over multiple types.
-For example, the following sum routine works for any type that supports construction from 0 and addition:
+For example, the following sum routine works for any type that supports construction from 0 and addition \commenttd{constructors have not been introduced yet.}:
 \begin{cfa}
 forall( otype T | { void `?{}`( T *, zero_t ); T `?+?`( T, T ); } ) // constraint type, 0 and +
@@ -530 +532 @@
 {
         VLA  x,            y = { 20, 0x01 },     z = y; $\C{// z points to y}$
-        //    x{};         y{ 20, 0x01 };          z{ z, y }; 
+        //    x{};         y{ 20, 0x01 };          z{ z, y };
         ^x{};                                                                   $\C{// deallocate x}$
         x{};                                                                    $\C{// reallocate x}$
@@ -567 +569 @@
 The resulting execution system now follows a cooperative threading-model, called \newterm{non-preemptive scheduling}.
 
-Because the scheduler is special, it can either be a stackless or stackfull coroutine.
+Because the scheduler is special, it can either be a stackless or stackfull coroutine. \commenttd{I dislike this sentence, it seems imply 1-step vs 2-step but also seems to say that some kind of coroutine is required, which is not the case.}
 For stackless, the scheduler performs scheduling on the stack of the current coroutine and switches directly to the next coroutine, so there is one context switch.
 For stackfull, the current coroutine switches to the scheduler, which performs scheduling, and it then switches to the next coroutine, so there are two context switches.
-A stackfull scheduler is often used for simplicity and security, even through there is a slightly higher runtime-cost.
+A stackfull scheduler is often used for simplicity and security, even through there is a slightly higher runtime-cost. \commenttd{I'm not a fan of the fact that we don't quantify this but yet imply it is negligeable.}
 
 Regardless of the approach used, a subset of concurrency related challenges start to appear.
@@ -775 +777 @@
 };
 void main( Format & fmt ) with( fmt ) {
-        for ( ;; ) {    
+        for ( ;; ) {
                 for ( g = 0; g < 5; g += 1 ) {      // group
                         for ( b = 0; b < 4; b += 1 ) { // block