Changeset 168c007

Timestamp:

Mar 21, 2017, 12:50:27 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

da6d4566, f5392c1

Parents:

94a8123 (diff), e04b636 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:/u/cforall/software/cfa/cfa-cc

Files:

• doc/proposals/concurrency/thePlan.md (modified) (1 diff)
• src/Concurrency/Keywords.cc (modified) (11 diffs)
• src/Parser/DeclarationNode.cc (modified) (2 diffs)
• src/Parser/ParseNode.h (modified) (2 diffs)
• src/Parser/TypeData.cc (modified) (5 diffs)
• src/Parser/lex.ll (modified) (1 diff)
• src/Parser/parser.yy (modified) (2 diffs)
• src/SynTree/Declaration.h (modified) (2 diffs)
• src/SynTree/Type.h (modified) (1 diff)
• src/benchmark/CorCtxSwitch.c (modified) (1 diff)
• src/benchmark/bench.c (modified) (4 diffs)
• src/benchmark/csv-data.c (modified) (1 diff)
• src/driver/Makefile.am (modified) (1 diff)
• src/driver/Makefile.in (modified) (1 diff)
• src/examples/multicore.c (modified) (1 diff)
• src/libcfa/concurrency/coroutine (modified) (1 diff)
• src/libcfa/concurrency/invoke.c (modified) (4 diffs)
• src/libcfa/concurrency/invoke.h (modified) (3 diffs)
• src/libcfa/concurrency/kernel.c (modified) (6 diffs)
• src/libcfa/concurrency/kernel_private.h (modified) (1 diff)
• src/libcfa/concurrency/monitor (modified) (2 diffs)
• src/libcfa/concurrency/monitor.c (modified) (2 diffs)
• src/libcfa/concurrency/thread (modified) (2 diffs)
• src/libcfa/concurrency/thread.c (modified) (4 diffs)
• src/main.cc (modified) (1 diff)
• src/tests/coroutine.c (modified) (3 diffs)
• src/tests/monitor.c (modified) (1 diff)
• src/tests/multi-monitor.c (modified) (1 diff)
• src/tests/thread.c (modified) (1 diff)

doc/proposals/concurrency/thePlan.md

@@ -8 +8 @@
 _Phase 2_ : Minimum Viable Product
 done - Monitor type and enter/leave mutex member routines
-Monitors as a language feature (not calling enter/leave by hand)
+done - Multi monitors calls,
+done - Monitors as a language feature (not calling enter/leave by hand)
 Internal scheduling
 
 _Phase 3_ : Kernel features
+Preemption
 Detach thread
 Cluster migration
-Preemption
 
 _Phase 4_ : Monitor features
-Multi monitors calls,
 External scheduling
 

src/Concurrency/Keywords.cc

@@ -17 +17 @@
 #include "Concurrency/Keywords.h"
 
+#include "SymTab/AddVisit.h"
 #include "SynTree/Declaration.h"
 #include "SynTree/Expression.h"
@@ -29 +30 @@
         namespace {
                 const std::list<Label> noLabels;
+                const std::list< Attribute * > noAttributes;
                 Type::StorageClasses noStorage;
                 Type::Qualifiers noQualifiers;
@@ -63 +65 @@
         //                                           void main( MyCoroutine * this );
         //
-        class CoroutineKeyword final : public Mutator {
+        class CoroutineKeyword final : public Visitor {
+            template< typename Visitor >
+            friend void SymTab::acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor );
           public:
 
-                static void implement( std::list< Declaration * > & translationUnit ) {}
+                using Visitor::visit;
+                virtual void visit( StructDecl * decl ) override final;
+
+                void handle( StructDecl * );
+                Declaration * addField( StructDecl * );
+                void addRoutines( StructDecl *, Declaration * );
+
+                static void implement( std::list< Declaration * > & translationUnit ) {
+                        CoroutineKeyword impl;
+                        SymTab::acceptAndAdd( translationUnit, impl );
+                }
+
+          private:
+                std::list< Declaration * > declsToAdd, declsToAddAfter;
+                StructDecl* coroutine_decl = nullptr;
         };
 
@@ -97 +115 @@
 
                 using Visitor::visit;
-                virtual void visit( FunctionDecl *functionDecl ) override final;
-                virtual void visit(   StructDecl *functionDecl ) override final;
+                virtual void visit( FunctionDecl * decl ) override final;
+                virtual void visit(   StructDecl * decl ) override final;
 
                 std::list<DeclarationWithType*> findMutexArgs( FunctionDecl* );
@@ -111 +129 @@
           private:
                 StructDecl* monitor_decl = nullptr;
+                StructDecl* guard_decl = nullptr;
         };
 
@@ -124 +143 @@
 
         //=============================================================================================
+        // Coroutine keyword implementation
+        //=============================================================================================
+        void CoroutineKeyword::visit(StructDecl * decl) {
+                if( decl->get_name() == "coroutine_desc" ) {
+                        assert( !coroutine_decl );
+                        coroutine_decl = decl;
+                }
+                else if ( decl->is_coroutine() ) {
+                        handle( decl );
+                }
+
+        }
+
+        void CoroutineKeyword::handle( StructDecl * decl ) {
+                if( ! decl->has_body() ) return;
+
+                if( !coroutine_decl ) throw SemanticError( "coroutine keyword requires coroutines to be in scope, add #include <coroutine>", decl );
+
+                Declaration * field = addField( decl );
+                addRoutines( decl, field );
+        }
+
+        Declaration * CoroutineKeyword::addField( StructDecl * decl ) {
+                Declaration * cor = new ObjectDecl(
+                        "__cor",
+                        noStorage,
+                        LinkageSpec::Cforall,
+                        nullptr,
+                        new StructInstType(
+                                noQualifiers,
+                                coroutine_decl
+                        ),
+                        nullptr
+                );
+
+                decl->get_members().push_back( cor );
+
+                return cor;
+        }
+
+        void CoroutineKeyword::addRoutines( StructDecl * decl, Declaration * field ) {
+                FunctionType * type = new FunctionType( noQualifiers, false );
+                type->get_parameters().push_back(
+                        new ObjectDecl(
+                                "this",
+                                noStorage,
+                                LinkageSpec::Cforall,
+                                nullptr,
+                                new PointerType(
+                                        noQualifiers,
+                                        new StructInstType(
+                                                noQualifiers,
+                                                decl
+                                        )
+                                ),
+                                nullptr
+                        )
+                );
+                type->get_returnVals().push_back(
+                        new ObjectDecl(
+                                "ret",
+                                noStorage,
+                                LinkageSpec::Cforall,
+                                nullptr,
+                                new PointerType(
+                                        noQualifiers,
+                                        new StructInstType(
+                                                noQualifiers,
+                                                coroutine_decl
+                                        )
+                                ),
+                                nullptr
+                        )
+                );
+
+                CompoundStmt * statement = new CompoundStmt( noLabels );
+                statement->push_back( 
+                        new ReturnStmt(
+                                noLabels,
+                                new AddressExpr(
+                                        new UntypedMemberExpr(
+                                                new NameExpr( "__cor" ),
+                                                new UntypedExpr(
+                                                        new NameExpr( "*?" ),
+                                                        { new NameExpr( "this" ) }
+                                                )
+                                        )
+                                )
+                        )
+                );
+
+                FunctionDecl * get_decl = new FunctionDecl(
+                        "get_coroutine",
+                        Type::Static,
+                        LinkageSpec::Cforall,
+                        type,
+                        statement,
+                        noAttributes,
+                        Type::Inline
+                );
+
+                declsToAddAfter.push_back( get_decl );
+
+                get_decl->fixUniqueId();
+        }
+        
+
+        //=============================================================================================
         // Mutex keyword implementation
         //=============================================================================================
@@ -137 +264 @@
                 if( ! body ) return;
 
-                assert(monitor_decl);
+                if( !monitor_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
+                if( !guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
+
                 addStatments( body, mutexArgs );
         }
@@ -146 +275 @@
                         monitor_decl = decl;
                 }
+                else if( decl->get_name() == "monitor_guard_t" ) {
+                        assert( !guard_decl );
+                        guard_decl = decl;
+                }
         }
 
@@ -175 +308 @@
 
                 //Make sure that typed isn't mutex
-                if( ! base->get_mutex() ) throw SemanticError( "mutex keyword may only appear once per argument ", arg );
+                if( base->get_mutex() ) throw SemanticError( "mutex keyword may only appear once per argument ", arg );
         }
 
         void MutexKeyword::addStatments( CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
-
                 ObjectDecl * monitors = new ObjectDecl(
                         "__monitors",
@@ -218 +350 @@
                                 new StructInstType(
                                         noQualifiers,
-                                        "monitor_guard_t"
+                                        guard_decl
                                 ),
                                 new ListInit(
@@ -224 +356 @@
                                                 new SingleInit( new VariableExpr( monitors ) ),
                                                 new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) )
-                                        }
+                                        },
+                                        noDesignators,
+                                        true
                                 )
                         ))
                 );
 
-                //monitor_desc * __monitors[] = { a, b };
+                //monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
                 body->push_front( new DeclStmt( noLabels, monitors) );
         }

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 17 08:46:05 2017
-// Update Count     : 1017
+// Last Modified On : Fri Mar 17 15:46:33 2017
+// Update Count     : 1018
 //
 
@@ -36 +36 @@
 const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" };
 const char * DeclarationNode::lengthNames[] = { "short", "long", "long long", "NoLengthNames" };
-const char * DeclarationNode::aggregateNames[] = { "struct", "union", "context", "NoAggregateNames" };
+const char * DeclarationNode::aggregateNames[] = { "struct", "union", "trait", "coroutine", "monitor", "thread", "NoAggregateNames" };
 const char * DeclarationNode::typeClassNames[] = { "otype", "dtype", "ftype", "NoTypeClassNames" };
 const char * DeclarationNode::builtinTypeNames[] = { "__builtin_va_list", "NoBuiltinTypeNames" };

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 16 08:32:43 2017
-// Update Count     : 776
+// Last Modified On : Fri Mar 17 15:42:18 2017
+// Update Count     : 777
 //
 
@@ -206 +206 @@
         enum Signedness { Signed, Unsigned, NoSignedness };
         enum Length { Short, Long, LongLong, NoLength };
-        enum Aggregate { Struct, Union, Trait, NoAggregate };
+        enum Aggregate { Struct, Union, Trait, Coroutine, Monitor, Thread, NoAggregate };
         enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass };
         enum BuiltinType { Valist, Zero, One, NoBuiltinType };

src/Parser/TypeData.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 17 08:46:10 2017
-// Update Count     : 560
+// Last Modified On : Fri Mar 17 15:52:43 2017
+// Update Count     : 563
 //
 
@@ -619 +619 @@
         switch ( td->aggregate.kind ) {
           case DeclarationNode::Struct:
-                at = new StructDecl( *td->aggregate.name, attributes );
+          case DeclarationNode::Coroutine:
+          case DeclarationNode::Monitor:
+          case DeclarationNode::Thread:
+                at = new StructDecl( *td->aggregate.name, td->aggregate.kind, attributes );
                 buildForall( td->aggregate.params, at->get_parameters() );
                 break;
@@ -656 +659 @@
                           switch ( type->aggregate.kind ) {
                                 case DeclarationNode::Struct:
+                                case DeclarationNode::Coroutine:
+                                case DeclarationNode::Monitor:
+                                case DeclarationNode::Thread:
                                   ret = new StructInstType( buildQualifiers( type ), (StructDecl *)typedecl );
                                   break;
@@ -671 +677 @@
                           switch ( type->aggregate.kind ) {
                                 case DeclarationNode::Struct:
+                                case DeclarationNode::Coroutine:
+                                case DeclarationNode::Monitor:
+                                case DeclarationNode::Thread:
                                   ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
                                   break;
@@ -703 +712 @@
                   switch ( type->aggregate.kind ) {
                         case DeclarationNode::Struct:
+                        case DeclarationNode::Coroutine:
+                        case DeclarationNode::Monitor:
+                        case DeclarationNode::Thread:
                           ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
                           break;

src/Parser/lex.ll

@@ -202 +202 @@
 __const__               { KEYWORD_RETURN(CONST); }                              // GCC
 continue                { KEYWORD_RETURN(CONTINUE); }
-_Coroutine              { KEYWORD_RETURN(COROUTINE); }                  // CFA
+coroutine               { KEYWORD_RETURN(COROUTINE); }                  // CFA
 default                 { KEYWORD_RETURN(DEFAULT); }
 disable                 { KEYWORD_RETURN(DISABLE); }                    // CFA

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 16 12:57:03 2017
-// Update Count     : 2316
+// Last Modified On : Fri Mar 17 15:42:22 2017
+// Update Count     : 2317
 //
 
@@ -1638 +1638 @@
                 { $$ = DeclarationNode::Union; }
         | COROUTINE
-                { $$ = DeclarationNode::Struct; }
+                { $$ = DeclarationNode::Coroutine; }
         | MONITOR
-                { $$ = DeclarationNode::Struct; }
+                { $$ = DeclarationNode::Monitor; }
         | THREAD
-                { $$ = DeclarationNode::Struct; }
+                { $$ = DeclarationNode::Thread; }
         ;
 

src/SynTree/Declaration.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 16 08:34:11 2017
-// Update Count     : 118
+// Last Modified On : Fri Mar 17 16:05:08 2017
+// Update Count     : 121
 //
 
@@ -255 +255 @@
         typedef AggregateDecl Parent;
   public:
-        StructDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >() ) : Parent( name, attributes ) {}
+        StructDecl( const std::string &name, DeclarationNode::Aggregate kind = DeclarationNode::Struct, const std::list< Attribute * > & attributes = std::list< class Attribute * >() ) : Parent( name, attributes ), kind( kind ) {}
         StructDecl( const StructDecl &other ) : Parent( other ) {}
 
+        bool is_coroutine() { return kind == DeclarationNode::Coroutine; }
+        bool is_monitor() { return kind == DeclarationNode::Monitor; }
+        bool is_thread() { return kind == DeclarationNode::Thread; }
+
         virtual StructDecl *clone() const { return new StructDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
+        DeclarationNode::Aggregate kind;
         virtual std::string typeString() const;
 };

src/SynTree/Type.h

@@ -117 +117 @@
                 bool operator!=( Qualifiers other ) const { return (val & Mask) != (other.val & Mask); }
                 bool operator<=( Qualifiers other ) const {
-                        return is_const <= other.is_const && is_volatile <= other.is_volatile &&
-                                is_mutex >= other.is_mutex && is_atomic == other.is_atomic;
+                        return is_const    <= other.is_const        //Any non-const converts to const without cost
+                                        && is_volatile <= other.is_volatile     //Any non-volatile converts to volatile without cost
+                                        && is_mutex    >= other.is_mutex        //Any mutex converts to non-mutex without cost
+                                        && is_atomic   == other.is_atomic;      //No conversion from atomic to non atomic is free
                 }
                 bool operator<( Qualifiers other ) const { return *this != other && *this <= other; }

src/benchmark/CorCtxSwitch.c

@@ -24 +24 @@
 
 struct GreatSuspender {
-        coroutine_desc c;
+        coroutine_desc __cor;
 };
 

src/benchmark/bench.c

@@ -86 +86 @@
 //=======================================
 
-struct CoroutineDummy { coroutine_desc c; };
+struct CoroutineDummy { coroutine_desc __cor; };
 DECL_COROUTINE(CoroutineDummy);
 void main(CoroutineDummy * this) {}
@@ -119 +119 @@
 struct CoroutineResume {
     int N;
-    coroutine_desc c;
+    coroutine_desc __cor;
 };
 
@@ -150 +150 @@
 //=======================================
 
-struct ThreadDummy { thread_desc t; };
+struct ThreadDummy { thread_desc __thrd; };
 DECL_THREAD(ThreadDummy);
 void main(ThreadDummy * this) {}
@@ -180 +180 @@
     int N;
     long long result;
-    thread_desc t;
+    thread_desc __thrd;
 };
 

src/benchmark/csv-data.c

@@ -26 +26 @@
 
 struct GreatSuspender {
-        coroutine_desc c;
+        coroutine_desc __cor;
 };
 

src/driver/Makefile.am

@@ -32 +32 @@
 
 install-exec-hook:
+        @test -z "$(CFA_BINDIR)" || $(MKDIR_P) "$(CFA_BINDIR)"
         @echo " $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) cfa '$(CFA_BINDIR)/$(CFA_NAME)'"; \
         $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) cfa $(CFA_BINDIR)/$(CFA_NAME) || exit $$?

src/driver/Makefile.in

@@ -530 +530 @@
 
 install-exec-hook:
+        @test -z "$(CFA_BINDIR)" || $(MKDIR_P) "$(CFA_BINDIR)"
         @echo " $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) cfa '$(CFA_BINDIR)/$(CFA_NAME)'"; \
         $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) cfa $(CFA_BINDIR)/$(CFA_NAME) || exit $$?

src/examples/multicore.c

@@ -2 +2 @@
 #include <thread>
 
-struct MyThread { thread_desc t; };
+struct MyThread { thread_desc __thrd; };
 
 DECL_THREAD(MyThread);

src/libcfa/concurrency/coroutine

@@ -30 +30 @@
 };
 
-#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X* this) { return &this->c; } void main(X* this)
+#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X* this) { return &this->__cor; } void main(X* this)
 
 //-----------------------------------------------------------------------------

src/libcfa/concurrency/invoke.c

@@ -56 +56 @@
 
 void CtxInvokeThread(
+      void (*dtor)(void *), 
       void (*main)(void *), 
       struct thread_desc *(*get_thread)(void *), 
@@ -63 +64 @@
 
       struct thread_desc* thrd = get_thread( this );
-      struct coroutine_desc* cor = &thrd->c;
+      struct coroutine_desc* cor = &thrd->cor;
       cor->state = Active;
 
@@ -91 +92 @@
         struct FakeStack {
             void *fixedRegisters[3];                    // fixed registers ebx, edi, esi (popped on 1st uSwitch, values unimportant)
-            uint32_t mxcr;                              // SSE Status and Control bits (control bits are preserved across function calls)
-            uint16_t fcw;                               // X97 FPU control word (preserved across function calls)
-            void *rturn;                                // where to go on return from uSwitch
+            uint32_t mxcr;                        // SSE Status and Control bits (control bits are preserved across function calls)
+          uint16_t fcw;                         // X97 FPU control word (preserved across function calls)
+            void *rturn;                          // where to go on return from uSwitch
             void *dummyReturn;                          // fake return compiler would have pushed on call to uInvoke
             void *argument[3];                          // for 16-byte ABI, 16-byte alignment starts here
@@ -105 +106 @@
         ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->argument[0] = this;     // argument to invoke
         ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = invoke;
+      ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520
+      ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F;  //Vol. 1 8-7 
 
 #elif defined( __x86_64__ )
 
       struct FakeStack {
-            void *fixedRegisters[5];                    // fixed registers rbx, r12, r13, r14, r15
-            uint32_t mxcr;                              // SSE Status and Control bits (control bits are preserved across function calls)
-            uint16_t fcw;                               // X97 FPU control word (preserved across function calls)
-            void *rturn;                                // where to go on return from uSwitch
-            void *dummyReturn;                          // NULL return address to provide proper alignment
+            void *fixedRegisters[5];            // fixed registers rbx, r12, r13, r14, r15
+            uint32_t mxcr;                      // SSE Status and Control bits (control bits are preserved across function calls)
+            uint16_t fcw;                       // X97 FPU control word (preserved across function calls)
+            void *rturn;                        // where to go on return from uSwitch
+            void *dummyReturn;                  // NULL return address to provide proper alignment
       };
 

src/libcfa/concurrency/invoke.h

@@ -28 +28 @@
       #define unlikely(x)    __builtin_expect(!!(x), 0)
       #define thread_local _Thread_local
-      #define SCHEDULER_CAPACITY 10
 
       struct spinlock {
@@ -60 +59 @@
 
       struct coStack_t {
-            unsigned int size;                // size of stack
-            void *storage;                            // pointer to stack
-            void *limit;                              // stack grows towards stack limit
-            void *base;                               // base of stack
-            void *context;                            // address of cfa_context_t
-            void *top;                                // address of top of storage
-            bool userStack;     
+            unsigned int size;                  // size of stack
+            void *storage;                      // pointer to stack
+            void *limit;                        // stack grows towards stack limit
+            void *base;                         // base of stack
+            void *context;                      // address of cfa_context_t
+            void *top;                          // address of top of storage
+            bool userStack;                     // whether or not the user allocated the stack
       };
 
@@ -72 +71 @@
 
       struct coroutine_desc {
-            struct coStack_t stack;
-            const char *name;                         // textual name for coroutine/task, initialized by uC++ generated code
-            int errno_;                               // copy of global UNIX variable errno
-            enum coroutine_state state;       // current execution status for coroutine
-            struct coroutine_desc *starter;           // first coroutine to resume this one
-            struct coroutine_desc *last;                      // last coroutine to resume this one
+            struct coStack_t stack;             // stack information of the coroutine
+            const char *name;                   // textual name for coroutine/task, initialized by uC++ generated code
+            int errno_;                         // copy of global UNIX variable errno
+            enum coroutine_state state;         // current execution status for coroutine
+            struct coroutine_desc *starter;     // first coroutine to resume this one
+            struct coroutine_desc *last;              // last coroutine to resume this one
       };
 
       struct thread_desc {
-            struct coroutine_desc c;                 // coroutine body used to store context
+            struct coroutine_desc cor;            // coroutine body used to store context
             struct signal_once terminated;      // indicate if execuation state is not halted
-            struct thread_desc * next;               // instrusive link field for threads
+            struct thread_desc * next;          // instrusive link field for threads
       };
 

src/libcfa/concurrency/kernel.c

@@ -107 +107 @@
 
 void ?{}( thread_desc * this, current_stack_info_t * info) {
-        (&this->c){ info };
+        (&this->cor){ info };
 }
 
@@ -113 +113 @@
 // Processor coroutine
 void ?{}(processorCtx_t * this, processor * proc) {
-        (&this->c){};
+        (&this->__cor){};
         this->proc = proc;
         proc->runner = this;
@@ -119 +119 @@
 
 void ?{}(processorCtx_t * this, processor * proc, current_stack_info_t * info) {
-        (&this->c){ info };
+        (&this->__cor){ info };
         this->proc = proc;
         proc->runner = this;
@@ -255 +255 @@
         processorCtx_t proc_cor_storage = { proc, &info };
 
-        LIB_DEBUG_PRINTF("Coroutine : created stack %p\n", proc_cor_storage.c.stack.base);
+        LIB_DEBUG_PRINTF("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
 
         //Set global state
-        proc->current_coroutine = &proc->runner->c;
+        proc->current_coroutine = &proc->runner->__cor;
         proc->current_thread = NULL;
 
@@ -268 +268 @@
         // back to here. Instead directly call the main since we already are on the 
         // appropriate stack.
-        proc_cor_storage.c.state = Active;
+        proc_cor_storage.__cor.state = Active;
       main( &proc_cor_storage );
-      proc_cor_storage.c.state = Halted;
+      proc_cor_storage.__cor.state = Halted;
 
         // Main routine of the core returned, the core is now fully terminated
@@ -359 +359 @@
         this_processor = systemProcessor;
         this_processor->current_thread = mainThread;
-        this_processor->current_coroutine = &mainThread->c;
+        this_processor->current_coroutine = &mainThread->cor;
 
         // SKULLDUGGERY: Force a context switch to the system processor to set the main thread's context to the current UNIX

src/libcfa/concurrency/kernel_private.h

@@ -35 +35 @@
 struct processorCtx_t {
         processor * proc;
-        coroutine_desc c;
+        coroutine_desc __cor;
 };
 

src/libcfa/concurrency/monitor

@@ -34 +34 @@
 }
 
-//Basic entering routine
-void enter(monitor_desc *);
-void leave(monitor_desc *);
-
 //Array entering routine
 void enter(monitor_desc **, int count);
@@ -49 +45 @@
 static inline int ?<?(monitor_desc* lhs, monitor_desc* rhs) {
         return ((intptr_t)lhs) < ((intptr_t)rhs);
-}
-
-static inline void ?{}( monitor_guard_t * this, monitor_desc ** m ) {
-        this->m = m;
-        this->count = 1;
-        enter( *this->m );
 }
 

src/libcfa/concurrency/monitor.c

@@ -74 +74 @@
 void enter(monitor_desc ** monitors, int count) {
         for(int i = 0; i < count; i++) {
-                // printf("%d\n", i);
                 enter( monitors[i] );
         }
@@ -81 +80 @@
 void leave(monitor_desc ** monitors, int count) {
         for(int i = count - 1; i >= 0; i--) {
-                // printf("%d\n", i);
                 leave( monitors[i] );
         }

src/libcfa/concurrency/thread

@@ -28 +28 @@
 // Anything that is resumed is a coroutine.
 trait is_thread(dtype T) {
+      void ^?{}(T* this);
       void main(T* this);
       thread_desc* get_thread(T* this);
 };
 
-#define DECL_THREAD(X) thread_desc* get_thread(X* this) { return &this->t; } void main(X* this)
+#define DECL_THREAD(X) thread_desc* get_thread(X* this) { return &this->__thrd; } void main(X* this)
 
 forall( dtype T | is_thread(T) )
 static inline coroutine_desc* get_coroutine(T* this) {
-        return &get_thread(this)->c;
+        return &get_thread(this)->cor;
 }
 
 static inline coroutine_desc* get_coroutine(thread_desc* this) {
-        return &this->c;
+        return &this->cor;
 }
 
@@ -64 +65 @@
 void ?{}( scoped(T)* this, P params );
 
-forall( dtype T | sized(T) | is_thread(T) | { void ^?{}(T*); } )
+forall( dtype T | sized(T) | is_thread(T) )
 void ^?{}( scoped(T)* this );
 

src/libcfa/concurrency/thread.c

@@ -42 +42 @@
 
 void ?{}(thread_desc* this) {
-        (&this->c){};
-        this->c.name = "Anonymous Coroutine";
+        (&this->cor){};
+        this->cor.name = "Anonymous Coroutine";
         (&this->terminated){};
         this->next = NULL;
@@ -49 +49 @@
 
 void ^?{}(thread_desc* this) {
-        ^(&this->c){};
+        ^(&this->cor){};
 }
 
@@ -64 +64 @@
 }
 
-forall( dtype T | sized(T) | is_thread(T) | { void ^?{}(T*); } )
+forall( dtype T | sized(T) | is_thread(T) )
 void ^?{}( scoped(T)* this ) {
         stop(&this->handle);
@@ -120 +120 @@
 extern "C" {
         void __thread_signal_termination( thread_desc * this ) {
-                this->c.state = Halted;
+                this->cor.state = Halted;
                 LIB_DEBUG_PRINTF("Thread end : %p\n", this);
                 signal( &this->terminated );    

src/main.cc

@@ -241 +241 @@
                 OPTPRINT( "fixNames" )
                 CodeGen::fixNames( translationUnit );
-                OPTPRINT( "tweakInit" )
+                OPTPRINT( "genInit" )
                 InitTweak::genInit( translationUnit );
                 OPTPRINT( "expandMemberTuples" );

src/tests/coroutine.c

@@ -2 +2 @@
 #include <coroutine>
 
-struct Fibonacci {
+coroutine Fibonacci {
       int fn; // used for communication
-      coroutine_desc c;
 };
 
@@ -11 +10 @@
 }
 
-coroutine_desc* get_coroutine(Fibonacci* this) {
-      return &this->c;
-}
-
 void main(Fibonacci* this) {
-#ifdef MORE_DEBUG
-      sout | "Starting main of coroutine " | this | endl;
-      sout | "Started from " | this->c.last | endl;
-#endif
       int fn1, fn2;             // retained between resumes
       this->fn = 0;
@@ -45 +36 @@
 int main() {
       Fibonacci f1, f2;
-#ifdef MORE_DEBUG      
-      Fibonacci *pf1 = &f1, *pf2 = &f2;
-      coroutine_desc *cf1 = &f1.c, *cf2 = &f2.c;
-      covptr_t  *vf1 = vtable(pf1), *vf2 = vtable(pf2);
-      coroutine_desc *cv1 = get_coroutine(vf1), *cv2 = get_coroutine(vf2);
-      Fibonacci *ov1 = (Fibonacci *)get_object(vf1), *ov2 = (Fibonacci *)get_object(vf2);
-
-      sout | "User coroutines : " | pf1 | ' ' | pf2 | endl;
-      sout | "Coroutine data  : " | cf1 | ' ' | cf2 | endl;
-      sout | "Vptr address    : " | vf1 | ' ' | vf2 | endl;
-      sout | "Vptr obj data   : " | ov1 | ' ' | ov2 | endl;
-      sout | "Vptr cor data   : " | cv1 | ' ' | cv2 | endl;
-#endif
       for ( int i = 1; i <= 10; i += 1 ) {
             sout | next(&f1) | ' ' | next(&f2) | endl;

src/tests/monitor.c

@@ -13 +13 @@
 }
 
+monitor_desc * get_monitor( global_t * this ) {
+        return &this->m;
+}
+
 static global_t global;
 
-void increment( /*mutex*/ global_t * this ) {
-        monitor_desc * mon = &this->m;
-        monitor_guard_t g1 = { &mon };
-        {
-                monitor_guard_t g2 = { &mon };
-                {
-                        monitor_guard_t g3 = { &mon };
-                        this->value += 1;
-                }
-        }
+void increment3( global_t * mutex this ) {
+        this->value += 1;
 }
 
-struct MyThread { thread_desc t; };
+void increment2( global_t * mutex this ) {
+        increment3( this );
+}
+
+void increment( global_t * mutex this ) {
+        increment2( this );
+}
+
+struct MyThread { thread_desc __thrd; };
 
 DECL_THREAD(MyThread);

src/tests/multi-monitor.c

@@ -6 +6 @@
 static int global12, global23, global13;
 
-static monitor_desc m1, m2, m3;
+struct monitor_t {
+        monitor_desc m;
+};
 
-void increment( /*mutex*/ monitor_desc * p1, /*mutex*/ monitor_desc * p2, int * value ) {
-        monitor_desc * mons[] = { p1, p2 };
-        monitor_guard_t g = { mons, 2 };
+monitor_desc * get_monitor( monitor_t * this ) {
+        return &this->m;
+}
+
+static monitor_t m1, m2, m3;
+
+void increment( monitor_t * mutex p1, monitor_t * mutex p2, int * value ) {
         *value += 1;
 }
 
 struct MyThread { 
-        thread_desc t; 
+        thread_desc __thrd; 
         int target;
 };

src/tests/thread.c

@@ -4 +4 @@
 #include <thread>
 
-struct First { thread_desc t; signal_once* lock; };
-struct Second { thread_desc t; signal_once* lock; };
+struct First { thread_desc __thrd; signal_once* lock; };
+struct Second { thread_desc __thrd; signal_once* lock; };
 
 DECL_THREAD(First);