Changes in / [8ca3a72:10e90cb]

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (3 diffs)
• CodeTools/TrackLoc.cc (modified) (1 diff)
• Common/Assert.cc (modified) (2 diffs)
• Common/PassVisitor.h (modified) (1 diff)
• Common/PassVisitor.impl.h (modified) (1 diff)
• Common/PassVisitor.proto.h (modified) (5 diffs)
• Concurrency/Keywords.cc (modified) (4 diffs)
• GenPoly/Box.cc (modified) (10 diffs)
• InitTweak/FixGlobalInit.cc (modified) (1 diff)
• InitTweak/FixInit.cc (modified) (1 diff)
• InitTweak/InitTweak.cc (modified) (5 diffs)
• Parser/ParseNode.h (modified) (4 diffs)
• ResolvExpr/CommonType.cc (modified) (5 diffs)
• ResolvExpr/ConversionCost.cc (modified) (8 diffs)
• ResolvExpr/PtrsAssignable.cc (modified) (4 diffs)
• ResolvExpr/PtrsCastable.cc (modified) (2 diffs)
• ResolvExpr/TypeMap.h (modified) (2 diffs)
• ResolvExpr/typeops.h (modified) (1 diff)
• SymTab/ImplementationType.cc (modified) (3 diffs)
• SynTree/Statement.cc (modified) (2 diffs)
• SynTree/Type.h (modified) (1 diff)
• SynTree/Visitor.cc (modified) (3 diffs)
• driver/cc1.cc (modified) (2 diffs)
• driver/cfa.cc (modified) (1 diff)
• libcfa/Makefile.am (modified) (1 diff)
• libcfa/Makefile.in (modified) (13 diffs)
• libcfa/concurrency/alarm.c (modified) (1 diff)
• libcfa/concurrency/alarm.h (added)
• libcfa/concurrency/kernel (modified) (3 diffs)
• libcfa/concurrency/kernel.c (modified) (15 diffs)
• libcfa/concurrency/kernel_private.h (modified) (3 diffs)
• libcfa/concurrency/monitor (modified) (1 diff)
• libcfa/concurrency/monitor.c (modified) (3 diffs)
• libcfa/concurrency/preemption.c (added)
• libcfa/concurrency/preemption.h (added)
• libcfa/concurrency/signal.c (deleted)
• main.cc (modified) (1 diff)
• tests/test.py (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -267 +267 @@
         }
 
-        void CodeGenerator::visit( TraitDecl * traitDecl ) {}
+        void CodeGenerator::visit( __attribute__((unused)) TraitDecl * traitDecl ) {}
 
         void CodeGenerator::visit( TypedefDecl * typeDecl ) {
@@ -328 +328 @@
         }
 
-        void CodeGenerator::visit( ConstructorInit * init ){
+        void CodeGenerator::visit( __attribute__((unused)) ConstructorInit * init ){
                 assertf( ! genC, "ConstructorInit nodes should not reach code generation." );
                 // xxx - generate something reasonable for constructor/destructor pairs
@@ -962 +962 @@
         }
 
-        void CodeGenerator::visit( NullStmt * nullStmt ) {
+        void CodeGenerator::visit( __attribute__((unused)) NullStmt * nullStmt ) {
                 //output << indent << CodeGenerator::printLabels( nullStmt->get_labels() );
                 output << "/* null statement */ ;";

src/CodeTools/TrackLoc.cc

@@ -85 +85 @@
                 }
 
-                void postvisit(BaseSyntaxNode * node) {
+                void postvisit( __attribute__((unused)) BaseSyntaxNode * node ) {
                         parents.pop();
                 }

src/Common/Assert.cc

@@ -21 +21 @@
 extern const char * __progname;                                                 // global name of running executable (argv[0])
 
-#define CFA_ASSERT_FMT "*CFA assertion error* from program \"%s\" in \"%s\" at line %d in file \"%s\""
+#define CFA_ASSERT_FMT "*CFA assertion error* \"%s\" from program \"%s\" in \"%s\" at line %d in file \"%s\""
 
 // called by macro assert in assert.h
 void __assert_fail( const char *assertion, const char *file, unsigned int line, const char *function ) {
-        fprintf( stderr, CFA_ASSERT_FMT ".\n", __progname, function, line, file );
+        fprintf( stderr, CFA_ASSERT_FMT ".\n", assertion, __progname, function, line, file );
         abort();
 }
@@ -31 +31 @@
 // called by macro assertf
 void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) {
-        fprintf( stderr, CFA_ASSERT_FMT ": ", __progname, function, line, file );
+        fprintf( stderr, CFA_ASSERT_FMT ": ", assertion, __progname, function, line, file );
         va_list args;
         va_start( args, fmt );

src/Common/PassVisitor.h

@@ -231 +231 @@
         std::list< Statement* > *       get_beforeStmts() { return stmtsToAddBefore_impl( pass, 0); }
         std::list< Statement* > *       get_afterStmts () { return stmtsToAddAfter_impl ( pass, 0); }
+        bool visit_children() { bool* skip = skip_children_impl(pass, 0); return ! (skip && *skip); }
 };
 

src/Common/PassVisitor.impl.h

@@ -3 +3 @@
 #define VISIT_START( node )  \
         call_previsit( node ); \
-
-#define VISIT_END( node )                \
+        if( visit_children() ) { \
+
+#define VISIT_END( node )            \
+        }                              \
         return call_postvisit( node ); \
 
 #define MUTATE_START( node )  \
         call_premutate( node ); \
+        if( visit_children() ) { \
 
 #define MUTATE_END( type, node )                \
+        }                                         \
         return call_postmutate< type * >( node ); \
 

src/Common/PassVisitor.proto.h

@@ -23 +23 @@
 
 template<typename pass_type, typename node_type>
-static inline void previsit_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) {}
+static inline void previsit_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) node_type * node, __attribute__((unused)) long unused ) {}
 
 
@@ -32 +32 @@
 
 template<typename pass_type, typename node_type>
-static inline void postvisit_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) {}
+static inline void postvisit_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) node_type * node, __attribute__((unused)) long unused ) {}
 
 // Mutate
@@ -41 +41 @@
 
 template<typename pass_type, typename node_type>
-static inline void premutate_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) {}
+static inline void premutate_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) node_type * node, __attribute__((unused)) long unused ) {}
 
 
@@ -71 +71 @@
 
 // Fields
-#define FIELD_PTR( type, name )                                                                                                                  \
-template<typename pass_type>                                                                                                                     \
-static inline auto name##_impl( pass_type& pass, __attribute__((unused)) int unused ) ->decltype( &pass.name ) { return &pass.name; }          \
-                                                                                                                                                 \
-template<typename pass_type>                                                                                                                     \
+#define FIELD_PTR( type, name )                                                                                                        \
+template<typename pass_type>                                                                                                           \
+static inline auto name##_impl( pass_type& pass, __attribute__((unused)) int unused ) ->decltype( &pass.name ) { return &pass.name; }  \
+                                                                                                                                       \
+template<typename pass_type>                                                                                                           \
 static inline type * name##_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) long unused ) { return nullptr;}    \
 
@@ -81 +81 @@
 FIELD_PTR( std::list< Statement* >, stmtsToAddBefore )
 FIELD_PTR( std::list< Statement* >, stmtsToAddAfter  )
+FIELD_PTR( bool, skip_children )

src/Concurrency/Keywords.cc

@@ -65 +65 @@
                 FunctionDecl * forwardDeclare( StructDecl * );
                 ObjectDecl * addField( StructDecl * );
-                void addRoutines( StructDecl *, ObjectDecl *, FunctionDecl * );
+                void addRoutines( ObjectDecl *, FunctionDecl * );
 
                 virtual bool is_target( StructDecl * decl ) = 0;
@@ -247 +247 @@
         void ConcurrentSueKeyword::visit(StructDecl * decl) {
                 Visitor::visit(decl);
-                if( decl->get_name() == type_name ) {
+                if( decl->get_name() == type_name && decl->has_body() ) {
                         assert( !type_decl );
                         type_decl = decl;
@@ -264 +264 @@
                 FunctionDecl * func = forwardDeclare( decl );
                 ObjectDecl * field = addField( decl );
-                addRoutines( decl, field, func );
+                addRoutines( field, func );
         }
 
@@ -359 +359 @@
         }
 
-        void ConcurrentSueKeyword::addRoutines( StructDecl * decl, ObjectDecl * field, FunctionDecl * func ) {
+        void ConcurrentSueKeyword::addRoutines( ObjectDecl * field, FunctionDecl * func ) {
                 CompoundStmt * statement = new CompoundStmt( noLabels );
                 statement->push_back( 

src/GenPoly/Box.cc

@@ -101 +101 @@
                         void passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
                         /// wraps a function application with a new temporary for the out-parameter return value
-                        Expression *addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg );
+                        Expression *addRetParam( ApplicationExpr *appExpr, Type *retType, std::list< Expression *>::iterator &arg );
                         /// Replaces all the type parameters of a generic type with their concrete equivalents under the current environment
                         void replaceParametersWithConcrete( ApplicationExpr *appExpr, std::list< Expression* >& params );
@@ -134 +134 @@
                   public:
                         template< typename DeclClass >
-                        DeclClass *handleDecl( DeclClass *decl, Type *type );
+                        DeclClass *handleDecl( DeclClass *decl );
                         template< typename AggDecl >
                         AggDecl * handleAggDecl( AggDecl * aggDecl );
@@ -663 +663 @@
                 }
 
-                Expression *Pass1::addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg ) {
+                Expression *Pass1::addRetParam( ApplicationExpr *appExpr, Type *retType, std::list< Expression *>::iterator &arg ) {
                         // Create temporary to hold return value of polymorphic function and produce that temporary as a result
                         // using a comma expression.
@@ -730 +730 @@
                         Type *concrete = replaceWithConcrete( appExpr, dynType );
                         // add out-parameter for return value
-                        return addRetParam( appExpr, function, concrete, arg );
+                        return addRetParam( appExpr, concrete, arg );
                 }
 
@@ -737 +737 @@
 //                      if ( ! function->get_returnVals().empty() && isPolyType( function->get_returnVals().front()->get_type(), tyVars ) ) {
                         if ( isDynRet( function, tyVars ) ) {
-                                ret = addRetParam( appExpr, function, function->get_returnVals().front()->get_type(), arg );
+                                ret = addRetParam( appExpr, function->get_returnVals().front()->get_type(), arg );
                         } // if
                         std::string mangleName = mangleAdapterName( function, tyVars );
@@ -1280 +1280 @@
 
                 template< typename DeclClass >
-                DeclClass * Pass2::handleDecl( DeclClass *decl, Type *type ) {
+                DeclClass * Pass2::handleDecl( DeclClass *decl ) {
                         DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) );
 
@@ -1294 +1294 @@
 
                 DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) {
-                        functionDecl = safe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl, functionDecl->get_functionType() ) );
+                        functionDecl = safe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) );
                         FunctionType * ftype = functionDecl->get_functionType();
                         if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) {
@@ -1319 +1319 @@
 
                 ObjectDecl * Pass2::mutate( ObjectDecl *objectDecl ) {
-                        return handleDecl( objectDecl, objectDecl->get_type() );
+                        return handleDecl( objectDecl );
                 }
 
@@ -1342 +1342 @@
                         addToTyVarMap( typeDecl, scopeTyVars );
                         if ( typeDecl->get_base() ) {
-                                return handleDecl( typeDecl, typeDecl->get_base() );
+                                return handleDecl( typeDecl );
                         } else {
                                 return Parent::mutate( typeDecl );
@@ -1349 +1349 @@
 
                 TypedefDecl * Pass2::mutate( TypedefDecl *typedefDecl ) {
-                        return handleDecl( typedefDecl, typedefDecl->get_base() );
+                        return handleDecl( typedefDecl );
                 }
 

src/InitTweak/FixGlobalInit.cc

@@ -125 +125 @@
 
         // only modify global variables
-        void GlobalFixer::visit( FunctionDecl *functionDecl ) {}
-        void GlobalFixer::visit( StructDecl *aggregateDecl ) {}
-        void GlobalFixer::visit( UnionDecl *aggregateDecl ) {}
-        void GlobalFixer::visit( EnumDecl *aggregateDecl ) {}
-        void GlobalFixer::visit( TraitDecl *aggregateDecl ) {}
-        void GlobalFixer::visit( TypeDecl *typeDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) FunctionDecl *functionDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) StructDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) UnionDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) EnumDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) TraitDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) TypeDecl *typeDecl ) {}
 
 } // namespace InitTweak

src/InitTweak/FixInit.cc

@@ -110 +110 @@
 
                         // don't go into other functions
-                        virtual void visit( FunctionDecl *decl ) override {}
+                        virtual void visit( __attribute__((unused)) FunctionDecl *decl ) override {}
 
                   protected:

src/InitTweak/InitTweak.cc

@@ -92 +92 @@
                 InitImpl( Initializer * init ) : init( init ) {}
 
-                virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
+                virtual std::list< Expression * > next( __attribute((unused)) std::list< Expression * > & indices ) {
                         // this is wrong, but just a placeholder for now
                         // if ( ! flattened ) flatten( indices );
@@ -248 +248 @@
         }
 
-        Statement * ExprImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
+        Statement * ExprImpl::buildListInit( __attribute((unused)) UntypedExpr * dst, __attribute((unused)) std::list< Expression * > & indices ) {
                 return NULL;
         }
@@ -475 +475 @@
                 ConstExprChecker() : isConstExpr( true ) {}
 
-                virtual void visit( ApplicationExpr *applicationExpr ) { isConstExpr = false; }
-                virtual void visit( UntypedExpr *untypedExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) ApplicationExpr *applicationExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) UntypedExpr *untypedExpr ) { isConstExpr = false; }
                 virtual void visit( NameExpr *nameExpr ) {
                         // xxx - temporary hack, because 0 and 1 really should be constexprs, even though they technically aren't in Cforall today
@@ -487 +487 @@
                         if ( ! dynamic_cast< NameExpr * >( arg) && ! dynamic_cast< VariableExpr * >( arg ) && ! dynamic_cast< MemberExpr * >( arg ) && ! dynamic_cast< UntypedMemberExpr * >( arg ) ) isConstExpr = false;
                 }
-                virtual void visit( LabelAddressExpr *labAddressExpr ) { isConstExpr = false; }
-                virtual void visit( UntypedMemberExpr *memberExpr ) { isConstExpr = false; }
-                virtual void visit( MemberExpr *memberExpr ) { isConstExpr = false; }
-                virtual void visit( VariableExpr *variableExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) LabelAddressExpr *labAddressExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) UntypedMemberExpr *memberExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) MemberExpr *memberExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) VariableExpr *variableExpr ) { isConstExpr = false; }
                 // these might be okay?
                 // virtual void visit( SizeofExpr *sizeofExpr );
@@ -501 +501 @@
                 // virtual void visit( LogicalExpr *logicalExpr );
                 // virtual void visit( ConditionalExpr *conditionalExpr );
-                virtual void visit( TypeExpr *typeExpr ) { isConstExpr = false; }
-                virtual void visit( AsmExpr *asmExpr ) { isConstExpr = false; }
-                virtual void visit( UntypedValofExpr *valofExpr ) { isConstExpr = false; }
-                virtual void visit( CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; }
-                virtual void visit( UntypedTupleExpr *tupleExpr ) { isConstExpr = false; }
-                virtual void visit( TupleExpr *tupleExpr ) { isConstExpr = false; }
-                virtual void visit( TupleAssignExpr *tupleExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) TypeExpr *typeExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) AsmExpr *asmExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) UntypedValofExpr *valofExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) UntypedTupleExpr *tupleExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) TupleExpr *tupleExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) TupleAssignExpr *tupleExpr ) { isConstExpr = false; }
 
                 bool isConstExpr;

src/Parser/ParseNode.h

@@ -61 +61 @@
         }
 
-        virtual void print( std::ostream &os, int indent = 0 ) const {}
-        virtual void printList( std::ostream &os, int indent = 0 ) const {}
+        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const {}
+        virtual void printList( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const {}
 
         static int indent_by;
@@ -113 +113 @@
         ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
 
-        virtual void print( std::ostream &os, int indent = 0 ) const override {}
-        void printOneLine( std::ostream &os, int indent = 0 ) const {}
+        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {}
+        void printOneLine( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const {}
 
         template<typename T>
@@ -283 +283 @@
         }
 
-        virtual void print( std::ostream &os, int indent = 0 ) const override;
-        virtual void printList( std::ostream &os, int indent = 0 ) const override;
+        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override;
+        virtual void printList( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override;
 
         Declaration * build() const;
@@ -363 +363 @@
         virtual StatementNode * append_last_case( StatementNode * );
 
-        virtual void print( std::ostream &os, int indent = 0 ) const override {}
-        virtual void printList( std::ostream &os, int indent = 0 ) const override {}
+        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {}
+        virtual void printList( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {}
   private:
         std::unique_ptr<Statement> stmt;

src/ResolvExpr/CommonType.cc

@@ -43 +43 @@
 
                 void getCommonWithVoidPointer( PointerType* voidPointer, PointerType* otherPointer );
-                template< typename RefType > void handleRefType( RefType *inst, Type *other );
 
                 Type *result;
@@ -126 +125 @@
         }
 
-        void CommonType::visit( VoidType *voidType ) {
-        }
+        void CommonType::visit( __attribute((unused)) VoidType *voidType ) {}
 
         void CommonType::visit( BasicType *basicType ) {
@@ -189 +187 @@
         }
 
-        void CommonType::visit( ArrayType *arrayType ) {
-        }
-
-        void CommonType::visit( FunctionType *functionType ) {
-        }
-
-        template< typename RefType > void CommonType::handleRefType( RefType *inst, Type *other ) {
-        }
-
-        void CommonType::visit( StructInstType *aggregateUseType ) {
-        }
-
-        void CommonType::visit( UnionInstType *aggregateUseType ) {
-        }
+        void CommonType::visit( __attribute((unused)) ArrayType *arrayType ) {}
+        void CommonType::visit( __attribute((unused)) FunctionType *functionType ) {}
+        void CommonType::visit( __attribute((unused)) StructInstType *aggregateUseType ) {}
+        void CommonType::visit( __attribute((unused)) UnionInstType *aggregateUseType ) {}
 
         void CommonType::visit( EnumInstType *enumInstType ) {
@@ -214 +202 @@
         }
 
-        void CommonType::visit( TraitInstType *aggregateUseType ) {
+        void CommonType::visit( __attribute((unused)) TraitInstType *aggregateUseType ) {
         }
 
@@ -239 +227 @@
         }
 
-        void CommonType::visit( TupleType *tupleType ) {
-        }
-
-        void CommonType::visit( VarArgsType *varArgsType ) {
-        }
+        void CommonType::visit( __attribute((unused)) TupleType *tupleType ) {}
+        void CommonType::visit( __attribute((unused)) VarArgsType *varArgsType ) {}
 
         void CommonType::visit( ZeroType *zeroType ) {

src/ResolvExpr/ConversionCost.cc

@@ -149 +149 @@
         };
 
-        void ConversionCost::visit(VoidType *voidType) {
+        void ConversionCost::visit( __attribute((unused)) VoidType *voidType ) {
                 cost = Cost::infinity;
         }
@@ -186 +186 @@
         }
 
-        void ConversionCost::visit(ArrayType *arrayType) {
-        }
-
-        void ConversionCost::visit(FunctionType *functionType) {
-        }
+        void ConversionCost::visit(__attribute((unused)) ArrayType *arrayType) {}
+        void ConversionCost::visit(__attribute((unused)) FunctionType *functionType) {}
 
         void ConversionCost::visit(StructInstType *inst) {
@@ -208 +205 @@
         }
 
-        void ConversionCost::visit(EnumInstType *inst) {
+        void ConversionCost::visit( __attribute((unused)) EnumInstType *inst ) {
                 static Type::Qualifiers q;
                 static BasicType integer( q, BasicType::SignedInt );
@@ -217 +214 @@
         }
 
-        void ConversionCost::visit(TraitInstType *inst) {
+        void ConversionCost::visit( __attribute((unused)) TraitInstType *inst) {
         }
 
@@ -239 +236 @@
         }
 
-        void ConversionCost::visit(TupleType *tupleType) {
+        void ConversionCost::visit( __attribute((unused)) TupleType *tupleType) {
                 Cost c;
                 if ( TupleType *destAsTuple = dynamic_cast< TupleType* >( dest ) ) {
@@ -259 +256 @@
         }
 
-        void ConversionCost::visit(VarArgsType *varArgsType) {
+        void ConversionCost::visit( __attribute((unused)) VarArgsType *varArgsType) {
                 if ( dynamic_cast< VarArgsType* >( dest ) ) {
                         cost = Cost::zero;
@@ -265 +262 @@
         }
 
-        void ConversionCost::visit(ZeroType *zeroType) {
+        void ConversionCost::visit( __attribute((unused)) ZeroType *zeroType) {
                 if ( dynamic_cast< ZeroType* >( dest ) ) {
                         cost = Cost::zero;
@@ -281 +278 @@
         }
 
-        void ConversionCost::visit(OneType *oneType) {
+        void ConversionCost::visit( __attribute((unused)) OneType *oneType) {
                 if ( dynamic_cast< OneType* >( dest ) ) {
                         cost = Cost::zero;

src/ResolvExpr/PtrsAssignable.cc

@@ -63 +63 @@
         }
 
-        PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {
-        }
+        PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {}
 
-        void PtrsAssignable::visit( VoidType *voidType ) {
+        void PtrsAssignable::visit( __attribute((unused)) VoidType *voidType ) {
                 if ( dynamic_cast< FunctionType* >( dest ) ) {
                         result = 0;
@@ -74 +73 @@
         }
 
-        void PtrsAssignable::visit( BasicType *basicType ) {
-        }
-
-        void PtrsAssignable::visit( PointerType *pointerType ) {
-        }
-
-        void PtrsAssignable::visit( ArrayType *arrayType ) {
-        }
-
-        void PtrsAssignable::visit( FunctionType *functionType ) {
+        void PtrsAssignable::visit( __attribute__((unused)) BasicType *basicType ) {}
+        void PtrsAssignable::visit( __attribute__((unused)) PointerType *pointerType ) {}
+        void PtrsAssignable::visit( __attribute__((unused)) ArrayType *arrayType ) {}
+        void PtrsAssignable::visit( __attribute__((unused)) FunctionType *functionType ) {
                 result = -1;
         }
 
-        void PtrsAssignable::visit( StructInstType *inst ) {
-                // I don't think we should be doing anything here, but I'm willing to admit that I might be wrong
-        }
-
-        void PtrsAssignable::visit( UnionInstType *inst ) {
-                // I don't think we should be doing anything here, but I'm willing to admit that I might be wrong
-        }
+        void PtrsAssignable::visit(  __attribute__((unused)) StructInstType *inst ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) UnionInstType *inst ) {}
 
         void PtrsAssignable::visit( EnumInstType *inst ) {
@@ -103 +91 @@
         }
 
-        void PtrsAssignable::visit( TraitInstType *inst ) {
-                // I definitely don't think we should be doing anything here
-        }
-
+        void PtrsAssignable::visit(  __attribute__((unused)) TraitInstType *inst ) {}
         void PtrsAssignable::visit( TypeInstType *inst ) {
                 EqvClass eqvClass;
@@ -116 +101 @@
         }
 
-        void PtrsAssignable::visit( TupleType *tupleType ) {
-///  // This code doesn't belong here, but it might be useful somewhere else
-///   if ( TupleType *destAsTuple = dynamic_cast< TupleType* >( dest ) ) {
-///     int ret = 0;
-///     std::list< Type* >::const_iterator srcIt = tupleType->get_types().begin();
-///     std::list< Type* >::const_iterator destIt = destAsTuple->get_types().begin();
-///     while ( srcIt != tupleType->get_types().end() && destIt != destAsTuple->get_types().end() ) {
-///       int assignResult = ptrsAssignable( *srcIt++, *destIt++ );
-///       if ( assignResult == 0 ) {
-///         result = assignResult;
-///         return;
-///       } else if ( assignResult < 0 ) {
-///         ret = -1;
-///       } else if ( ret > 0 ) {
-///         ret += assignResult;
-///       }
-///     }
-///     if ( srcIt == tupleType->get_types().end() && destIt == destAsTuple->get_types().end() ) {
-///       result = ret;
-///     } else {
-///       result = 0;
-///     }
-///   }
-        }
-
-        void PtrsAssignable::visit( VarArgsType *varArgsType ) {
-        }
-
-        void PtrsAssignable::visit( ZeroType *zeroType ) {
-        }
-        
-        void PtrsAssignable::visit( OneType *oneType ) {
-        }
+        void PtrsAssignable::visit(  __attribute__((unused)) TupleType *tupleType ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) VarArgsType *varArgsType ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) ZeroType *zeroType ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) OneType *oneType ) {}
         
 } // namespace ResolvExpr

src/ResolvExpr/PtrsCastable.cc

@@ -92 +92 @@
         }
 
-        void PtrsCastable::visit(VoidType *voidType) {
+        void PtrsCastable::visit( __attribute__((unused)) VoidType *voidType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(BasicType *basicType) {
+        void PtrsCastable::visit( __attribute__((unused)) BasicType *basicType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(PointerType *pointerType) {
+        void PtrsCastable::visit( __attribute__((unused)) PointerType *pointerType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(ArrayType *arrayType) {
+        void PtrsCastable::visit( __attribute__((unused)) ArrayType *arrayType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(FunctionType *functionType) {
+        void PtrsCastable::visit( __attribute__((unused)) FunctionType *functionType) {
                 // result = -1;
                 result = functionCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(StructInstType *inst) {
+        void PtrsCastable::visit( __attribute__((unused)) StructInstType *inst) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(UnionInstType *inst) {
+        void PtrsCastable::visit( __attribute__((unused)) UnionInstType *inst) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(EnumInstType *inst) {
+        void PtrsCastable::visit( __attribute__((unused)) EnumInstType *inst) {
                 if ( dynamic_cast< EnumInstType* >( dest ) ) {
                         result = 1;
@@ -144 +144 @@
         }
 
-        void PtrsCastable::visit(TupleType *tupleType) {
+        void PtrsCastable::visit( __attribute__((unused)) TupleType *tupleType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(VarArgsType *varArgsType) {
+        void PtrsCastable::visit( __attribute__((unused)) VarArgsType *varArgsType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(ZeroType *zeroType) {
+        void PtrsCastable::visit( __attribute__((unused)) ZeroType *zeroType) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit(OneType *oneType) {
+        void PtrsCastable::visit( __attribute__((unused)) OneType *oneType) {
                 result = objectCast( dest, env, indexer );
         }

src/ResolvExpr/TypeMap.h

@@ -110 +110 @@
                         }
 
-                        virtual void visit( VoidType *voidType ) {
+                        virtual void visit( __attribute__((unused)) VoidType *voidType ) {
                                 findAndReplace( typeMap.voidValue );
                         }
@@ -138 +138 @@
                         }
 
-                        virtual void visit( FunctionType *functionType ) {
+                        virtual void visit( __attribute__((unused)) FunctionType *functionType ) {
                                 findAndReplace( typeMap.functionPointerValue );
                         }

src/ResolvExpr/typeops.h

@@ -132 +132 @@
         }
 
-        template< typename Container1, typename Container2 >
-        bool typesCompatibleList( Container1 &c1, Container2 &c2, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
-                typename Container1::iterator i1 = c1.begin();
-                typename Container2::iterator i2 = c2.begin();
-                for ( ; i1 != c1.end() && i2 != c2.end(); ++i1, ++i2 ) {
-                        if ( ! typesCompatible( *i1, *i2, indexer ) ) {
-                                return false;
-                        } // if
-                }
-                return ( i1 == c1.end() ) && ( i2 == c2.end() );
-        }
-
         /// creates the type represented by the list of returnVals in a FunctionType. The caller owns the return value.
         Type * extractResultType( FunctionType * functionType );

src/SymTab/ImplementationType.cc

@@ -61 +61 @@
         }
 
-        void ImplementationType::visit(VoidType *voidType) {
-        }
-
-        void ImplementationType::visit(BasicType *basicType) {
-        }
+        void ImplementationType::visit( __attribute__((unused)) VoidType *voidType ) {}
+        void ImplementationType::visit( __attribute__((unused)) BasicType *basicType ) {}
 
         void ImplementationType::visit(PointerType *pointerType) {
@@ -89 +86 @@
         }
 
-        void ImplementationType::visit(StructInstType *aggregateUseType) {
-        }
-
-        void ImplementationType::visit(UnionInstType *aggregateUseType) {
-        }
-
-        void ImplementationType::visit(EnumInstType *aggregateUseType) {
-        }
-
-        void ImplementationType::visit(TraitInstType *aggregateUseType) {
-        }
+        void ImplementationType::visit( __attribute__((unused)) StructInstType * aggregateUseType ) {}
+        void ImplementationType::visit( __attribute__((unused)) UnionInstType * aggregateUseType ) {}
+        void ImplementationType::visit( __attribute__((unused)) EnumInstType * aggregateUseType ) {}
+        void ImplementationType::visit( __attribute__((unused)) TraitInstType * aggregateUseType ) {}
 
         void ImplementationType::visit(TypeInstType *inst) {
@@ -120 +110 @@
         }
 
-        void ImplementationType::visit(VarArgsType *varArgsType) {
-        }
-
-        void ImplementationType::visit(ZeroType *zeroType) {
-        }
-
-        void ImplementationType::visit(OneType *oneType) {
-        }
+        void ImplementationType::visit( __attribute__((unused)) VarArgsType *varArgsType ) {}
+        void ImplementationType::visit( __attribute__((unused)) ZeroType *zeroType ) {}
+        void ImplementationType::visit( __attribute__((unused)) OneType *oneType ) {}
 } // namespace SymTab
 

src/SynTree/Statement.cc

@@ -30 +30 @@
 Statement::Statement( std::list<Label> _labels ) : labels( _labels ) {}
 
-void Statement::print( std::ostream &, int indent ) const {}
+void Statement::print( __attribute__((unused)) std::ostream &, __attribute__((unused)) int indent ) const {}
 
 Statement::~Statement() {}
@@ -365 +365 @@
 NullStmt::NullStmt() : CompoundStmt( std::list<Label>() ) {}
 
-void NullStmt::print( std::ostream &os, int indent ) const {
+void NullStmt::print( std::ostream &os, __attribute__((unused)) int indent ) const {
         os << "Null Statement" << endl ;
 }

src/SynTree/Type.h

@@ -334 +334 @@
         virtual void print( std::ostream & os, int indent = 0 ) const;
 
-        virtual void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const {}
+        virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
   protected:
         virtual std::string typeString() const = 0;

src/SynTree/Visitor.cc

@@ -122 +122 @@
 }
 
-void Visitor::visit( BranchStmt *branchStmt ) {
+void Visitor::visit( __attribute__((unused)) BranchStmt *branchStmt ) {
 }
 
@@ -143 +143 @@
 }
 
-void Visitor::visit( NullStmt *nullStmt ) {
+void Visitor::visit( __attribute__((unused)) NullStmt *nullStmt ) {
 }
 
@@ -445 +445 @@
 
 
-void Visitor::visit( Subrange *subrange ) {}
-
-
-void Visitor::visit( Constant *constant ) {}
+void Visitor::visit( __attribute__((unused)) Subrange *subrange ) {}
+
+
+void Visitor::visit( __attribute__((unused)) Constant *constant ) {}
 // Local Variables: //
 // tab-width: 4 //

src/driver/cc1.cc

@@ -84 +84 @@
 
 
-void sigTermHandler( int signal ) {
+void sigTermHandler( __attribute__((unused)) int signal ) {
         if ( tmpfilefd != -1 ) {                                                        // RACE, file created ?
                 rmtmpfile();                                                                    // remove
@@ -469 +469 @@
 
 
-int main( const int argc, const char * const argv[], const char * const env[] ) {
+int main( const int argc, const char * const argv[], __attribute__((unused)) const char * const env[] ) {
 #ifdef __DEBUG_H__
         for ( int i = 0; env[i] != NULL; i += 1 ) {

src/driver/cfa.cc

@@ -271 +271 @@
                 args[nargs] = "-ldl";
                 nargs += 1;
+                args[nargs] = "-lrt";
+                nargs += 1;
                 args[nargs] = "-Xlinker";
                 nargs += 1;

src/libcfa/Makefile.am

@@ -54 +54 @@
 # not all platforms support concurrency, add option do disable it
 if BUILD_CONCURRENCY
-libsrc += concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c concurrency/invoke.c concurrency/signal.c
+libsrc += concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c concurrency/invoke.c concurrency/preemption.c
 endif
 

src/libcfa/Makefile.in

@@ -46 +46 @@
 
 # not all platforms support concurrency, add option do disable it
-@BUILD_CONCURRENCY_TRUE@am__append_4 = concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c concurrency/invoke.c concurrency/signal.c
+@BUILD_CONCURRENCY_TRUE@am__append_4 = concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c concurrency/invoke.c concurrency/preemption.c
 subdir = src/libcfa
 DIST_COMMON = $(am__nobase_cfa_include_HEADERS_DIST) \
@@ -104 +104 @@
         concurrency/kernel.c concurrency/monitor.c \
         concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \
-        concurrency/invoke.c concurrency/signal.c
+        concurrency/invoke.c concurrency/preemption.c
 am__dirstamp = $(am__leading_dot)dirstamp
 @BUILD_CONCURRENCY_TRUE@am__objects_1 = concurrency/libcfa_d_a-coroutine.$(OBJEXT) \
@@ -122 +122 @@
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-alarm.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-invoke.$(OBJEXT) \
-@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-signal.$(OBJEXT)
+@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-preemption.$(OBJEXT)
 am__objects_4 = libcfa_d_a-libcfa-prelude.$(OBJEXT) \
         libcfa_d_a-interpose.$(OBJEXT) \
@@ -138 +138 @@
         concurrency/kernel.c concurrency/monitor.c \
         concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \
-        concurrency/invoke.c concurrency/signal.c
+        concurrency/invoke.c concurrency/preemption.c
 @BUILD_CONCURRENCY_TRUE@am__objects_5 = concurrency/libcfa_a-coroutine.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-thread.$(OBJEXT) \
@@ -154 +154 @@
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-alarm.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-invoke.$(OBJEXT) \
-@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-signal.$(OBJEXT)
+@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-preemption.$(OBJEXT)
 am__objects_8 = libcfa_a-libcfa-prelude.$(OBJEXT) \
         libcfa_a-interpose.$(OBJEXT) \
@@ -445 +445 @@
 concurrency/libcfa_d_a-invoke.$(OBJEXT): concurrency/$(am__dirstamp) \
         concurrency/$(DEPDIR)/$(am__dirstamp)
-concurrency/libcfa_d_a-signal.$(OBJEXT): concurrency/$(am__dirstamp) \
+concurrency/libcfa_d_a-preemption.$(OBJEXT):  \
+        concurrency/$(am__dirstamp) \
         concurrency/$(DEPDIR)/$(am__dirstamp)
 libcfa-d.a: $(libcfa_d_a_OBJECTS) $(libcfa_d_a_DEPENDENCIES) $(EXTRA_libcfa_d_a_DEPENDENCIES) 
@@ -473 +474 @@
 concurrency/libcfa_a-invoke.$(OBJEXT): concurrency/$(am__dirstamp) \
         concurrency/$(DEPDIR)/$(am__dirstamp)
-concurrency/libcfa_a-signal.$(OBJEXT): concurrency/$(am__dirstamp) \
+concurrency/libcfa_a-preemption.$(OBJEXT):  \
+        concurrency/$(am__dirstamp) \
         concurrency/$(DEPDIR)/$(am__dirstamp)
 libcfa.a: $(libcfa_a_OBJECTS) $(libcfa_a_DEPENDENCIES) $(EXTRA_libcfa_a_DEPENDENCIES) 
@@ -488 +490 @@
         -rm -f concurrency/libcfa_a-kernel.$(OBJEXT)
         -rm -f concurrency/libcfa_a-monitor.$(OBJEXT)
-        -rm -f concurrency/libcfa_a-signal.$(OBJEXT)
+        -rm -f concurrency/libcfa_a-preemption.$(OBJEXT)
         -rm -f concurrency/libcfa_a-thread.$(OBJEXT)
         -rm -f concurrency/libcfa_d_a-alarm.$(OBJEXT)
@@ -495 +497 @@
         -rm -f concurrency/libcfa_d_a-kernel.$(OBJEXT)
         -rm -f concurrency/libcfa_d_a-monitor.$(OBJEXT)
-        -rm -f concurrency/libcfa_d_a-signal.$(OBJEXT)
+        -rm -f concurrency/libcfa_d_a-preemption.$(OBJEXT)
         -rm -f concurrency/libcfa_d_a-thread.$(OBJEXT)
         -rm -f containers/libcfa_a-maybe.$(OBJEXT)
@@ -537 +539 @@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-kernel.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-monitor.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-signal.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-preemption.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-thread.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-alarm.Po@am__quote@
@@ -544 +546 @@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-kernel.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-monitor.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-signal.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-preemption.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-thread.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_a-maybe.Po@am__quote@
@@ -869 +871 @@
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-invoke.obj `if test -f 'concurrency/invoke.c'; then $(CYGPATH_W) 'concurrency/invoke.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/invoke.c'; fi`
 
-concurrency/libcfa_d_a-signal.o: concurrency/signal.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-signal.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-signal.Tpo -c -o concurrency/libcfa_d_a-signal.o `test -f 'concurrency/signal.c' || echo '$(srcdir)/'`concurrency/signal.c
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-signal.Tpo concurrency/$(DEPDIR)/libcfa_d_a-signal.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/signal.c' object='concurrency/libcfa_d_a-signal.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-signal.o `test -f 'concurrency/signal.c' || echo '$(srcdir)/'`concurrency/signal.c
-
-concurrency/libcfa_d_a-signal.obj: concurrency/signal.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-signal.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-signal.Tpo -c -o concurrency/libcfa_d_a-signal.obj `if test -f 'concurrency/signal.c'; then $(CYGPATH_W) 'concurrency/signal.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/signal.c'; fi`
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-signal.Tpo concurrency/$(DEPDIR)/libcfa_d_a-signal.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/signal.c' object='concurrency/libcfa_d_a-signal.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-signal.obj `if test -f 'concurrency/signal.c'; then $(CYGPATH_W) 'concurrency/signal.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/signal.c'; fi`
+concurrency/libcfa_d_a-preemption.o: concurrency/preemption.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-preemption.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-preemption.Tpo -c -o concurrency/libcfa_d_a-preemption.o `test -f 'concurrency/preemption.c' || echo '$(srcdir)/'`concurrency/preemption.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-preemption.Tpo concurrency/$(DEPDIR)/libcfa_d_a-preemption.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/preemption.c' object='concurrency/libcfa_d_a-preemption.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-preemption.o `test -f 'concurrency/preemption.c' || echo '$(srcdir)/'`concurrency/preemption.c
+
+concurrency/libcfa_d_a-preemption.obj: concurrency/preemption.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-preemption.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-preemption.Tpo -c -o concurrency/libcfa_d_a-preemption.obj `if test -f 'concurrency/preemption.c'; then $(CYGPATH_W) 'concurrency/preemption.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/preemption.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-preemption.Tpo concurrency/$(DEPDIR)/libcfa_d_a-preemption.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/preemption.c' object='concurrency/libcfa_d_a-preemption.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-preemption.obj `if test -f 'concurrency/preemption.c'; then $(CYGPATH_W) 'concurrency/preemption.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/preemption.c'; fi`
 
 libcfa_a-libcfa-prelude.obj: libcfa-prelude.c
@@ -1163 +1165 @@
 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-invoke.obj `if test -f 'concurrency/invoke.c'; then $(CYGPATH_W) 'concurrency/invoke.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/invoke.c'; fi`
 
-concurrency/libcfa_a-signal.o: concurrency/signal.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-signal.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-signal.Tpo -c -o concurrency/libcfa_a-signal.o `test -f 'concurrency/signal.c' || echo '$(srcdir)/'`concurrency/signal.c
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-signal.Tpo concurrency/$(DEPDIR)/libcfa_a-signal.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/signal.c' object='concurrency/libcfa_a-signal.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-signal.o `test -f 'concurrency/signal.c' || echo '$(srcdir)/'`concurrency/signal.c
-
-concurrency/libcfa_a-signal.obj: concurrency/signal.c
-@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-signal.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-signal.Tpo -c -o concurrency/libcfa_a-signal.obj `if test -f 'concurrency/signal.c'; then $(CYGPATH_W) 'concurrency/signal.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/signal.c'; fi`
-@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-signal.Tpo concurrency/$(DEPDIR)/libcfa_a-signal.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/signal.c' object='concurrency/libcfa_a-signal.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-signal.obj `if test -f 'concurrency/signal.c'; then $(CYGPATH_W) 'concurrency/signal.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/signal.c'; fi`
+concurrency/libcfa_a-preemption.o: concurrency/preemption.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-preemption.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-preemption.Tpo -c -o concurrency/libcfa_a-preemption.o `test -f 'concurrency/preemption.c' || echo '$(srcdir)/'`concurrency/preemption.c
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-preemption.Tpo concurrency/$(DEPDIR)/libcfa_a-preemption.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/preemption.c' object='concurrency/libcfa_a-preemption.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-preemption.o `test -f 'concurrency/preemption.c' || echo '$(srcdir)/'`concurrency/preemption.c
+
+concurrency/libcfa_a-preemption.obj: concurrency/preemption.c
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-preemption.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-preemption.Tpo -c -o concurrency/libcfa_a-preemption.obj `if test -f 'concurrency/preemption.c'; then $(CYGPATH_W) 'concurrency/preemption.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/preemption.c'; fi`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-preemption.Tpo concurrency/$(DEPDIR)/libcfa_a-preemption.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='concurrency/preemption.c' object='concurrency/libcfa_a-preemption.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-preemption.obj `if test -f 'concurrency/preemption.c'; then $(CYGPATH_W) 'concurrency/preemption.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/preemption.c'; fi`
 install-nobase_cfa_includeHEADERS: $(nobase_cfa_include_HEADERS)
         @$(NORMAL_INSTALL)

src/libcfa/concurrency/alarm.c

@@ +1 @@
+//                              -*- Mode: CFA -*-
+//
+// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// alarm.c --
+//
+// Author           : Thierry Delisle
+// Created On       : Fri Jun 2 11:31:25 2017
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
+//
+
+extern "C" {
+#include <time.h>
+#include <sys/time.h>
+}
+
+#include "alarm.h"
+#include "kernel_private.h"
+#include "preemption.h"
+
+//=============================================================================================
+// Clock logic
+//=============================================================================================
+
+__cfa_time_t __kernel_get_time() {
+        timespec curr;
+        clock_gettime( CLOCK_REALTIME, &curr );
+        return ((__cfa_time_t)curr.tv_sec * TIMEGRAN) + curr.tv_nsec;
+}
+
+void __kernel_set_timer( __cfa_time_t alarm ) {
+        itimerval val;
+        val.it_value.tv_sec = alarm / TIMEGRAN;                 // seconds
+        val.it_value.tv_usec = (alarm % TIMEGRAN) / ( TIMEGRAN / 1_000_000L ); // microseconds
+        val.it_interval.tv_sec = 0;
+        val.it_interval.tv_usec = 0;
+        setitimer( ITIMER_REAL, &val, NULL );
+}
+
+//=============================================================================================
+// Alarm logic
+//=============================================================================================
+
+void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = 0, __cfa_time_t period = 0 ) {
+        this->thrd = thrd;
+        this->alarm = alarm;
+        this->period = period;
+        this->next = 0;
+        this->set = false;
+        this->kernel_alarm = false;
+}
+
+void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = 0, __cfa_time_t period = 0 ) {
+        this->proc = proc;
+        this->alarm = alarm;
+        this->period = period;
+        this->next = 0;
+        this->set = false;
+        this->kernel_alarm = true;
+}
+
+void ^?{}( alarm_node_t * this ) {
+        if( this->set ) {
+                unregister_self( this );
+        }
+}
+
+static inline void insert_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t p ) {
+        assert( !n->next );
+        if( p == this->tail ) {
+                this->tail = &n->next;
+        }
+        else {
+                n->next = *p;
+        }
+        *p = n;
+}
+
+void insert( alarm_list_t * this, alarm_node_t * n ) {
+        alarm_node_t ** it = &this->head;
+        while( (*it) && (n->alarm > (*it)->alarm) ) {
+                it = &(*it)->next;
+        }
+
+        insert_at( this, n, it );
+}
+
+alarm_node_t * pop( alarm_list_t * this ) {
+        alarm_node_t * head = this->head;
+        if( head ) {
+                this->head = head->next;
+                if( !head->next ) {
+                        this->tail = &this->head;
+                }
+                head->next = NULL;
+        }
+        return head;
+}
+
+static inline void remove_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t it ) {
+        assert( it );
+        assert( (*it)->next == n );
+
+        (*it)->next = n->next;
+        if( !n-> next ) {
+                this->tail = it;
+        }
+        n->next = NULL;
+}
+
+static inline void remove( alarm_list_t * this, alarm_node_t * n ) {
+        alarm_node_t ** it = &this->head;
+        while( (*it) && (*it)->next != n ) {
+                it = &(*it)->next;
+        }
+
+        if( *it ) { remove_at( this, n, it ); }
+}
+
+void register_self( alarm_node_t * this ) {
+        disable_interrupts();
+        assert( !systemProcessor->pending_alarm );
+        lock( &systemProcessor->alarm_lock );
+        {
+                insert( &systemProcessor->alarms, this );
+                if( systemProcessor->pending_alarm ) {
+                        tick_preemption();
+                }
+        }
+        unlock( &systemProcessor->alarm_lock );
+        this->set = true;
+        enable_interrupts();
+}
+
+void unregister_self( alarm_node_t * this ) {
+        disable_interrupts();
+        lock( &systemProcessor->alarm_lock );
+        remove( &systemProcessor->alarms, this );
+        unlock( &systemProcessor->alarm_lock );
+        disable_interrupts();
+        this->set = false;
+}

src/libcfa/concurrency/kernel

@@ -28 +28 @@
 //-----------------------------------------------------------------------------
 // Locks
+bool try_lock( spinlock * );
 void lock( spinlock * );
 void unlock( spinlock * );
@@ -85 +86 @@
 
         struct FinishAction finish;
+
+        struct alarm_node_t * preemption_alarm;
+        unsigned int preemption;
+
+        unsigned short disable_preempt_count;
+
+        bool pending_preemption;
 };
 
@@ -94 +102 @@
 
 // Local Variables: //
-// mode: c //
-// tab-width: 4 //
+// mode: CFA //
+// tab-width: 6 //
 // End: //

src/libcfa/concurrency/kernel.c

@@ -36 +36 @@
 //CFA Includes
 #include "libhdr.h"
+#include "preemption.h"
 
 //Private includes
@@ -47 +48 @@
 KERNEL_STORAGE(processorCtx_t, systemProcessorCtx);
 KERNEL_STORAGE(cluster, systemCluster);
-KERNEL_STORAGE(processor, systemProcessor);
+KERNEL_STORAGE(system_proc_t, systemProcessor);
 KERNEL_STORAGE(thread_desc, mainThread);
 KERNEL_STORAGE(machine_context_t, mainThread_context);
 
 cluster * systemCluster;
-processor * systemProcessor;
+system_proc_t * systemProcessor;
 thread_desc * mainThread;
 
@@ -118 +119 @@
 // Processor coroutine
 void ?{}(processorCtx_t * this, processor * proc) {
-        (&this->__cor){};
+        (&this->__cor){ "Processor" };
         this->proc = proc;
         proc->runner = this;
@@ -139 +140 @@
         (&this->terminated){};
         this->is_terminated = false;
+        this->preemption_alarm = NULL;
+        this->preemption = default_preemption();
+        this->disable_preempt_count = 1;                //Start with interrupts disabled
+        this->pending_preemption = false;
 
         start( this );
@@ -149 +154 @@
         (&this->terminated){};
         this->is_terminated = false;
+        this->disable_preempt_count = 0;
+        this->pending_preemption = false;
 
         this->runner = runner;
         LIB_DEBUG_PRINT_SAFE("Kernel : constructing processor context %p\n", runner);
         runner{ this };
+}
+
+void ?{}(system_proc_t * this, cluster * cltr, processorCtx_t * runner) {
+        (&this->alarms){};
+        (&this->alarm_lock){};
+        this->pending_alarm = false;
+
+        (&this->proc){ cltr, runner };
 }
 
@@ -178 +193 @@
 void main(processorCtx_t * runner) {
         processor * this = runner->proc;
+
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this);
 
-        thread_desc * readyThread = NULL;
-        for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ ) 
         {
-                readyThread = nextThread( this->cltr );
-
-                if(readyThread) 
+                // Setup preemption data
+                preemption_scope scope = { this };
+
+                LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);
+
+                thread_desc * readyThread = NULL;
+                for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ ) 
                 {
-                        runThread(this, readyThread);
-
-                        //Some actions need to be taken from the kernel
-                        finishRunning(this);
-
-                        spin_count = 0;
-                } 
-                else 
-                {
-                        spin(this, &spin_count);
-                }               
-        }
-
-        LIB_DEBUG_PRINT_SAFE("Kernel : core %p unlocking thread\n", this);
+                        readyThread = nextThread( this->cltr );
+
+                        if(readyThread)
+                        {
+                                runThread(this, readyThread);
+
+                                //Some actions need to be taken from the kernel
+                                finishRunning(this);
+
+                                spin_count = 0;
+                        }
+                        else
+                        {
+                                spin(this, &spin_count);
+                        }
+                }
+
+                LIB_DEBUG_PRINT_SAFE("Kernel : core %p stopping\n", this);
+        }
+
         signal( &this->terminated );
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this);
@@ -299 +323 @@
         LIB_DEBUG_PRINT_SAFE("Kernel : Starting core %p\n", this);
         
-        // pthread_attr_t attributes;
-        // pthread_attr_init( &attributes );
-
         pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
-
-        // pthread_attr_destroy( &attributes );
 
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);       
@@ -316 +335 @@
         assertf( thrd->next == NULL, "Expected null got %p", thrd->next );
         
-        lock( &systemProcessor->cltr->lock );
-        append( &systemProcessor->cltr->ready_queue, thrd );
-        unlock( &systemProcessor->cltr->lock );
+        lock( &systemProcessor->proc.cltr->lock );
+        append( &systemProcessor->proc.cltr->ready_queue, thrd );
+        unlock( &systemProcessor->proc.cltr->lock );
 }
 
@@ -367 +386 @@
 }
 
+//=============================================================================================
+// Kernel Setup logic
+//=============================================================================================
 //-----------------------------------------------------------------------------
 // Kernel boot procedures
@@ -379 +401 @@
         mainThread{ &info };
 
+        LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
+
+        // Enable preemption
+        kernel_start_preemption();
+
         // Initialize the system cluster
         systemCluster = (cluster *)&systemCluster_storage;
         systemCluster{};
 
+        LIB_DEBUG_PRINT_SAFE("Kernel : System cluster ready\n");
+
         // Initialize the system processor and the system processor ctx
         // (the coroutine that contains the processing control flow)
-        systemProcessor = (processor *)&systemProcessor_storage;
+        systemProcessor = (system_proc_t *)&systemProcessor_storage;
         systemProcessor{ systemCluster, (processorCtx_t *)&systemProcessorCtx_storage };
 
         // Add the main thread to the ready queue 
-        // once resume is called on systemProcessor->ctx the mainThread needs to be scheduled like any normal thread
+        // once resume is called on systemProcessor->runner the mainThread needs to be scheduled like any normal thread
         ScheduleThread(mainThread);
 
         //initialize the global state variables
-        this_processor = systemProcessor;
+        this_processor = &systemProcessor->proc;
         this_processor->current_thread = mainThread;
         this_processor->current_coroutine = &mainThread->cor;
@@ -400 +429 @@
         // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
         // mainThread is on the ready queue when this call is made. 
-        resume(systemProcessor->runner);
+        resume( systemProcessor->proc.runner );
 
 
@@ -414 +443 @@
         // When its coroutine terminates, it return control to the mainThread
         // which is currently here
-        systemProcessor->is_terminated = true;
+        systemProcessor->proc.is_terminated = true;
         suspend();
 
@@ -421 +450 @@
         // Destroy the system processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
-        ^(systemProcessor->runner){};
+        ^(systemProcessor->proc.runner){};
         ^(systemProcessor){};
 
@@ -484 +513 @@
 }
 
+//=============================================================================================
+// Kernel Utilities
+//=============================================================================================
 //-----------------------------------------------------------------------------
 // Locks
@@ -491 +523 @@
 void ^?{}( spinlock * this ) {
 
+}
+
+bool try_lock( spinlock * this ) {
+        return this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0;
 }
 

src/libcfa/concurrency/kernel_private.h

@@ -21 +21 @@
 #include "thread"
 
+#include "alarm.h"
+
 //-----------------------------------------------------------------------------
 // Scheduler
@@ -35 +37 @@
 //-----------------------------------------------------------------------------
 // Processor
-struct processorCtx_t {
+coroutine processorCtx_t {
         processor * proc;
-        coroutine_desc __cor;
 };
-
-DECL_COROUTINE(processorCtx_t);
 
 void main(processorCtx_t *);
@@ -47 +46 @@
 void finishRunning(processor * this);
 void spin(processor * this, unsigned int * spin_count);
+
+struct system_proc_t {
+        processor proc;
+
+        alarm_list_t alarms;
+        spinlock alarm_lock;
+
+        bool pending_alarm;
+};
+
+extern cluster * systemCluster;
+extern system_proc_t * systemProcessor;
+extern thread_local processor * this_processor;
+
+static inline void disable_interrupts() {
+        __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, 1, __ATOMIC_SEQ_CST );
+        assert( prev != (unsigned short) -1 );
+}
+
+static inline void enable_interrupts_noRF() {
+        unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, -1, __ATOMIC_SEQ_CST );
+        assert( prev != (unsigned short) 0 );
+}
+
+static inline void enable_interrupts() {
+        unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, -1, __ATOMIC_SEQ_CST );
+        assert( prev != (unsigned short) 0 );
+        if( prev == 1 && this_processor->pending_preemption ) {
+                ScheduleInternal( this_processor->current_thread );
+                this_processor->pending_preemption = false;
+        }
+}
 
 //-----------------------------------------------------------------------------

src/libcfa/concurrency/monitor

@@ -92 +92 @@
 uintptr_t front( condition * this );
 
+struct __acceptable_t {
+        void (*func)(void);
+        unsigned short count;
+        monitor_desc * monitors[1];
+};
+
+void __accept_internal( unsigned short count, __acceptable_t * acceptables, void (*func)(void) );
+
 #endif //MONITOR_H

src/libcfa/concurrency/monitor.c

@@ -212 +212 @@
         ScheduleInternal( locks, count, threads, thread_count );
 
+
         //WE WOKE UP
 
@@ -312 +313 @@
         ScheduleInternal( locks, count, &signallee, 1 );
 
+
+
+
         LIB_DEBUG_PRINT_SAFE( "Back from signal block\n" );
 
@@ -330 +334 @@
         );
         return this->blocked.head->user_info;
+}
+
+//-----------------------------------------------------------------------------
+// Internal scheduling
+void __accept_internal( unsigned short count, __acceptable_t * acceptables, void (*func)(void) ) {
+        // thread_desc * this = this_thread();
+
+        // unsigned short count = this->current_monitor_count;
+        // unsigned int recursions[ count ];            //Save the current recursion levels to restore them later
+        // spinlock *   locks     [ count ];            //We need to pass-in an array of locks to ScheduleInternal
+
+        // lock_all( this->current_monitors, locks, count );
+
+
+
+
+
+        // // // Everything is ready to go to sleep
+        // // ScheduleInternal( locks, count, threads, thread_count );
+
+
+        // //WE WOKE UP
+
+
+        // //We are back, restore the owners and recursions
+        // lock_all( locks, count );
+        // restore_recursion( this->monitors, recursions, count );
+        // unlock_all( locks, count );
 }
 

src/main.cc

@@ -146 +146 @@
 } // sigSegvBusHandler
 
-void sigAbortHandler( int sig_num ) {
+void sigAbortHandler( __attribute__((unused)) int sig_num ) {
         backtrace( 6 );                                                                         // skip first 6 stack frames
         signal( SIGABRT, SIG_DFL);                                                      // reset default signal handler

src/tests/test.py

@@ -197 +197 @@
                         # fetch return code and error from the diff command
                         retcode, error = diff(".expect/%s.txt" % test.path, ".out/%s.log" % test.name, dry_run)
+
+        else:
+                with open (out_file, "r") as myfile:
+                        error = myfile.read()
+
+                
         # clean the executable
         sh("rm -f %s > /dev/null 2>&1" % test.name, dry_run)