Changes in / [f57668a:c352893]

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 (added)
• tests/.expect/concurrent/sched-int-disjoint.txt (added)
• tests/.expect/concurrent/sched-int-multi.txt (deleted)
• 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 (added)
• tests/sched-int-disjoint.c (added)
• tests/sched-int-multi.c (deleted)
• tests/sched-int-multi2.c (deleted)
• tests/sched-int-wait.c (added)
• 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