Changeset fb31cb8 for doc/proposals/concurrency/text/basics.tex

Timestamp:

Oct 17, 2017, 12:06:15 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

633c711

Parents:

0aaac0e

Message:

Updated thesis up to implementation

File:

• doc/proposals/concurrency/text/basics.tex (modified) (2 diffs)

doc/proposals/concurrency/text/basics.tex

@@ -328 +328 @@
 
 \begin{cfacode}
-        thread foo {};
+thread foo {};
 \end{cfacode}
 
@@ -343 +343 @@
 Obviously, for this thread implementation to be usefull it must run some user code. Several other threading interfaces use a function-pointer representation as the interface of threads (for example \Csharp~\cite{Csharp} and Scala~\cite{Scala}). However, this proposal considers that statically tying a \code{main} routine to a thread superseeds this approach. Since the \code{main} routine is already a special routine in \CFA (where the program begins), it is a natural extension of the semantics using overloading to declare mains for different threads (the normal main being the main of the initial thread). As such the \code{main} routine of a thread can be defined as
 \begin{cfacode}
-        thread foo {};
-
-        void main(foo & this) {
-                sout | "Hello World!" | endl;
-        }
+thread foo {};
+
+void main(foo & this) {
+        sout | "Hello World!" | endl;
+}
 \end{cfacode}
 
 In this example, threads of type \code{foo} start execution in the \code{void main(foo &)} routine, which prints \code{"Hello World!"}. While this thesis encourages this approach to enforce strongly-typed programming, users may prefer to use the routine-based thread semantics for the sake of simplicity. With these semantics it is trivial to write a thread type that takes a function pointer as a parameter and executes it on its stack asynchronously
 \begin{cfacode}
-        typedef void (*voidFunc)(int);
-
-        thread FuncRunner {
-                voidFunc func;
-                int arg;
-        };
-
-        void ?{}(FuncRunner & this, voidFunc inFunc, int arg) {
-                this.func = inFunc;
-        }
-
-        void main(FuncRunner & this) {
-                this.func( this.arg );
-        }
+typedef void (*voidFunc)(int);
+
+thread FuncRunner {
+        voidFunc func;
+        int arg;
+};
+
+void ?{}(FuncRunner & this, voidFunc inFunc, int arg) {
+        this.func = inFunc;
+}
+
+void main(FuncRunner & this) {
+        this.func( this.arg );
+}
 \end{cfacode}