Changeset db4062d

Timestamp:

Jun 20, 2018, 8:42:37 AM (5 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

aaron-thesis, arm-eh, 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, with_gc

Children:

4439008

Parents:

e04aec4 (diff), 270fdcf (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

Files:

• src/CodeGen/CodeGenerator.cc (modified) (2 diffs)
• src/CodeGen/CodeGenerator.h (modified) (1 diff)
• src/Common/Debug.h (modified) (1 diff)
• src/Common/PassVisitor.h (modified) (3 diffs)
• src/Common/PassVisitor.impl.h (modified) (5 diffs)
• src/GenPoly/Lvalue.cc (modified) (3 diffs)
• src/ResolvExpr/AlternativeFinder.cc (modified) (6 diffs)
• src/ResolvExpr/Resolver.h (modified) (1 diff)
• src/SymTab/Indexer.cc (modified) (2 diffs)
• src/SynTree/Expression.cc (modified) (1 diff)
• src/SynTree/Expression.h (modified) (1 diff)
• src/SynTree/Mutator.h (modified) (1 diff)
• src/SynTree/SynTree.h (modified) (1 diff)
• src/SynTree/Visitor.h (modified) (1 diff)
• src/tests/.gitignore (modified) (1 diff)
• src/tests/Makefile.am (modified) (1 diff)
• src/tests/Makefile.in (modified) (1 diff)
• src/tests/concurrent/coroutineYield.c (modified) (4 diffs)
• src/tests/concurrent/preempt.c (modified) (4 diffs)
• src/tests/concurrent/signal/block.c (modified) (3 diffs)
• src/tests/concurrent/signal/disjoint.c (modified) (5 diffs)
• src/tests/concurrent/signal/wait.c (modified) (6 diffs)
• src/tests/long_tests.h (added)
• src/tests/preempt_longrun/Makefile.am (modified) (3 diffs)
• src/tests/preempt_longrun/Makefile.in (modified) (4 diffs)
• src/tests/preempt_longrun/create.c (modified) (2 diffs)
• src/tests/preempt_longrun/enter.c (modified) (2 diffs)
• src/tests/preempt_longrun/enter3.c (modified) (2 diffs)
• src/tests/preempt_longrun/processor.c (modified) (2 diffs)
• src/tests/preempt_longrun/stack.c (modified) (2 diffs)
• src/tests/preempt_longrun/update-type (added)
• src/tests/preempt_longrun/yield.c (modified) (3 diffs)
• tools/Makefile.am (modified) (2 diffs)
• tools/Makefile.in (modified) (6 diffs)
• tools/busy (added)
• tools/error (added)
• tools/error.c (added)
• tools/watchdog (added)
• tools/watchdog.c (added)

src/CodeGen/CodeGenerator.cc

@@ -133 +133 @@
                 output << "__attribute__ ((";
                 for ( list< Attribute * >::iterator attr( attributes.begin() );; ) {
-                        output << (*attr)->get_name();
-                        if ( ! (*attr)->get_parameters().empty() ) {
+                        output << (*attr)->name;
+                        if ( ! (*attr)->parameters.empty() ) {
                                 output << "(";
-                                genCommaList( (*attr)->get_parameters().begin(), (*attr)->get_parameters().end() );
+                                genCommaList( (*attr)->parameters.begin(), (*attr)->parameters.end() );
                                 output << ")";
                         } // if
@@ -836 +836 @@
                 assertf( ! genC, "Deleted expressions should not reach code generation." );
                 expr->expr->accept( *visitor );
+        }
+
+        void CodeGenerator::postvisit( DefaultArgExpr * arg ) {
+                assertf( ! genC, "Default argument expressions should not reach code generation." );
+                arg->expr->accept( *visitor );
         }
 

src/CodeGen/CodeGenerator.h

@@ -94 +94 @@
                 void postvisit( ConstructorExpr * );
                 void postvisit( DeletedExpr * );
+                void postvisit( DefaultArgExpr * );
                 void postvisit( GenericExpr * );
 

src/Common/Debug.h

@@ -28 +28 @@
 namespace Debug {
         /// debug codegen a translation unit
-        static inline void codeGen( __attribute__((unused)) const std::list< Declaration * > & translationUnit, __attribute__((unused)) const std::string & label, __attribute__((unused)) LinkageSpec::Spec linkageFilter = LinkageSpec::Compiler ) {
+        static inline void codeGen( __attribute__((unused)) const std::list< Declaration * > & translationUnit, __attribute__((unused)) const std::string & label, __attribute__((unused)) LinkageSpec::Spec linkageFilter = LinkageSpec::Builtin ) {
         #ifdef DEBUG
                 std::list< Declaration * > decls;

src/Common/PassVisitor.h

@@ -125 +125 @@
         virtual void visit( InitExpr *  initExpr ) override final;
         virtual void visit( DeletedExpr *  delExpr ) override final;
+        virtual void visit( DefaultArgExpr * argExpr ) override final;
         virtual void visit( GenericExpr * genExpr ) override final;
 
@@ -224 +225 @@
         virtual Expression * mutate( InitExpr *  initExpr ) override final;
         virtual Expression * mutate( DeletedExpr *  delExpr ) override final;
+        virtual Expression * mutate( DefaultArgExpr * argExpr ) override final;
         virtual Expression * mutate( GenericExpr * genExpr ) override final;
 
@@ -258 +260 @@
 
 private:
+        bool inFunction = false;
+
         template<typename pass_t> friend void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_t >& visitor );
         template<typename pass_t> friend void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_t >& visitor );

src/Common/PassVisitor.impl.h

@@ -404 +404 @@
                         indexerAddId( &func );
                         maybeAccept_impl( node->type, *this );
+                        // function body needs to have the same scope as parameters - CompoundStmt will not enter
+                        // a new scope if inFunction is true
+                        ValueGuard< bool > oldInFunction( inFunction );
+                        inFunction = true;
                         maybeAccept_impl( node->statements, *this );
                         maybeAccept_impl( node->attributes, *this );
@@ -434 +438 @@
                         indexerAddId( &func );
                         maybeMutate_impl( node->type, *this );
+                        // function body needs to have the same scope as parameters - CompoundStmt will not enter
+                        // a new scope if inFunction is true
+                        ValueGuard< bool > oldInFunction( inFunction );
+                        inFunction = true;
                         maybeMutate_impl( node->statements, *this );
                         maybeMutate_impl( node->attributes, *this );
@@ -712 +720 @@
         VISIT_START( node );
         {
-                auto guard1 = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                // do not enter a new scope if inFunction is true - needs to check old state before the assignment
+                ValueGuard< bool > oldInFunction( inFunction );
+                auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
                 auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
+                inFunction = false;
                 visitStatementList( node->kids );
         }
@@ -723 +734 @@
         MUTATE_START( node );
         {
-                auto guard1 = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                // do not enter a new scope if inFunction is true - needs to check old state before the assignment
+                ValueGuard< bool > oldInFunction( inFunction );
+                auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
                 auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
+                inFunction = false;
                 mutateStatementList( node->kids );
         }
@@ -2084 +2098 @@
 
 //--------------------------------------------------------------------------
+// DefaultArgExpr
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( DefaultArgExpr * node ) {
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+        maybeAccept_impl( node->expr, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( DefaultArgExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env, *this );
+        indexerScopedMutate( node->result, *this );
+        maybeMutate_impl( node->expr, *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
 // GenericExpr
 template< typename pass_type >

src/GenPoly/Lvalue.cc

@@ -146 +146 @@
 
         namespace {
-                // true for intrinsic function calls that return a reference
+                // true for intrinsic function calls that return an lvalue in C
                 bool isIntrinsicReference( Expression * expr ) {
+                        // known intrinsic-reference prelude functions
+                        static std::set<std::string> lvalueFunctions = { "*?", "?[?]" };
                         if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * >( expr ) ) {
                                 std::string fname = InitTweak::getFunctionName( untyped );
-                                // known intrinsic-reference prelude functions
-                                return fname == "*?" || fname == "?[?]";
+                                return lvalueFunctions.count(fname);
                         } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( expr ) ) {
                                 if ( DeclarationWithType * func = InitTweak::getFunction( appExpr ) ) {
-                                        // use type of return variable rather than expr result type, since it may have been changed to a pointer type
-                                        FunctionType * ftype = GenPoly::getFunctionType( func->get_type() );
-                                        Type * ret = ftype->returnVals.empty() ? nullptr : ftype->returnVals.front()->get_type();
-                                        return func->linkage == LinkageSpec::Intrinsic && dynamic_cast<ReferenceType *>( ret );
+                                        return func->linkage == LinkageSpec::Intrinsic && lvalueFunctions.count(func->name);
                                 }
                         }
@@ -212 +210 @@
                                                 // TODO: it's likely that the second condition should be ... && ! isIntrinsicReference( arg ), but this requires investigation.
 
-                                                if ( function->get_linkage() != LinkageSpec::Intrinsic && isIntrinsicReference( arg ) ) {
+                                                if ( function->linkage != LinkageSpec::Intrinsic && isIntrinsicReference( arg ) ) {
                                                         // needed for definition of prelude functions, etc.
                                                         // if argument is dereference or array subscript, the result isn't REALLY a reference, but non-intrinsic functions expect a reference: take address
@@ -228 +226 @@
                                                         arg = new AddressExpr( arg );
                                                 // } else if ( function->get_linkage() == LinkageSpec::Intrinsic && InitTweak::getPointerBase( arg->result ) ) {
-                                                } else if ( function->get_linkage() == LinkageSpec::Intrinsic && arg->result->referenceDepth() != 0 ) {
+                                                } else if ( function->linkage == LinkageSpec::Intrinsic && arg->result->referenceDepth() != 0 ) {
                                                         // argument is a 'real' reference, but function expects a C lvalue: add a dereference to the reference-typed argument
                                                         PRINT(

src/ResolvExpr/AlternativeFinder.cc

@@ -176 +176 @@
                                                 selected[ mangleName ] = current;
                                         } else if ( candidate->cost == mapPlace->second.candidate->cost ) {
-                                                PRINT(
-                                                        std::cerr << "marking ambiguous" << std::endl;
-                                                )
-                                                mapPlace->second.isAmbiguous = true;
+                                                // if one of the candidates contains a deleted identifier, can pick the other, since
+                                                // deleted expressions should not be ambiguous if there is another option that is at least as good
+                                                if ( findDeletedExpr( candidate->expr ) ) {
+                                                        // do nothing
+                                                        PRINT( std::cerr << "candidate is deleted" << std::endl; )
+                                                } else if ( findDeletedExpr( mapPlace->second.candidate->expr ) ) {
+                                                        PRINT( std::cerr << "current is deleted" << std::endl; )
+                                                        selected[ mangleName ] = current;
+                                                } else {
+                                                        PRINT(
+                                                                std::cerr << "marking ambiguous" << std::endl;
+                                                        )
+                                                        mapPlace->second.isAmbiguous = true;
+                                                }
                                         } else {
                                                 PRINT(
@@ -335 +345 @@
                 if ( ConstantExpr * constantExpr = dynamic_cast< ConstantExpr * >( member ) ) {
                         // get the value of the constant expression as an int, must be between 0 and the length of the tuple type to have meaning
-                        // xxx - this should be improved by memoizing the value of constant exprs
-                        // during parsing and reusing that information here.
-                        std::stringstream ss( constantExpr->get_constant()->get_value() );
-                        int val = 0;
+                        auto val = constantExpr->intValue();
                         std::string tmp;
-                        if ( ss >> val && ! (ss >> tmp) ) {
-                                if ( val >= 0 && (unsigned int)val < tupleType->size() ) {
-                                        alternatives.push_back( Alternative( new TupleIndexExpr( expr->clone(), val ), env, newCost ) );
-                                } // if
+                        if ( val >= 0 && (unsigned long long)val < tupleType->size() ) {
+                                alternatives.push_back( Alternative( new TupleIndexExpr( expr->clone(), val ), env, newCost ) );
                         } // if
-                } else if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( member ) ) {
-                        // xxx - temporary hack until 0/1 are int constants
-                        if ( nameExpr->get_name() == "0" || nameExpr->get_name() == "1" ) {
-                                std::stringstream ss( nameExpr->get_name() );
-                                int val;
-                                ss >> val;
-                                alternatives.push_back( Alternative( new TupleIndexExpr( expr->clone(), val ), env, newCost ) );
-                        }
                 } // if
         }
@@ -439 +436 @@
                                         return Cost::infinity;
                                 }
+                        }
+                        if ( DefaultArgExpr * def = dynamic_cast< DefaultArgExpr * >( *actualExpr ) ) {
+                                // default arguments should be free - don't include conversion cost.
+                                // Unwrap them here because they are not relevant to the rest of the system.
+                                *actualExpr = def->expr;
+                                ++formal;
+                                continue;
                         }
                         Type * formalType = (*formal)->get_type();
@@ -611 +615 @@
         ConstantExpr* getDefaultValue( Initializer* init ) {
                 if ( SingleInit* si = dynamic_cast<SingleInit*>( init ) ) {
-                        if ( CastExpr* ce = dynamic_cast<CastExpr*>( si->get_value() ) ) {
-                                return dynamic_cast<ConstantExpr*>( ce->get_arg() );
+                        if ( CastExpr* ce = dynamic_cast<CastExpr*>( si->value ) ) {
+                                return dynamic_cast<ConstantExpr*>( ce->arg );
+                        } else {
+                                return dynamic_cast<ConstantExpr*>( si->value );
                         }
                 }
@@ -873 +879 @@
                                                                 indexer ) ) {
                                                         results.emplace_back(
-                                                                i, cnstExpr, move(env), move(need), move(have),
+                                                                i, new DefaultArgExpr( cnstExpr ), move(env), move(need), move(have),
                                                                 move(openVars), nextArg, nTuples );
                                                 }
@@ -1065 +1071 @@
                 funcFinder.findWithAdjustment( untypedExpr->function );
                 // if there are no function alternatives, then proceeding is a waste of time.
+                // xxx - findWithAdjustment throws, so this check and others like it shouldn't be necessary.
                 if ( funcFinder.alternatives.empty() ) return;
 

src/ResolvExpr/Resolver.h

@@ -36 +36 @@
         void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
         void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer );
+        /// Searches expr and returns the first DeletedExpr found, otherwise nullptr
+        DeletedExpr * findDeletedExpr( Expression * expr );
 } // namespace ResolvExpr
 

src/SymTab/Indexer.cc

@@ -126 +126 @@
                                 decls.push_back( DeclBall{ data, isUserDefinedFunc, isCopyFunc } );
                                 existsUserDefinedCopyFunc = existsUserDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc);
-                                if ( isUserDefinedFunc && ! data.deleteStmt ) {
+                                if ( isUserDefinedFunc && ! deleteStmt ) {
                                         // any user-defined function can act as an implicit delete statement for generated constructors.
                                         // a delete stmt should not act as an implicit delete statement.
@@ -166 +166 @@
                                 bool isCopyFunc = ball.isCopyFunc;
                                 bool existsUserDefinedCopyFunc = val.existsUserDefinedCopyFunc;
-                                // only implicitly delete non-user defined functions that are  not intrinsic, and are
-                                // not copy functions (assignment or copy constructor), unless a user-defined copy function exists.
-                                // deleteStmt will be non-null only if a user-defined function is found.
-                                if (isNotUserDefinedFunc && (! isCopyFunc || existsUserDefinedCopyFunc)) {
-                                        ball.decl.deleteStmt = val.deleteStmt;
+
+                                // only implicitly delete non-user defined functions that are not intrinsic, and are
+                                // not copy functions (assignment or copy constructor). If a  user-defined copy function exists,
+                                // do not pass along the non-user-defined copy functions since signatures do not have to match,
+                                // and the generated functions will often be cheaper.
+                                if ( isNotUserDefinedFunc ) {
+                                        if ( isCopyFunc ) {
+                                                // Skip over non-user-defined copy functions when there is a user-defined copy function.
+                                                // Since their signatures do not have to be exact, deleting them is the wrong choice.
+                                                if ( existsUserDefinedCopyFunc ) continue;
+                                        } else {
+                                                // delete non-user-defined non-copy functions if applicable.
+                                                // deleteStmt will be non-null only if a user-defined function is found.
+                                                ball.decl.deleteStmt = val.deleteStmt;
+                                        }
                                 }
                                 out.push_back( ball.decl );

src/SynTree/Expression.cc

@@ -746 +746 @@
         os << std::endl << indent+1 << "... deleted by: ";
         deleteStmt->print( os, indent+1 );
+}
+
+
+DefaultArgExpr::DefaultArgExpr( Expression * expr ) : expr( expr ) {
+        assert( expr->result );
+        result = expr->result->clone();
+}
+DefaultArgExpr::DefaultArgExpr( const DefaultArgExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ) {}
+DefaultArgExpr::~DefaultArgExpr() {
+        delete expr;
+}
+
+void DefaultArgExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "Default Argument Expression" << std::endl << indent+1;
+        expr->print( os, indent+1 );
 }
 

src/SynTree/Expression.h

@@ -865 +865 @@
 };
 
+/// expression wrapping the use of a default argument - should never make it past the resolver.
+class DefaultArgExpr : public Expression {
+public:
+        Expression * expr;
+
+        DefaultArgExpr( Expression * expr );
+        DefaultArgExpr( const DefaultArgExpr & other );
+        ~DefaultArgExpr();
+
+        virtual DefaultArgExpr * clone() const { return new DefaultArgExpr( * this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+};
+
 /// C11 _Generic expression
 class GenericExpr : public Expression {

src/SynTree/Mutator.h

@@ -93 +93 @@
         virtual Expression * mutate( InitExpr  * initExpr ) = 0;
         virtual Expression * mutate( DeletedExpr * delExpr ) = 0;
+        virtual Expression * mutate( DefaultArgExpr * argExpr ) = 0;
         virtual Expression * mutate( GenericExpr * genExpr ) = 0;
 

src/SynTree/SynTree.h

@@ -101 +101 @@
 class InitExpr;
 class DeletedExpr;
+class DefaultArgExpr;
 class GenericExpr;
 

src/SynTree/Visitor.h

@@ -95 +95 @@
         virtual void visit( InitExpr *  initExpr ) = 0;
         virtual void visit( DeletedExpr * delExpr ) = 0;
+        virtual void visit( DefaultArgExpr * argExpr ) = 0;
         virtual void visit( GenericExpr * genExpr ) = 0;
 

src/tests/.gitignore

@@ -1 +1 @@
 .out/
 .err/
+.type

src/tests/Makefile.am

@@ -28 +28 @@
 DEBUG_FLAGS =
 
-BUILD_FLAGS = -g -Wall -Wno-unused-function -quiet @CFA_FLAGS@
+BUILD_FLAGS = -g -Wall -Wno-unused-function -quiet @CFA_FLAGS@ -I.
 if !BUILD_DEBUG
 BUILD_FLAGS += -nodebug

src/tests/Makefile.in

@@ -309 +309 @@
 # applies to both programs
 DEBUG_FLAGS = 
-BUILD_FLAGS = -g -Wall -Wno-unused-function -quiet @CFA_FLAGS@ \
+BUILD_FLAGS = -g -Wall -Wno-unused-function -quiet @CFA_FLAGS@ -I. \
         $(am__append_1) $(am__append_2) $(am__append_3)
 TEST_FLAGS = $(if $(test), 2> $(test), )

src/tests/concurrent/coroutineYield.c

@@ -4 +4 @@
 #include <thread>
 #include <time>
+
+#define __kick_rate 150000ul
+#include "long_tests.h"
 
 #ifndef PREEMPTION_RATE
@@ -13 +16 @@
 }
 
-#ifdef LONG_TEST
+#ifdef TEST_LONG
 static const unsigned long N = 600_000ul;
 #else
@@ -23 +26 @@
 void main(Coroutine& this) {
         while(true) {
-                sout | "Coroutine 1" | endl;
+                #if !defined(TEST_FOREVER)
+                        sout | "Coroutine 1" | endl;
+                #endif
                 yield();
-                sout | "Coroutine 2" | endl;
+                #if !defined(TEST_FOREVER)
+                        sout | "Coroutine 2" | endl;
+                #endif
                 suspend();
         }
@@ -33 +40 @@
 int main(int argc, char* argv[]) {
         Coroutine c;
-        for(int i = 0; i < N; i++) {
-                sout | "Thread 1" | endl;
+        for(int i = 0; TEST(i < N); i++) {
+                #if !defined(TEST_FOREVER)
+                        sout | "Thread 1" | endl;
+                #endif
                 resume(c);
-                sout | "Thread 2" | endl;
+                #if !defined(TEST_FOREVER)
+                        sout | "Thread 2" | endl;
+                #endif
                 yield();
+                KICK_WATCHDOG;
         }
 }

src/tests/concurrent/preempt.c

@@ -2 +2 @@
 #include <thread>
 #include <time>
+
+#include "long_tests.h"
 
 #ifndef PREEMPTION_RATE
@@ -11 +13 @@
 }
 
-#ifdef LONG_TEST
+#ifdef TEST_LONG
 static const unsigned long N = 30_000ul;
 #else
@@ -30 +32 @@
 
 void main(worker_t & this) {
-        while(counter < N) {
+        while(TEST(counter < N)) {
                 __cfaabi_check_preemption();
                 if( (counter % 7) == this.value ) {
@@ -40 +42 @@
                 }
                 __cfaabi_check_preemption();
+                KICK_WATCHDOG;
         }
 }

src/tests/concurrent/signal/block.c

@@ -14 +14 @@
 #include <time>
 
+#include "long_tests.h"
+
 #ifndef PREEMPTION_RATE
 #define PREEMPTION_RATE 10`ms
@@ -22 +24 @@
 }
 
-#ifdef LONG_TEST
+#ifdef TEST_LONG
 static const unsigned long N = 150_000ul;
 #else
@@ -66 +68 @@
 thread Waiter {};
 void main( Waiter & this ) {
-        for( int i = 0; i < N; i++ ) {
+        for( int i = 0; TEST(i < N); i++ ) {
                 wait_op( globalA, globalB, i );
+                KICK_WATCHDOG;
         }
 }

src/tests/concurrent/signal/disjoint.c

@@ -4 +4 @@
 #include <thread>
 #include <time>
+
+#include "long_tests.h"
 
 #ifndef PREEMPTION_RATE
@@ -13 +15 @@
 }
 
-#ifdef LONG_TEST
+#ifdef TEST_LONG
 static const unsigned long N = 300_000ul;
 #else
@@ -67 +69 @@
         }
 
-        d.counter++;
+        #if !defined(TEST_FOREVER)
+                d.counter++;
+                if( (d.counter % 1000) == 0 ) sout | d.counter | endl;
+        #endif
 
-        if( (d.counter % 1000) == 0 ) sout | d.counter | endl;
-
-        return d.counter < N;
+        return TEST(d.counter < N);
 }
 
@@ -77 +80 @@
 
 void main( Waiter & this ) {
-        while( wait( mut, data ) ) { yield(); }
+        while( wait( mut, data ) ) { KICK_WATCHDOG; yield(); }
 }
 
@@ -94 +97 @@
 
         //This is technically a mutual exclusion violation but the mutex monitor protects us
-        bool running = data.counter < N && data.counter > 0;
+        bool running = TEST(data.counter < N) && data.counter > 0;
         if( data.state != SIGNAL && running ) {
                 sout | "ERROR Eager signal" | data.state | endl;

src/tests/concurrent/signal/wait.c

@@ -12 +12 @@
 #include <time>
 
+#define __kick_rate 12000ul
+#include "long_tests.h"
+
 #ifndef PREEMPTION_RATE
 #define PREEMPTION_RATE 10`ms
@@ -20 +23 @@
 }
 
-#ifdef LONG_TEST
+#ifdef TEST_LONG
 static const unsigned long N = 375_000ul;
 #else
@@ -90 +93 @@
 // Waiter ABC
 void main( WaiterABC & this ) {
-        for( int i = 0; i < N; i++ ) {
+        for( int i = 0; TEST(i < N); i++ ) {
                 wait( condABC, globalA, globalB, globalC );
+                KICK_WATCHDOG;
         }
 
@@ -100 +104 @@
 // Waiter AB
 void main( WaiterAB & this ) {
-        for( int i = 0; i < N; i++ ) {
+        for( int i = 0; TEST(i < N); i++ ) {
                 wait( condAB , globalA, globalB );
+                KICK_WATCHDOG;
         }
 
@@ -110 +115 @@
 // Waiter AC
 void main( WaiterAC & this ) {
-        for( int i = 0; i < N; i++ ) {
+        for( int i = 0; TEST(i < N); i++ ) {
                 wait( condAC , globalA, globalC );
+                KICK_WATCHDOG;
         }
 
@@ -120 +126 @@
 // Waiter BC
 void main( WaiterBC & this ) {
-        for( int i = 0; i < N; i++ ) {
+        for( int i = 0; TEST(i < N); i++ ) {
                 wait( condBC , globalB, globalC );
+                KICK_WATCHDOG;
         }
 

src/tests/preempt_longrun/Makefile.am

@@ -19 +19 @@
 preempt=10ul\`ms
 debug=-debug
+type=LONG
 
 REPEAT = ${abs_top_srcdir}/tools/repeat
+WATCHDOG = ${abs_top_srcdir}/tools/watchdog
 TIME = /usr/bin/time -f "%E"
 
-BUILD_FLAGS = -g -Wall -Wno-unused-function -quiet @CFA_FLAGS@ -O2 -DPREEMPTION_RATE=${preempt} -DLONG_TEST
+# $(shell ./update-type $(type))
+# ./update-type $(type)
+
+UPDATED_TYPE = $(shell ./update-type $(type))
+
+BUILD_FLAGS = -g -Wall -Wno-unused-function -quiet @CFA_FLAGS@ -O2 -DPREEMPTION_RATE=${preempt} -I.. -I. -DTEST_$(shell cat .type | tr a-z A-Z)
 CFLAGS = ${BUILD_FLAGS}
 CC = @CFA_BINDIR@/@CFA_NAME@
@@ -29 +36 @@
 TESTS = block coroutine create disjoint enter enter3 processor stack wait yield
 
-.INTERMEDIATE: ${TESTS}
+# .INTERMEDIATE: ${TESTS}
 
 all-local: ${TESTS:=.run}
 
+runall : ${TESTS:=.run}
+        @ echo "All programs terminated normally"
+
+watchall : ${TESTS:=.watch}
+        @ echo "All programs terminated normally"
+
+compileall : ${TESTS}
+        @ echo "Compiled"
+
 clean-local:
-        rm -f ${TESTS} core* out.log
+        rm -f ${TESTS} core* out.log .type
 
-% : %.c ${CC}
+% : %.c ${CC} ${UPDATED_TYPE}
         ${AM_V_GEN}${CC} ${CFLAGS} ${<} $(debug) -o ${@}
 
 %.run : % ${REPEAT}
         @ time ${REPEAT} -r out.log -i -s $(repeats) timeout ${max_time} ./${<}
+        @ rm ${<}
+        @ echo -e "${<}: SUCCESS\n"
+
+%.watch : % ${WATCHDOG}
+        @ time ${WATCHDOG} ./${<}
         @ rm ${<}
         @ echo -e "${<}: SUCCESS\n"
@@ -49 +70 @@
         @ echo -e "${<}: SUCCESS\n"
 
-${REPEAT}:
+${REPEAT}: ${abs_top_srcdir}/tools/Makefile
         @+make -C ${abs_top_srcdir}/tools/
+
+${WATCHDOG}: ${abs_top_srcdir}/tools/Makefile
+        @+make -C ${abs_top_srcdir}/tools/

src/tests/preempt_longrun/Makefile.in

@@ -452 +452 @@
 preempt = 10ul\`ms
 debug = -debug
+type = LONG
 REPEAT = ${abs_top_srcdir}/tools/repeat
+WATCHDOG = ${abs_top_srcdir}/tools/watchdog
 TIME = /usr/bin/time -f "%E"
-BUILD_FLAGS = -g -Wall -Wno-unused-function -quiet @CFA_FLAGS@ -O2 -DPREEMPTION_RATE=${preempt} -DLONG_TEST
+
+# $(shell ./update-type $(type))
+# ./update-type $(type)
+UPDATED_TYPE = $(shell ./update-type $(type))
+BUILD_FLAGS = -g -Wall -Wno-unused-function -quiet @CFA_FLAGS@ -O2 -DPREEMPTION_RATE=${preempt} -I.. -I. -DTEST_$(shell cat .type | tr a-z A-Z)
 TESTS = block coroutine create disjoint enter enter3 processor stack wait yield
 all: all-am
@@ -873 +879 @@
 
 
-.INTERMEDIATE: ${TESTS}
+# .INTERMEDIATE: ${TESTS}
 
 all-local: ${TESTS:=.run}
 
+runall : ${TESTS:=.run}
+        @ echo "All programs terminated normally"
+
+watchall : ${TESTS:=.watch}
+        @ echo "All programs terminated normally"
+
+compileall : ${TESTS}
+        @ echo "Compiled"
+
 clean-local:
-        rm -f ${TESTS} core* out.log
-
-% : %.c ${CC}
+        rm -f ${TESTS} core* out.log .type
+
+% : %.c ${CC} ${UPDATED_TYPE}
         ${AM_V_GEN}${CC} ${CFLAGS} ${<} $(debug) -o ${@}
 
@@ -888 +903 @@
         @ echo -e "${<}: SUCCESS\n"
 
+%.watch : % ${WATCHDOG}
+        @ time ${WATCHDOG} ./${<}
+        @ rm ${<}
+        @ echo -e "${<}: SUCCESS\n"
+
 %.time : % ${REPEAT}
         @ ${REPEAT} -i -s -- $(repeats) $(TIME) -a -o times.log ./${<}
@@ -893 +913 @@
         @ echo -e "${<}: SUCCESS\n"
 
-${REPEAT}:
+${REPEAT}: ${abs_top_srcdir}/tools/Makefile
+        @+make -C ${abs_top_srcdir}/tools/
+
+${WATCHDOG}: ${abs_top_srcdir}/tools/Makefile
         @+make -C ${abs_top_srcdir}/tools/
 

src/tests/preempt_longrun/create.c

@@ -2 +2 @@
 #include <thread>
 #include <time>
+
+#include "long_tests.h"
 
 #ifndef PREEMPTION_RATE
@@ -19 +21 @@
 int main(int argc, char* argv[]) {
         processor p;
-        for(int i = 0; i < N; i++) {
+        for(int i = 0; TEST(i < N); i++) {
                 worker_t w[7];
+                KICK_WATCHDOG;
         }
 }

src/tests/preempt_longrun/enter.c

@@ -3 +3 @@
 #include <thread>
 #include <time>
+
+#define __kick_rate 75000ul
+#include "long_tests.h"
 
 #ifndef PREEMPTION_RATE
@@ -15 +18 @@
 
 monitor mon_t {};
-void foo( mon_t & mutex this ) {}
+void foo( mon_t & mutex this ) {
+        KICK_WATCHDOG;
+}
 
 mon_t mon;
 thread worker_t {};
 void main( worker_t & this ) {
-        for( unsigned long i = 0; i < N; i++ ) {
+        for( unsigned long i = 0; TEST(i < N); i++ ) {
                 foo( mon );
         }

src/tests/preempt_longrun/enter3.c

@@ -3 +3 @@
 #include <thread>
 #include <time>
+
+#define __kick_rate 75000ul
+#include "long_tests.h"
 
 #ifndef PREEMPTION_RATE
@@ -18 +21 @@
 mon_t mon1, mon2, mon3;
 
-void foo( mon_t & mutex a, mon_t & mutex b, mon_t & mutex c ) {}
+void foo( mon_t & mutex a, mon_t & mutex b, mon_t & mutex c ) {
+        KICK_WATCHDOG;
+}
 
 thread worker_t {};
 
 void main( worker_t & this ) {
-        for( unsigned long i = 0; i < N; i++ ) {
+        for( unsigned long i = 0; TEST(i < N); i++ ) {
                 foo( mon1, mon2, mon3 );
         }

src/tests/preempt_longrun/processor.c

@@ -4 +4 @@
 
 #include <unistd.h>
+
+#include "long_tests.h"
 
 #ifndef PREEMPTION_RATE
@@ -17 +19 @@
 int main(int argc, char* argv[]) {
         processor * p[15];
-        write(STDOUT_FILENO, "Preparing\n", sizeof("Preparing\n"));
         for ( int pi = 0; pi < 15; pi++ ) {
                 p[pi] = new();
         }
-        write(STDOUT_FILENO, "Starting\n", sizeof("Starting\n"));
-        for ( int i = 0; i < N; i++) {
+        for ( int i = 0; TEST(i < N); i++) {
                 int pi = i % 15;
                 delete( p[pi] );
                 p[pi] = new();
+                KICK_WATCHDOG;
         }
-        write(STDOUT_FILENO, "Stopping\n", sizeof("Stopping\n"));
         for ( int pi = 0; pi < 15; pi++ ) {
                 delete( p[pi] );
         }
-        write(STDOUT_FILENO, "Done\n", sizeof("Done\n"));
 }

src/tests/preempt_longrun/stack.c

@@ -3 +3 @@
 #include <thread>
 #include <time>
+
+#define __kick_rate 5000000ul
+#include "long_tests.h"
 
 #ifndef PREEMPTION_RATE
@@ -15 +18 @@
 
 void main(worker_t & this) {
-        volatile long long p = 5_021_609ul;
-        volatile long long a = 326_417ul;
-        volatile long long n = 1l;
-        for (volatile long long i = 0; i < p; i++) {
-                n *= a;
-                n %= p;
-        }
+        while(TEST(0)) {
+                volatile long long p = 5_021_609ul;
+                volatile long long a = 326_417ul;
+                volatile long long n = 1l;
+                for (volatile long long i = 0; i < p; i++) {
+                        n *= a;
+                        n %= p;
+                        KICK_WATCHDOG;
+                }
 
-        if( n != a ) {
-                abort();
+                if( !TEST(n == a) ) {
+                        abort();
+                }
         }
 }

src/tests/preempt_longrun/yield.c

@@ -2 +2 @@
 #include <thread>
 #include <time>
+
+#define __kick_rate 550000ul
+#include "long_tests.h"
 
 #ifndef PREEMPTION_RATE
@@ -11 +14 @@
 }
 
-#ifdef LONG_TEST
+#ifdef TEST_LONG
 static const unsigned long N = 9_750_000ul;
 #else
@@ -20 +23 @@
 
 void main(worker_t & this) {
-        for(int i = 0; i < N; i++) {
+        for(int i = 0; TEST(i < N); i++) {
                 yield();
+                KICK_WATCHDOG;
         }
 }

tools/Makefile.am

@@ -18 +18 @@
 CFLAGS = -Wall -Wextra -O2 -g
 
-noinst_PROGRAMS = busy catchsig repeat
+noinst_PROGRAMS = busy catchsig repeat watchdog
 
 busy_SOURCES     = busy.c
@@ -24 +24 @@
 catchsig_SOURCES = catchsig.c
 repeat_SOURCES   = repeat.c
+watchdog_SOURCES = watchdog.c

tools/Makefile.in

@@ -92 +92 @@
 build_triplet = @build@
 host_triplet = @host@
-noinst_PROGRAMS = busy$(EXEEXT) catchsig$(EXEEXT) repeat$(EXEEXT)
+noinst_PROGRAMS = busy$(EXEEXT) catchsig$(EXEEXT) repeat$(EXEEXT) \
+        watchdog$(EXEEXT)
 subdir = tools
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
@@ -115 +116 @@
 repeat_OBJECTS = $(am_repeat_OBJECTS)
 repeat_LDADD = $(LDADD)
+am_watchdog_OBJECTS = watchdog.$(OBJEXT)
+watchdog_OBJECTS = $(am_watchdog_OBJECTS)
+watchdog_LDADD = $(LDADD)
 AM_V_P = $(am__v_P_@AM_V@)
 am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
@@ -143 +147 @@
 am__v_CCLD_0 = @echo "  CCLD    " $@;
 am__v_CCLD_1 = 
-SOURCES = $(busy_SOURCES) $(catchsig_SOURCES) $(repeat_SOURCES)
-DIST_SOURCES = $(busy_SOURCES) $(catchsig_SOURCES) $(repeat_SOURCES)
+SOURCES = $(busy_SOURCES) $(catchsig_SOURCES) $(repeat_SOURCES) \
+        $(watchdog_SOURCES)
+DIST_SOURCES = $(busy_SOURCES) $(catchsig_SOURCES) $(repeat_SOURCES) \
+        $(watchdog_SOURCES)
 am__can_run_installinfo = \
   case $$AM_UPDATE_INFO_DIR in \
@@ -295 +301 @@
 catchsig_SOURCES = catchsig.c
 repeat_SOURCES = repeat.c
+watchdog_SOURCES = watchdog.c
 all: all-am
 
@@ -344 +351 @@
         $(AM_V_CCLD)$(LINK) $(repeat_OBJECTS) $(repeat_LDADD) $(LIBS)
 
+watchdog$(EXEEXT): $(watchdog_OBJECTS) $(watchdog_DEPENDENCIES) $(EXTRA_watchdog_DEPENDENCIES) 
+        @rm -f watchdog$(EXEEXT)
+        $(AM_V_CCLD)$(LINK) $(watchdog_OBJECTS) $(watchdog_LDADD) $(LIBS)
+
 mostlyclean-compile:
         -rm -f *.$(OBJEXT)
@@ -353 +364 @@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/catchsig.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/repeat.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/watchdog.Po@am__quote@
 
 .c.o: