Changeset c352893

Timestamp:

May 5, 2017, 3:42:38 PM (7 years ago)

Author:

Andrew Beach <ajbeach@…>

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:

f04288f

Parents:

f57668a (diff), 982ed5b (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:software/cfa/cfa-cc

Quick save while I switch computers.

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (2 diffs)
• CodeGen/Generate.cc (modified) (2 diffs)
• CodeGen/Generate.h (modified) (1 diff)
• Concurrency/Keywords.cc (modified) (4 diffs)
• GenPoly/PolyMutator.cc (modified) (2 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• SynTree/BaseSyntaxNode.h (modified) (1 diff)
• SynTree/Declaration.h (modified) (1 diff)
• SynTree/SynTree.h (modified) (1 diff)
• SynTree/TypeDecl.cc (modified) (1 diff)
• benchmark/CorCtxSwitch.c (modified) (2 diffs)
• benchmark/Makefile.am (modified) (1 diff)
• benchmark/Makefile.in (modified) (1 diff)
• benchmark/Monitor.c (added)
• benchmark/SchedInt.c (added)
• benchmark/ThrdCtxSwitch.c (modified) (1 diff)
• benchmark/bench.c (modified) (1 diff)
• benchmark/bench.h (added)
• benchmark/csv-data.c (modified) (4 diffs)
• libcfa/concurrency/thread.c (modified) (1 diff)
• tests/.expect/concurrent/sched-int-barge.txt (moved) (moved from src/tests/.expect/concurrent/sched-int-multi.txt)
• tests/.expect/concurrent/sched-int-disjoint.txt (added)
• tests/.expect/concurrent/sched-int-multi2.txt (deleted)
• tests/.expect/concurrent/sched-int-wait.txt (added)
• tests/.expect/concurrent/sched-int.txt (deleted)
• tests/Makefile.am (modified) (1 diff)
• tests/Makefile.in (modified) (1 diff)
• tests/sched-int-barge.c (moved) (moved from src/tests/sched-int-multi.c) (6 diffs)
• tests/sched-int-disjoint.c (added)
• tests/sched-int-wait.c (moved) (moved from src/tests/sched-int-multi2.c) (10 diffs)
• tests/sched-int.c (deleted)

src/CodeGen/CodeGenerator.cc

@@ -262 +262 @@
                         } // if
                 } else {
-                        output << typeDecl->typeString() << " " << typeDecl->get_name();
+                        output << typeDecl->genTypeString() << " " << typeDecl->get_name();
+                        if ( typeDecl->get_kind() != TypeDecl::Any && typeDecl->get_sized() ) {
+                                output << " | sized(" << typeDecl->get_name() << ")";
+                        }
                         if ( ! typeDecl->get_assertions().empty() ) {
                                 output << " | { ";
@@ -769 +772 @@
         void CodeGenerator::visit( ExprStmt * exprStmt ) {
                 assert( exprStmt );
-                // cast the top-level expression to void to reduce gcc warnings.
-                Expression * expr = new CastExpr( exprStmt->get_expr() );
+                Expression * expr = exprStmt->get_expr();
+                if ( genC ) {
+                        // cast the top-level expression to void to reduce gcc warnings.
+                        expr = new CastExpr( expr );
+                }
                 expr->accept( *this );
                 output << ";";

src/CodeGen/Generate.cc

@@ -22 +22 @@
 #include "SynTree/Declaration.h"
 #include "CodeGenerator.h"
-#include "Tuples/Tuples.h"
+#include "GenType.h"
+#include "SynTree/SynTree.h"
+#include "SynTree/Type.h"
+#include "SynTree/BaseSyntaxNode.h"
+// #include "Tuples/Tuples.h"
 
 using namespace std;
@@ -39 +43 @@
                 } // for
         }
+
+        void generate( BaseSyntaxNode * node, std::ostream & os ) {
+                if ( Type * type = dynamic_cast< Type * >( node ) ) {
+                        os << CodeGen::genPrettyType( type, "" );
+                } else {
+                        CodeGen::CodeGenerator cgv( os, true, false );
+                        node->accept( cgv );
+                }
+                os << std::endl;
+        }
 } // namespace CodeGen
 

src/CodeGen/Generate.h

@@ -25 +25 @@
         /// Generates code. doIntrinsics determines if intrinsic functions are printed, pretty formats output nicely (e.g., uses unmangled names, etc.), generateC is true when the output must consist only of C code (allows some assertions, etc.)
         void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC = false );
+
+        /// Generate code for a single node -- helpful for debugging in gdb
+        void generate( BaseSyntaxNode * node, std::ostream & os );
 } // namespace CodeGen
 

src/Concurrency/Keywords.cc

@@ -246 +246 @@
         //=============================================================================================
         void ConcurrentSueKeyword::visit(StructDecl * decl) {
+                Visitor::visit(decl);
                 if( decl->get_name() == type_name ) {
                         assert( !type_decl );
@@ -385 +386 @@
         //=============================================================================================
         void MutexKeyword::visit(FunctionDecl* decl) {
+                Visitor::visit(decl);           
+
                 std::list<DeclarationWithType*> mutexArgs = findMutexArgs( decl );
                 if( mutexArgs.empty() ) return;
@@ -402 +405 @@
 
         void MutexKeyword::visit(StructDecl* decl) {
+                Visitor::visit(decl);
+
                 if( decl->get_name() == "monitor_desc" ) {
                         assert( !monitor_decl );
@@ -504 +509 @@
         //=============================================================================================
         void ThreadStarter::visit(FunctionDecl * decl) {
+                Visitor::visit(decl);
+                
                 if( ! InitTweak::isConstructor(decl->get_name()) ) return;
 

src/GenPoly/PolyMutator.cc

@@ -50 +50 @@
 
         Statement * PolyMutator::mutateStatement( Statement *stmt ) {
+                // don't want statements from outer CompoundStmts to be added to this CompoundStmt
+                ValueGuard< std::list< Statement* > > oldStmtsToAdd( stmtsToAdd );
+                ValueGuard< std::list< Statement* > > oldStmtsToAddAfter( stmtsToAddAfter );
+                ValueGuard< TypeSubstitution * > oldEnv( env );
+                stmtsToAdd.clear();
+                stmtsToAddAfter.clear();
+
                 Statement *newStmt = maybeMutate( stmt, *this );
                 if ( ! stmtsToAdd.empty() || ! stmtsToAddAfter.empty() ) {
@@ -83 +90 @@
 
         Statement * PolyMutator::mutate(IfStmt *ifStmt) {
+                ifStmt->set_condition(  mutateExpression( ifStmt->get_condition() ) );
                 ifStmt->set_thenPart(  mutateStatement( ifStmt->get_thenPart() ) );
                 ifStmt->set_elsePart(  mutateStatement( ifStmt->get_elsePart() ) );
-                ifStmt->set_condition(  mutateExpression( ifStmt->get_condition() ) );
                 return ifStmt;
         }
 
         Statement * PolyMutator::mutate(WhileStmt *whileStmt) {
+                whileStmt->set_condition(  mutateExpression( whileStmt->get_condition() ) );
                 whileStmt->set_body(  mutateStatement( whileStmt->get_body() ) );
-                whileStmt->set_condition(  mutateExpression( whileStmt->get_condition() ) );
                 return whileStmt;
         }
 
         Statement * PolyMutator::mutate(ForStmt *forStmt) {
-                forStmt->set_body(  mutateStatement( forStmt->get_body() ) );
                 mutateAll( forStmt->get_initialization(), *this );
                 forStmt->set_condition(  mutateExpression( forStmt->get_condition() ) );
                 forStmt->set_increment(  mutateExpression( forStmt->get_increment() ) );
+                forStmt->set_body(  mutateStatement( forStmt->get_body() ) );
                 return forStmt;
         }
 
         Statement * PolyMutator::mutate(SwitchStmt *switchStmt) {
+                switchStmt->set_condition( mutateExpression( switchStmt->get_condition() ) );
                 mutateStatementList( switchStmt->get_statements() );
-                switchStmt->set_condition( mutateExpression( switchStmt->get_condition() ) );
                 return switchStmt;
         }
 
         Statement * PolyMutator::mutate(CaseStmt *caseStmt) {
+                caseStmt->set_condition(  mutateExpression( caseStmt->get_condition() ) );
                 mutateStatementList( caseStmt->get_statements() );
-                caseStmt->set_condition(  mutateExpression( caseStmt->get_condition() ) );
                 return caseStmt;
         }

src/ResolvExpr/AlternativeFinder.cc

@@ -766 +766 @@
                         } // if
                 } // for
-                // function may return struct or union value, in which case we need to add alternatives for implicit conversions to each of the anonymous members
+
+                candidates.clear();
+                candidates.splice( candidates.end(), alternatives );
+
+                findMinCost( candidates.begin(), candidates.end(), std::back_inserter( alternatives ) );
+
+                // function may return struct or union value, in which case we need to add alternatives for implicit
+                // conversions to each of the anonymous members, must happen after findMinCost since anon conversions
+                // are never the cheapest expression
                 for ( const Alternative & alt : alternatives ) {
                         addAnonConversions( alt );
                 }
-
-                candidates.clear();
-                candidates.splice( candidates.end(), alternatives );
-
-                findMinCost( candidates.begin(), candidates.end(), std::back_inserter( alternatives ) );
 
                 if ( alternatives.empty() && targetType && ! targetType->isVoid() ) {

src/SynTree/BaseSyntaxNode.h

@@ -18 +18 @@
 
 #include "Common/utility.h"
+#include "Visitor.h"
 
 class BaseSyntaxNode {
   public:
         CodeLocation location;
+
+        virtual void accept( Visitor & v ) = 0; // temporary -- needs to be here so that BaseSyntaxNode is polymorphic and can be dynamic_cast
 };
 

src/SynTree/Declaration.h

@@ -204 +204 @@
 
         virtual std::string typeString() const;
+        virtual std::string genTypeString() const;
 
         virtual TypeDecl *clone() const { return new TypeDecl( *this ); }

src/SynTree/SynTree.h

@@ -21 +21 @@
 #include <map>
 #include <iostream>
+
+class BaseSyntaxNode;
 
 class Declaration;

src/SynTree/TypeDecl.cc

@@ -29 +29 @@
 }
 
+std::string TypeDecl::genTypeString() const {
+        static const std::string kindNames[] = { "otype", "dtype", "ftype", "ttype" };
+        return kindNames[ kind ];
+}
+
 std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data ) {
   return os << data.kind << ", " << data.isComplete;

src/benchmark/CorCtxSwitch.c

@@ -3 +3 @@
 #include <thread>
 
-#include <unistd.h>                                     // sysconf
-#include <sys/times.h>                                  // times
-#include <time.h>
-
-inline unsigned long long int Time() {
-    timespec ts;
-    clock_gettime(
-#if defined( __linux__ )
-         CLOCK_THREAD_CPUTIME_ID,
-#elif defined( __freebsd__ )
-         CLOCK_PROF,
-#elif defined( __solaris__ )
-         CLOCK_HIGHRES,
-#else
-    #error uC++ : internal error, unsupported architecture
-#endif
-         &ts );
-    return 1000000000LL * ts.tv_sec + ts.tv_nsec;
-} // Time
+#include "bench.h"
 
 coroutine GreatSuspender {};
@@ -42 +24 @@
 }
 
-#ifndef N
-#define N 100000000
-#endif
-
 int main() {
         const unsigned int NoOfTimes = N;

src/benchmark/Makefile.am

@@ -44 +44 @@
         @rm -f ./a.out
 
+sched-int:
+        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=10000000 SchedInt.c
+        @for number in 1 2 3 4 5 6 7 8 9 10; do \
+                ./a.out ; \
+        done
+        @rm -f ./a.out
+
+monitor:
+        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=10000000 Monitor.c
+        @for number in 1 2 3 4 5 6 7 8 9 10; do \
+                ./a.out ; \
+        done
+        @rm -f ./a.out
+
 csv-data:
         @${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -quiet -DN=10000000 csv-data.c

src/benchmark/Makefile.in

@@ -492 +492 @@
         @rm -f ./a.out
 
+sched-int:
+        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=10000000 SchedInt.c
+        @for number in 1 2 3 4 5 6 7 8 9 10; do \
+                ./a.out ; \
+        done
+        @rm -f ./a.out
+
+monitor:
+        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=10000000 Monitor.c
+        @for number in 1 2 3 4 5 6 7 8 9 10; do \
+                ./a.out ; \
+        done
+        @rm -f ./a.out
+
 csv-data:
         @${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -quiet -DN=10000000 csv-data.c

src/benchmark/ThrdCtxSwitch.c

@@ -3 +3 @@
 #include <thread>
 
-#include <unistd.h>                                     // sysconf
-#include <sys/times.h>                                  // times
-#include <time.h>
-
-inline unsigned long long int Time() {
-    timespec ts;
-    clock_gettime(
-#if defined( __linux__ )
-         CLOCK_THREAD_CPUTIME_ID,
-#elif defined( __freebsd__ )
-         CLOCK_PROF,
-#elif defined( __solaris__ )
-         CLOCK_HIGHRES,
-#else
-    #error uC++ : internal error, unsupported architecture
-#endif
-         &ts );
-    return 1000000000LL * ts.tv_sec + ts.tv_nsec;
-} // Time
- 
-#ifndef N
-#define N 100000000
-#endif
+#include "bench.h"
 
 int main() {

src/benchmark/bench.c

@@ -4 +4 @@
 #include <thread>
 
-#include <unistd.h>                                     // sysconf
-#include <sys/times.h>                                  // times
-#include <time.h>
-
-inline unsigned long long int Time() {
-    timespec ts;
-    clock_gettime(
-#if defined( __linux__ )
-         CLOCK_THREAD_CPUTIME_ID,
-#elif defined( __freebsd__ )
-         CLOCK_PROF,
-#elif defined( __solaris__ )
-         CLOCK_HIGHRES,
-#else
-    #error uC++ : internal error, unsupported architecture
-#endif
-         &ts );
-    return 1000000000LL * ts.tv_sec + ts.tv_nsec;
-} // Time
+#include "bench.h"
 
 //=======================================

src/benchmark/csv-data.c

@@ -1 +1 @@
 #include <fstream>
+#include <monitor>
 #include <stdlib>
 #include <thread>
 
-extern "C" {
-#include <unistd.h>                                     // sysconf
-#include <sys/times.h>                                  // times
-#include <time.h>
-}
-
-inline unsigned long long int Time() {
-    timespec ts;
-    clock_gettime(
-#if defined( __linux__ )
-         CLOCK_THREAD_CPUTIME_ID,
-#elif defined( __freebsd__ )
-         CLOCK_PROF,
-#elif defined( __solaris__ )
-         CLOCK_HIGHRES,
-#else
-    #error uC++ : internal error, unsupported architecture
-#endif
-         &ts );
-    return 1000000000LL * ts.tv_sec + ts.tv_nsec;
-} // Time
+#include "bench.h"
 
 coroutine GreatSuspender {};
@@ -48 +29 @@
 #endif
 
-
-
+//-----------------------------------------------------------------------------
+// coroutine context switch
 long long int measure_coroutine() {
         const unsigned int NoOfTimes = N;
@@ -67 +48 @@
 }
 
+//-----------------------------------------------------------------------------
+// thread context switch
 long long int measure_thread() {
         const unsigned int NoOfTimes = N;
@@ -80 +63 @@
 }
 
+//-----------------------------------------------------------------------------
+// single monitor entry
+monitor mon_t {};
+void dummy( mon_t * mutex m ) {}
+
+long long int measure_1_monitor_entry() {
+        const unsigned int NoOfTimes = N;
+        long long int StartTime, EndTime;
+        mon_t mon;
+
+        StartTime = Time();
+        for ( volatile unsigned int i = 0; i < NoOfTimes; i += 1 ) {
+                dummy( &mon );
+        }
+        EndTime = Time();
+
+        return ( EndTime - StartTime ) / NoOfTimes;
+}
+
+//-----------------------------------------------------------------------------
+// multi monitor entry
+void dummy( mon_t * mutex m1,  mon_t * mutex m2 ) {}
+
+long long int measure_2_monitor_entry() {
+        const unsigned int NoOfTimes = N;
+        long long int StartTime, EndTime;
+        mon_t mon1, mon2;
+
+        StartTime = Time();
+        for ( volatile unsigned int i = 0; i < NoOfTimes; i += 1 ) {
+                dummy( &mon1, &mon2 );
+        }
+        EndTime = Time();
+
+        return ( EndTime - StartTime ) / NoOfTimes;
+}
+
+//-----------------------------------------------------------------------------
+// single internal sched entry
+mon_t mon1;
+
+condition cond1a; 
+condition cond1b;
+
+thread thrd1a { long long int * out; };
+thread thrd1b {};
+
+void ?{}( thrd1a * this, long long int * out ) {
+        this->out = out;
+}
+
+void side1A( mon_t * mutex a, long long int * out ) {
+        long long int StartTime, EndTime;
+
+        StartTime = Time();
+        for( int i = 0;; i++ ) {
+                signal(&cond1a);
+                if( i > N ) break;
+                wait(&cond1b);
+        }
+        EndTime = Time();
+
+        *out = ( EndTime - StartTime ) / N;
+}
+
+void side1B( mon_t * mutex a ) {
+        for( int i = 0;; i++ ) {
+                signal(&cond1b);
+                if( i > N ) break;
+                wait(&cond1a);
+        }
+}
+
+void main( thrd1a * this ) { side1A( &mon1, this->out ); }
+void main( thrd1b * this ) { side1B( &mon1 ); }
+
+long long int measure_1_sched_int() {
+        long long int t;
+        {
+                thrd1a a = { &t };
+                thrd1b b;
+        }
+        return t;
+}
+
+//-----------------------------------------------------------------------------
+// multi internal sched entry
+mon_t mon2;
+
+condition cond2a; 
+condition cond2b;
+
+thread thrd2a { long long int * out; };
+thread thrd2b {};
+
+void ?{}( thrd2a * this, long long int * out ) {
+        this->out = out;
+}
+
+void side2A( mon_t * mutex a, mon_t * mutex b, long long int * out ) {
+        long long int StartTime, EndTime;
+
+        StartTime = Time();
+        for( int i = 0;; i++ ) {
+                signal(&cond2a);
+                if( i > N ) break;
+                wait(&cond2b);
+        }
+        EndTime = Time();
+
+        *out = ( EndTime - StartTime ) / N;
+}
+
+void side2B( mon_t * mutex a, mon_t * mutex b ) {
+        for( int i = 0;; i++ ) {
+                signal(&cond2b);
+                if( i > N ) break;
+                wait(&cond2a);
+        }
+}
+
+void main( thrd2a * this ) { side2A( &mon1, &mon2, this->out ); }
+void main( thrd2b * this ) { side2B( &mon1, &mon2 ); }
+
+long long int measure_2_sched_int() {
+        long long int t;
+        {
+                thrd2a a = { &t };
+                thrd2b b;
+        }
+        return t;
+}
+
+//-----------------------------------------------------------------------------
+// main loop
 int main()
 {
-        sout | time(NULL) | ',' | measure_coroutine() | ',' | measure_thread() | endl;
-}
+        sout | time(NULL) | ',';
+        sout | measure_coroutine() | ',';
+        sout | measure_thread() | ',';
+        sout | measure_1_monitor_entry() | ',';
+        sout | measure_2_monitor_entry() | ',';
+        sout | measure_1_sched_int() | ',';
+        sout | measure_2_sched_int() | endl;
+}

src/libcfa/concurrency/thread.c

@@ -40 +40 @@
         this->next = NULL;
 
-        this->current_monitors      = NULL;
-        this->current_monitor_count = 0;
+        this->current_monitors      = &this->mon;
+        this->current_monitor_count = 1;
 }
 

src/tests/Makefile.am

@@ -22 +22 @@
 concurrent=yes
 quick_test+= coroutine thread monitor
-concurrent_test=coroutine thread monitor multi-monitor sched-int sched-int-multi sched-int-multi2 sched-ext sched-ext-multi preempt
+concurrent_test=coroutine thread monitor multi-monitor sched-int-disjoint sched-int-barge sched-int-wait sched-ext sched-ext-multi preempt
 else
 concurrent=no

src/tests/Makefile.in

@@ -230 +230 @@
 @BUILD_CONCURRENCY_TRUE@concurrent = yes
 @BUILD_CONCURRENCY_FALSE@concurrent_test = 
-@BUILD_CONCURRENCY_TRUE@concurrent_test = coroutine thread monitor multi-monitor sched-int sched-int-multi sched-int-multi2 sched-ext sched-ext-multi preempt
+@BUILD_CONCURRENCY_TRUE@concurrent_test = coroutine thread monitor multi-monitor sched-int-disjoint sched-int-barge sched-int-wait sched-ext sched-ext-multi preempt
 
 # applies to both programs

src/tests/sched-int-barge.c

@@ -2 +2 @@
 #include <kernel>
 #include <monitor>
+#include <stdlib>
 #include <thread>
 
@@ -12 +13 @@
         int counter;
         state_t state;
+
+        unsigned short do_signal;
+        unsigned short do_wait2;
+        unsigned short do_wait1;
 };
 
@@ -18 +23 @@
         this->counter = 0;
         this->state = BARGE;
+
+        this->do_signal = 6;
+        this->do_wait1  = 1;
+        this->do_wait2  = 3;
 }
 
@@ -33 +42 @@
         c->counter++;
 
+        if( (c->counter % 1000) == 0 ) sout | c->counter | endl;
+
         int action = c->counter % 10;
 
-        if( action == 1 || action == 3 ) {
-                if(c->state != BARGE) {
-                        sout | "ERROR Mutual exclusion is inconsistent for wait" | endl;
-                        abort();
-                }
+        if( action == 0 ) {
+                c->do_signal = max( ((unsigned)rand48()) % 10, 1);
+                c->do_wait1 = ((unsigned)rand48()) % (c->do_signal);
+                c->do_wait2 = ((unsigned)rand48()) % (c->do_signal);
 
+                // if(c->do_wait1 == c->do_wait2) sout | "Same" | endl;
+        }
+
+        if( action == c->do_wait1 || action == c->do_wait2 ) {
                 c->state = WAIT;
                 wait( &cond );
 
                 if(c->state != SIGNAL) {
-                        sout | "ERROR Barging detected" | endl;
+                        sout | "ERROR Barging detected" | c->counter | endl;
                         abort();
                 }
         }
-        else if( action == 6 ) {
-                if(c->state != BARGE) {
-                        sout | "ERROR Mutual exclusion is inconsistent for signal" | endl;
-                        abort();
-                }
-
+        else if( action == c->do_signal ) {
                 c->state = SIGNAL;
 
@@ -64 +73 @@
         }
 
-        if( (c->counter % 1000) == 0 ) sout | c->counter | endl;
-        if( c->counter == 100_000 ) c->done = true;
+        if( c->counter >= 100_000 ) c->done = true;
         return !c->done;
 }
@@ -82 +90 @@
 
 int main(int argc, char* argv[]) {
-        processor p[3];
+        rand48seed(0);
+        processor p;
         {
-                Threads t[20];
+                Threads t[17];
         }
 }

src/tests/sched-int-wait.c

@@ -2 +2 @@
 #include <kernel>
 #include <monitor>
+#include <stdlib>
 #include <thread>
 
@@ -12 +13 @@
 condition condAB, condAC, condBC, condABC;
 
-thread Signaler {};
+thread Signaler {
+        int signals[4];
+};
+
+void ?{}( Signaler * this ){
+        this->signals[0] = 0;
+        this->signals[1] = 0;
+        this->signals[2] = 0;
+        this->signals[3] = 0;
+}
+
 thread WaiterAB {};
 thread WaiterAC {};
@@ -18 +29 @@
 thread WaiterABC{};
 
-int state;
-
-/*
-multi phase
-*/
+volatile bool done;
 
 //----------------------------------------------------------------------------------------------------
@@ -35 +42 @@
 
 void wait( condition * cond, global_t * mutex a, global_t * mutex b ) {
-        state++;
-        sout | "Waiting" | state | endl;
         wait( cond );
-        sout | "Waking" | state | endl;
-        state--;
 }
 
 void wait( condition * cond, global_t * mutex a, global_t * mutex b, global_t * mutex c ) {
-        state++;
-        sout | "Waiting" | state | endl;
         wait( cond );
-        sout | "Waking" | state | endl;
-        state--;
 }
 
 //----------------------------------------------------------------------------------------------------
 // Signaler
-// signals respectively AB, AC, BC, ABC
-void signalerABC( global_t * mutex a, global_t * mutex b, global_t * mutex c ) {
-        sout | "Signaling ABC" | endl;
-        signal( &condABC, a, b, c );
-        sout | "Signaling AB" | endl;
-        signal( &condAB , a, b );
-        sout | "Signaling BC" | endl;
-        signal( &condBC , b, c );
-        sout | "Signaling AC" | endl;
-        signal( &condAC , a, c );
-}
+void main( Signaler* this ) {
 
-void signalerAB( global_t * mutex a, global_t * mutex b, global_t * c ) {
-        signalerABC(a, b, c);
-}
+        while( true ) {
+                int action = (unsigned)rand48() % 4;
+                bool finished = true;
 
-void signalerA( global_t * mutex a, global_t * b, global_t * c ) {
-        signalerAB (a, b, c);
-}
+                for(int i = 0; i < 4; i++) {
+                        if( this->signals[action] < 10_000 ) {
+                                finished = false;
+                                break;
+                        }
+                        else {
+                                action = (action + 1) % 4;
+                        }
+                }
 
-void main( Signaler* this ) {
-        while( state != 4 ) { yield(); }
-        signalerA( &globalA, &globalB, &globalC );
+                this->signals[action]++;
+                if( finished ) break;
+
+                //sout | action | this->signals[0] | this->signals[1] | this->signals[2] | this->signals[3] | endl;
+
+                switch( action ) {
+                        case 0: 
+                                signal( &condABC, &globalA, &globalB, &globalC );
+                                break;
+                        case 1: 
+                                signal( &condAB , &globalA, &globalB );
+                                break;
+                        case 2: 
+                                signal( &condBC , &globalB, &globalC );
+                                break;
+                        case 3: 
+                                signal( &condAC , &globalA, &globalC );
+                                break;
+                        default:
+                                sout | "Something went wrong" | endl;
+                                abort();
+                }
+        }       
 }
 
@@ -80 +95 @@
 // Waiter ABC
 void main( WaiterABC* this ) {
-        while( state != 0 ) { yield(); }
-        wait( &condABC, &globalA, &globalB, &globalC );
+        while( !done ) {
+                wait( &condABC, &globalA, &globalB, &globalC );
+        }
 }
 
@@ -87 +103 @@
 // Waiter AB
 void main( WaiterAB* this ) {
-        while( state != 1 ) { yield(); }
-        wait( &condAB , &globalA, &globalB );
+        while( !done ) {
+                wait( &condAB , &globalA, &globalB );
+        }
 }
 
@@ -94 +111 @@
 // Waiter AC
 void main( WaiterAC* this ) {
-        while( state != 2 ) { yield(); }
-        wait( &condAC , &globalA, &globalC );
+        while( !done ) {
+                wait( &condAC , &globalA, &globalC );
+        }
 }
 
@@ -101 +119 @@
 // Waiter BC
 void main( WaiterBC* this ) {
-        while( state != 3 ) { yield(); }
-        wait( &condBC , &globalB, &globalC );
+        while( !done ) {
+                wait( &condBC , &globalB, &globalC );
+        }
 }
 
@@ -108 +127 @@
 // Main
 int main(int argc, char* argv[]) {
-        state = 0;
+        done = false;
         processor p;
         {
@@ -115 +134 @@
                 WaiterBC  c;
                 WaiterAC  d;
-                Signaler  e;
+                {
+                        Signaler  e;
+                }
+                done = true;
+                signal( &condABC, &globalA, &globalB, &globalC );
+                signal( &condAB , &globalA, &globalB );
+                signal( &condBC , &globalB, &globalC );
+                signal( &condAC , &globalA, &globalC );
         }
 }