Changeset 358cba0 for src

Timestamp:

May 15, 2018, 4:17:15 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, with_gc

Children:

2e5fa345

Parents:

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

Message:

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

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (9 diffs)
• CodeGen/FixNames.cc (modified) (2 diffs)
• Common/Heap.cc (modified) (1 diff)
• Common/Heap.h (modified) (2 diffs)
• Common/PassVisitor.proto.h (modified) (4 diffs)
• Common/utility.h (modified) (2 diffs)
• Parser/parser.yy (modified) (10 diffs)
• benchmark/Makefile.am (modified) (1 diff)
• benchmark/Makefile.in (modified) (1 diff)
• driver/cc1.cc (modified) (3 diffs)
• driver/cfa.cc (modified) (5 diffs)
• libcfa/bits/containers.h (modified) (1 diff)
• libcfa/concurrency/coroutine (modified) (5 diffs)
• libcfa/concurrency/coroutine.c (modified) (3 diffs)
• libcfa/concurrency/invoke.c (modified) (1 diff)
• libcfa/concurrency/invoke.h (modified) (4 diffs)
• libcfa/concurrency/kernel (modified) (4 diffs)
• libcfa/concurrency/kernel.c (modified) (39 diffs)
• libcfa/concurrency/kernel_private.h (modified) (1 diff)
• libcfa/concurrency/monitor.c (modified) (12 diffs)
• libcfa/concurrency/preemption.c (modified) (9 diffs)
• libcfa/concurrency/thread.c (modified) (7 diffs)
• libcfa/interpose.c (modified) (10 diffs)
• libcfa/interpose.h (deleted)
• libcfa/stdlib (modified) (2 diffs)
• libcfa/time.c (modified) (5 diffs)
• main.cc (modified) (7 diffs)
• tests/.expect/fallthrough-ERROR.txt (deleted)
• tests/coroutine/fmtLines.c (modified) (3 diffs)

src/CodeGen/CodeGenerator.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Sep  3 20:42:52 2017
-// Update Count     : 490
+// Last Modified On : Sat May  5 09:08:32 2018
+// Update Count     : 494
 //
 #include "CodeGenerator.h"
@@ -370 +370 @@
 
         void CodeGenerator::postvisit( Constant * constant ) {
-                output << constant->get_value() ;
+                output << constant->get_value();
         }
 
@@ -587 +587 @@
                 output << "(";
                 if ( castExpr->get_result()->isVoid() ) {
-                        output << "(void)" ;
+                        output << "(void)";
                 } else {
                         // at least one result type of cast.
@@ -878 +878 @@
                         } // for
                 } // if
-                output << " );" ;
+                output << " );";
         }
 
@@ -886 +886 @@
                 output << "( ";
                 if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *visitor );
-                output << " )" ;
+                output << " )";
         }
 
         void CodeGenerator::postvisit( DirectiveStmt * dirStmt ) {
-                output << dirStmt->directive;
+                output << endl << dirStmt->directive;                   // endl prevents spaces before directive
         }
 
@@ -907 +907 @@
 
         void CodeGenerator::postvisit( SwitchStmt * switchStmt ) {
-                output << "switch ( " ;
+                output << "switch ( ";
                 switchStmt->get_condition()->accept( *visitor );
                 output << " ) ";
@@ -933 +933 @@
                 ++indent;
                 for ( std::list<Statement *>::iterator i = sts.begin(); i != sts.end();  i++) {
-                        output << indent << printLabels( (*i)->get_labels() )  ;
+                        output << indent << printLabels( (*i)->get_labels() ) ;
                         (*i)->accept( *visitor );
                         output << endl;
@@ -1070 +1070 @@
         void CodeGenerator::postvisit( WhileStmt * whileStmt ) {
                 if ( whileStmt->get_isDoWhile() ) {
-                        output << "do" ;
-                } else {
-                        output << "while (" ;
+                        output << "do";
+                } else {
+                        output << "while (";
                         whileStmt->get_condition()->accept( *visitor );
                         output << ")";
@@ -1084 +1084 @@
 
                 if ( whileStmt->get_isDoWhile() ) {
-                        output << " while (" ;
+                        output << " while (";
                         whileStmt->get_condition()->accept( *visitor );
                         output << ");";

src/CodeGen/FixNames.cc

@@ -56 +56 @@
                 auto && name = SymTab::Mangler::mangle( mainDecl.get() );
                 // std::cerr << name << std::endl;
-                return name;
+                return std::move(name);
         }
         std::string mangle_main_args() {
@@ -79 +79 @@
                 auto&& name = SymTab::Mangler::mangle( mainDecl.get() );
                 // std::cerr << name << std::endl;
-                return name;
+                return std::move(name);
         }
 

src/Common/Heap.cc

@@ -7 +7 @@
 // Heap.cc --
 //
-// Author           : Peter A. Buhr
-// Created On       :
+// Author           : Thierry Delisle
+// Created On       : Thu May  3 16:16:10 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu May  3 16:16:10 2018
-// Update Count     : 2
+// Last Modified On : Fri May  4 17:27:31 2018
+// Update Count     : 28
 //
 
-namespace HeapStats{
-  void newPass( const char * const name ) {}
-  void printStats() {}
+#include <cassert>
+#include <cmath>
+#include <cstddef>
+#include <cstring>
+#include <iomanip>
+#include <iostream>
+
+//#define WITH_HEAP_STATISTICS
+
+namespace HeapStats {
+#if !defined( WITH_HEAP_STATISTICS )
+        void newPass( const char * const ) {}
+
+        void printStats() {}
+#else
+        struct StatBlock {
+                const char * name = nullptr;
+                size_t mallocs    = 0;
+                size_t frees      = 0;
+        };
+
+        StatBlock    passes[100] = {{ "Pre-Parse", 0, 0 }};
+        const size_t passes_size = sizeof(passes) / sizeof(passes[0]);
+        size_t       passes_cnt = 1;
+
+        void newPass( const char * const name ) {
+                passes[passes_cnt].name    = name;
+                passes[passes_cnt].mallocs = 0;
+                passes[passes_cnt].frees   = 0;
+                passes_cnt++;
+
+                assertf(passes_cnt < passes_size, "Too many passes for HeapStats, increase the size of the array in Heap.h");
+        }
+
+        void print(size_t value, size_t total) {
+                std::cerr << std::setw(12) << value;
+                std::cerr << "(" << std::setw(3);
+                std::cerr << (value == 0 ? 0 : value * 100 / total);
+                std::cerr << "%) | ";
+        }
+
+        void print(const StatBlock& stat, size_t nc, size_t total_mallocs, size_t total_frees) {
+                std::cerr << std::setw(nc) << stat.name;
+                std::cerr << " | ";
+
+                print(stat.mallocs, total_mallocs);
+                print(stat.frees  , total_frees  );
+                std::cerr << "\n";
+        }
+
+        void print(char c, size_t nc) {
+                for(size_t i = 0; i < nc; i++) {
+                        std::cerr << c;
+                }
+                std::cerr << '\n';
+        }
+
+        void printStats() {
+                size_t nc = 0;
+                size_t total_mallocs = 0;
+                size_t total_frees   = 0;
+                for(size_t i = 0; i < passes_cnt; i++) {
+                        nc = std::max(nc, std::strlen(passes[i].name));
+                        total_mallocs += passes[i].mallocs;
+                        total_frees   += passes[i].frees;
+                }
+                size_t nct = nc + 44;
+
+                const char * const title = "Heap Usage Statistic";
+                print('=', nct);
+                for(size_t i = 0; i < (nct - std::strlen(title)) / 2; i++) std::cerr << ' ';
+                std::cerr << title << std::endl;
+                print('-', nct);
+                std::cerr << std::setw(nc) << "Pass";
+                std::cerr << " |       Malloc Count |         Free Count |" << std::endl;
+
+                print('-', nct);
+                for(size_t i = 0; i < passes_cnt; i++) {
+                        print(passes[i], nc, total_mallocs, total_frees);
+                }
+                print('-', nct);
+                print({"Sum", total_mallocs, total_frees}, nc, total_mallocs, total_frees);
+
+        }
+
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <signal.h>
+        extern "C" {
+#include <dlfcn.h>
+#include <execinfo.h>
+        }
+
+//=============================================================================================
+// Interposing helpers
+//=============================================================================================
+
+        typedef void (* generic_fptr_t)(void);
+        generic_fptr_t interpose_symbol( const char * symbol, const char * version ) {
+                const char * error;
+
+                static void * library;
+                if ( ! library ) {
+#if defined( RTLD_NEXT )
+                        library = RTLD_NEXT;
+#else
+                        // missing RTLD_NEXT => must hard-code library name, assuming libstdc++
+                        library = dlopen( "libc.so.6", RTLD_LAZY );
+                        error = dlerror();
+                        if ( error ) {
+                                std::cerr << "interpose_symbol : failed to open libc, " << error << std::endl;
+                                abort();
+                        }
+#endif // RTLD_NEXT
+                } // if
+
+                generic_fptr_t fptr;
+
+#if defined( _GNU_SOURCE )
+                if ( version ) {
+                        fptr = (generic_fptr_t)dlvsym( library, symbol, version );
+                } else {
+                        fptr = (generic_fptr_t)dlsym( library, symbol );
+                }
+#else
+                fptr = (generic_fptr_t)dlsym( library, symbol );
+#endif // _GNU_SOURCE
+
+                error = dlerror();
+                if ( error ) {
+                        std::cerr << "interpose_symbol : internal error, " << error << std::endl;
+                        abort();
+                }
+
+                return fptr;
+        }
+
+        extern "C" {
+                void * malloc( size_t size ) __attribute__((malloc));
+                void * malloc( size_t size ) {
+                        static auto __malloc = reinterpret_cast<void * (*)(size_t)>(interpose_symbol( "malloc", nullptr ));
+                        if( passes_cnt > 0 ) passes[passes_cnt - 1].mallocs++;
+                        return __malloc( size );
+                }
+
+                void free( void * ptr ) {
+                        static auto __free = reinterpret_cast<void   (*)(void *)>(interpose_symbol( "free", nullptr ));
+                        if( passes_cnt > 0 ) passes[passes_cnt - 1].frees++;
+                        return __free( ptr );
+                }
+
+                void * calloc( size_t nelem, size_t size ) {
+                        static auto __calloc = reinterpret_cast<void * (*)(size_t, size_t)>(interpose_symbol( "calloc", nullptr ));
+                        if( passes_cnt > 0 ) passes[passes_cnt - 1].mallocs++;
+                        return __calloc( nelem, size );
+                }
+
+                void * realloc( void * ptr, size_t size ) {
+                        static auto __realloc = reinterpret_cast<void * (*)(void *, size_t)>(interpose_symbol( "realloc", nullptr ));
+                        void * s = __realloc( ptr, size );
+                        if ( s != ptr && passes_cnt > 0 ) {                     // did realloc get new storage ?
+                                passes[passes_cnt - 1].mallocs++;
+                                passes[passes_cnt - 1].frees++;
+                        } // if
+                        return s;
+                }
+        }
+#endif
 }
-

src/Common/Heap.h

@@ -7 +7 @@
 // Heap.h --
 //
-// Author           : Peter A. Buhr
-// Created On       :
+// Author           : Thierry Delisle
+// Created On       : Thu May  3 16:16:10 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu May  3 16:16:10 2018
-// Update Count     : 2
+// Last Modified On : Fri May  4 14:34:08 2018
+// Update Count     : 3
 //
 
@@ -17 +17 @@
 
 namespace HeapStats {
-  void newPass( const char * const name );
-  void printStats();
+        void newPass( const char * const name );
+        void printStats();
 }

src/Common/PassVisitor.proto.h

@@ -47 +47 @@
 
         operator bool() { return m_ref ? *m_ref : true; }
-        bool operator=( bool val ) { return *m_ref = val; }
+        bool operator=( bool val ) { assert(m_ref); return *m_ref = val; }
 
 private:
@@ -53 +53 @@
         friend class ChildrenGuard;
 
-        bool * set( bool & val ) {
+        bool * set( bool * val ) {
                 bool * prev = m_ref;
-                m_ref = &val;
+                m_ref = val;
                 return prev;
         }
@@ -67 +67 @@
         ChildrenGuard( bool_ref * ref )
                 : m_val ( true )
-                , m_prev( ref ? ref->set( m_val ) : nullptr )
+                , m_prev( ref ? ref->set( &m_val ) : nullptr )
                 , m_ref ( ref )
         {}
@@ -73 +73 @@
         ~ChildrenGuard() {
                 if( m_ref ) {
-                        m_ref->set( *m_prev );
+                        m_ref->set( m_prev );
                 }
         }

src/Common/utility.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu May  3 12:18:31 2018
-// Update Count     : 39
+// Last Modified On : Sun May  6 22:24:16 2018
+// Update Count     : 40
 //
 
@@ -442 +442 @@
 template<typename T>
 inline
-#if __GNUC__ > 4
+#if defined(__GNUC__) && __GNUC__ > 4
 constexpr
 #endif

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu May  3 08:20:09 2018
-// Update Count     : 3225
+// Last Modified On : Fri May 11 17:51:38 2018
+// Update Count     : 3261
 //
 
@@ -302 +302 @@
 
 %type<decl> field_declaration field_declaration_list field_declarator field_declaring_list
-%type<en> field field_list field_name fraction_constants
+%type<en> field field_list field_name fraction_constants_opt
 
 %type<decl> external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr
@@ -499 +499 @@
         | type_name '.' no_attr_identifier                                      // CFA, nested type
                 { SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; }
+//              { $$ = nullptr; }
         | type_name '.' '[' push field_list pop ']'                     // CFA, nested type / tuple field selector
                 { SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; }
+//              { $$ = nullptr; }
         | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11
                 { SemanticError( yylloc, "_Generic is currently unimplemented." ); $$ = nullptr; }
@@ -533 +535 @@
         | postfix_expression '.' no_attr_identifier
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
+        | postfix_expression '.' INTEGERconstant                        // CFA, tuple index
+                { $$ = new ExpressionNode( build_fieldSel( $1, build_constantInteger( *$3 ) ) ); }
+        | postfix_expression FLOATING_FRACTIONconstant          // CFA, tuple index
+                { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_FLOATING_FRACTIONconstant( *$2 ) ) ); }
         | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); }
-        | postfix_expression FLOATING_FRACTIONconstant          // CFA, tuple index
-                { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_FLOATING_FRACTIONconstant( *$2 ) ) ); }
         | postfix_expression ARROW no_attr_identifier
                 {
                         $$ = new ExpressionNode( build_pfieldSel( $1, *$3 == "0" || *$3 == "1" ? build_constantInteger( *$3 ) : build_varref( $3 ) ) );
                 }
-        | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
-                        { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $5 ) ) ); }
         | postfix_expression ARROW INTEGERconstant                      // CFA, tuple index
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_constantInteger( *$3 ) ) ); }
+        | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
+                { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $5 ) ) ); }
         | postfix_expression ICR
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); }
@@ -597 +601 @@
 
 field_name:
-        INTEGERconstant fraction_constants
+        INTEGERconstant fraction_constants_opt
                 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_constantInteger( *$1 ), $2 ) ); }
-        | FLOATINGconstant fraction_constants
+        | FLOATINGconstant fraction_constants_opt
                 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *$1 ), $2 ) ); }
-        | no_attr_identifier fraction_constants
+        | no_attr_identifier fraction_constants_opt
                 {
                         $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) );
@@ -607 +611 @@
         ;
 
-fraction_constants:
+fraction_constants_opt:
         // empty
                 { $$ = nullptr; }
-        | fraction_constants FLOATING_FRACTIONconstant
+        | fraction_constants_opt FLOATING_FRACTIONconstant
                 {
                         Expression * constant = build_field_name_FLOATING_FRACTIONconstant( *$2 );
@@ -2390 +2394 @@
 external_definition_list:
         external_definition
-        | external_definition_list { forall = xxx; } push external_definition
+        | external_definition_list
+                { forall = xxx; }
+          push external_definition
                 { $$ = $1 ? $1->appendList( $4 ) : $4; }
         ;
@@ -2430 +2436 @@
                 {
                         for ( DeclarationNode * iter = $5; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
-                                iter->addQualifiers( $1->clone() );
+                                if ( isMangled( iter->linkage ) ) {             // ignore extern "C"
+                                        iter->addQualifiers( $1->clone() );
+                                } // if
                         } // for
                         xxx = false;
@@ -2443 +2451 @@
                 {
                         for ( DeclarationNode * iter = $5; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
-                                iter->addQualifiers( $1->clone() );
+                                if ( isMangled( iter->linkage ) ) {             // ignore extern "C"
+                                        iter->addQualifiers( $1->clone() );
+                                } // if
                         } // for
                         xxx = false;
@@ -2457 +2467 @@
                 {
                         for ( DeclarationNode * iter = $6; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
-                                iter->addQualifiers( $1->clone() );
-                                iter->addQualifiers( $2->clone() );
+                                if ( isMangled( iter->linkage ) && isMangled( $2->linkage ) ) { // ignore extern "C"
+                                        iter->addQualifiers( $1->clone() );
+                                        iter->addQualifiers( $2->clone() );
+                                } // if
                         } // for
                         xxx = false;

src/benchmark/Makefile.am

@@ -43 +43 @@
 
 %.runquiet :
-        @+make $(basename $@)
+        @+make $(basename $@) CFLAGS="-w"
         @taskset -c 1 ./a.out
         @rm -f a.out

src/benchmark/Makefile.in

@@ -459 +459 @@
 
 %.runquiet :
-        @+make $(basename $@)
+        @+make $(basename $@) CFLAGS="-w"
         @taskset -c 1 ./a.out
         @rm -f a.out

src/driver/cc1.cc

@@ -10 +10 @@
 // Created On       : Fri Aug 26 14:23:51 2005
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jan 18 08:14:21 2017
-// Update Count     : 81
+// Last Modified On : Sat May 12 16:11:53 2018
+// Update Count     : 94
 //
 
@@ -32 +32 @@
 string compiler_name( CFA_BACKEND_CC );                                 // path/name of C compiler
 
+string D__GCC_X__( "-D__GCC_X__=" );
 string D__GCC_BPREFIX__( "-D__GCC_BPREFIX__=" );
 string D__CFA_FLAGPREFIX__( "-D__CFA_FLAG__=" );
@@ -162 +163 @@
                                 cargs[ncargs] = ( *new string( string( argv[i + 1] ).substr( D__CFA_FLAGPREFIX__.size() - 2 ) ) ).c_str();
                                 ncargs += 1;
+                                i += 1;                                                                 // and the argument
+                        } else if ( prefix( arg, D__GCC_X__ ) ) {
+                                args[nargs] = "-x";
+                                nargs += 1;
+                                args[nargs] = ( *new string( arg.substr( D__GCC_X__.size() ) ) ).c_str(); // pass the flag along
+                                nargs += 1;
+                        } else if ( arg == "-D" && prefix( argv[i + 1], D__GCC_X__.substr(2) ) ) {
+                                args[nargs] = "-x";
+                                nargs += 1;
+                                args[nargs] = ( *new string( string( argv[i + 1] ).substr( D__GCC_X__.size() - 2 ) ) ).c_str(); // pass the flag along
+                                nargs += 1;
                                 i += 1;                                                                 // and the argument
                         } else if ( prefix( arg, D__GCC_BPREFIX__ ) ) {

src/driver/cfa.cc

@@ -10 +10 @@
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed May  2 17:57:43 2018
-// Update Count     : 224
+// Last Modified On : Mon May 14 07:52:50 2018
+// Update Count     : 243
 //
 
@@ -158 +158 @@
                                 args[nargs] = argv[i];                                  // pass the argument along
                                 nargs += 1;
-                        } else if ( prefix( arg, "-std=" ) ) {
+                        } else if ( prefix( arg, "-std=" ) || prefix( arg, "--std=" ) ) {
                                 std_flag = true;                                                // -std=XX provided
                                 args[nargs] = argv[i];                                  // pass the argument along
+                                nargs += 1;
+                        } else if ( arg == "-x" ) {                                     // lost so force along
+                                args[nargs] = argv[i];                                  // pass the argument along
+                                nargs += 1;
+                                i += 1;                                                                 // advance to argument
+                                args[nargs] = argv[i];                                  // pass the argument along
+                                nargs += 1;
+                                args[nargs] = ( *new string( string("-D__GCC_X__=") + argv[i] ) ).c_str(); // add the argument for -x
+                                nargs += 1;
+                        } else if ( prefix( arg, "-x" ) ) {                     // lost so force along
+                                args[nargs] = argv[i];                                  // pass the argument along
+                                nargs += 1;
+                                args[nargs] = ( *new string( string("-D__GCC_X__=") + arg.substr(2) ) ).c_str(); // add the argument for -x
                                 nargs += 1;
                         } else if ( arg == "-w" ) {
@@ -240 +253 @@
         } // for
 
+#ifdef __x86_64__
+        args[nargs] = "-mcx16";                                                         // allow double-wide CAA
+        nargs += 1;
+#endif // __x86_64__
+
 #ifdef __DEBUG_H__
         cerr << "args:";
@@ -268 +286 @@
         if ( link ) {
                 #if ! defined(HAVE_LIBCFA_RELEASE)
-                        if( !debug ) {
+                        if ( ! debug ) {
                                 cerr << "error: Option -nodebug is unavailable, libcfa was not installed." << endl;
                                 exit( EXIT_FAILURE );
-                                }
+                        } // if
                 #endif
                 #if ! defined(HAVE_LIBCFA_DEBUG)
-                        if( debug ) {
+                        if ( debug ) {
                                 cerr << "error: Option -debug is unavailable, libcfa-d was not installed." << endl;
                                 exit( EXIT_FAILURE );
-                                }
+                        } // if
                 #endif
 
@@ -292 +310 @@
                 args[nargs] = "-L" CFA_LIBDIR;
                 nargs += 1;
-                if( debug ) {
+                if ( debug ) {
                         args[nargs] = "-lcfa-d";
                 } else {
                         args[nargs] = "-lcfa";
-                }
+                } // if
                 nargs += 1;
                 args[nargs] = "-lpthread";

src/libcfa/bits/containers.h

@@ -186 +186 @@
 #endif
 
+
+//-----------------------------------------------------------------------------
+// Doubly Linked List
+//-----------------------------------------------------------------------------
+#ifdef __cforall
+        forall(dtype TYPE | sized(TYPE))
+        #define T TYPE
+        #define __getter_t * [T * & next, T * & prev] ( T & )
+#else
+        typedef void (*__generit_c_getter_t)();
+        #define T void
+        #define __getter_t __generit_c_getter_t
+#endif
+struct __dllist {
+        T * head;
+        __getter_t __get;
+};
+#undef T
+#undef __getter_t
+
+#ifdef __cforall
+#define __dllist_t(T) __dllist(T)
+#else
+#define __dllist_t(T) struct __dllist
+#endif
+
+#ifdef __cforall
+
+        forall(dtype T | sized(T))
+        static inline [void] ?{}( __dllist(T) & this, * [T * & next, T * & prev] ( T & ) __get ) {
+                this.head{ NULL };
+                this.__get = __get;
+        }
+
+        #define _next .0
+        #define _prev .1
+        forall(dtype T | sized(T))
+        static inline void push_front( __dllist(T) & this, T & node ) with( this ) {
+                if ( head ) {
+                        __get( node )_next = head;
+                        __get( node )_prev = __get( *head )_prev;
+                        // inserted node must be consistent before it is seen
+                        // prevent code movement across barrier
+                        asm( "" : : : "memory" );
+                        __get( *head )_prev = &node;
+                        T & prev = *__get( node )_prev;
+                        __get( prev )_next = &node;
+                }
+                else {
+                        __get( node )_next = &node;
+                        __get( node )_prev = &node;
+                }
+
+                // prevent code movement across barrier
+                asm( "" : : : "memory" );
+                head = &node;
+        }
+
+        forall(dtype T | sized(T))
+        static inline void remove( __dllist(T) & this, T & node ) with( this ) {
+                if ( &node == head ) {
+                        if ( __get( *head )_next == head ) {
+                                head = NULL;
+                        }
+                        else {
+                                head = __get( *head )_next;
+                        }
+                }
+                __get( *__get( node )_next )_prev = __get( node )_prev;
+                __get( *__get( node )_prev )_next = __get( node )_next;
+                __get( node )_next = NULL;
+                __get( node )_prev = NULL;
+        }
+        #undef _next
+        #undef _prev
+#endif
+
 //-----------------------------------------------------------------------------
 // Tools

src/libcfa/concurrency/coroutine

@@ -72 +72 @@
 // Suspend implementation inlined for performance
 static inline void suspend() {
-        coroutine_desc * src = TL_GET( this_coroutine );                        // optimization
+        // optimization : read TLS once and reuse it
+        // Safety note: this is preemption safe since if
+        // preemption occurs after this line, the pointer
+        // will also migrate which means this value will
+        // stay in syn with the TLS
+        coroutine_desc * src = TL_GET( this_coroutine );
 
         assertf( src->last != 0,
@@ -89 +94 @@
 forall(dtype T | is_coroutine(T))
 static inline void resume(T & cor) {
-        coroutine_desc * src = TL_GET( this_coroutine );                        // optimization
+        // optimization : read TLS once and reuse it
+        // Safety note: this is preemption safe since if
+        // preemption occurs after this line, the pointer
+        // will also migrate which means this value will
+        // stay in syn with the TLS
+        coroutine_desc * src = TL_GET( this_coroutine );
         coroutine_desc * dst = get_coroutine(cor);
 
@@ -107 +117 @@
                 dst->last = src;
                 dst->starter = dst->starter ? dst->starter : src;
-        } // if
+        }
 
         // always done for performance testing
@@ -114 +124 @@
 
 static inline void resume(coroutine_desc * dst) {
-        coroutine_desc * src = TL_GET( this_coroutine );                        // optimization
+        // optimization : read TLS once and reuse it
+        // Safety note: this is preemption safe since if
+        // preemption occurs after this line, the pointer
+        // will also migrate which means this value will
+        // stay in syn with the TLS
+        coroutine_desc * src = TL_GET( this_coroutine );
 
         // not resuming self ?
@@ -125 +140 @@
                 // set last resumer
                 dst->last = src;
-        } // if
+        }
 
         // always done for performance testing

src/libcfa/concurrency/coroutine.c

@@ -84 +84 @@
 // Wrapper for co
 void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
-      verify( TL_GET( preemption_state ).enabled || TL_GET( this_processor )->do_terminate );
+      // Safety note : This could cause some false positives due to preemption
+      verify( TL_GET( preemption_state.enabled ) || TL_GET( this_processor )->do_terminate );
       disable_interrupts();
 
@@ -91 +92 @@
 
       // set new coroutine that task is executing
-      TL_SET( this_coroutine, dst );
+      kernelTLS.this_coroutine = dst;
 
       // context switch to specified coroutine
@@ -102 +103 @@
 
       enable_interrupts( __cfaabi_dbg_ctx );
-      verify( TL_GET( preemption_state ).enabled || TL_GET( this_processor )->do_terminate );
+      // Safety note : This could cause some false positives due to preemption
+      verify( TL_GET( preemption_state.enabled ) || TL_GET( this_processor )->do_terminate );
 } //ctxSwitchDirect
 

src/libcfa/concurrency/invoke.c

@@ -69 +69 @@
         // Fetch the thread handle from the user defined thread structure
         struct thread_desc* thrd = get_thread( this );
+        thrd->self_cor.last = NULL;
 
         // Officially start the thread by enabling preemption

src/libcfa/concurrency/invoke.h

@@ -18 +18 @@
 #include "bits/locks.h"
 
-#define TL_GET( member ) kernelThreadData.member
-#define TL_SET( member, value ) kernelThreadData.member = value;
+#define TL_GET( member ) kernelTLS.member
+#define TL_SET( member, value ) kernelTLS.member = value;
 
 #ifdef __cforall
@@ -44 +44 @@
                                 volatile bool in_progress;
                         } preemption_state;
-                } kernelThreadData;
+                } kernelTLS;
         }
 
         static inline struct coroutine_desc * volatile active_coroutine() { return TL_GET( this_coroutine ); }
-        static inline struct thread_desc * volatile active_thread() { return TL_GET( this_thread ); }
-        static inline struct processor * volatile active_processor() { return TL_GET( this_processor ); }
+        static inline struct thread_desc    * volatile active_thread   () { return TL_GET( this_thread    ); }
+        static inline struct processor      * volatile active_processor() { return TL_GET( this_processor ); } // UNSAFE
         #endif
 
@@ -136 +136 @@
                 struct thread_desc * next;
 
-                __cfaabi_dbg_debug_do(
-                        // instrusive link field for debugging
-                        struct thread_desc * dbg_next;
-                        struct thread_desc * dbg_prev;
-                )
+                struct {
+                        struct thread_desc * next;
+                        struct thread_desc * prev;
+                } node;
      };
 
@@ -147 +146 @@
                 static inline thread_desc * & get_next( thread_desc & this ) {
                         return this.next;
+                }
+
+                static inline [thread_desc *&, thread_desc *& ] __get( thread_desc & this ) {
+                        return this.node.[next, prev];
                 }
 

src/libcfa/concurrency/kernel

@@ -40 +40 @@
 
 //-----------------------------------------------------------------------------
-// Cluster
-struct cluster {
-        // Ready queue locks
-        __spinlock_t ready_queue_lock;
+// Processor
+extern struct cluster * mainCluster;
 
-        // Ready queue for threads
-        __queue_t(thread_desc) ready_queue;
-
-        // Name of the cluster
-        const char * name;
-
-        // Preemption rate on this cluster
-        Duration preemption_rate;
-};
-
-extern struct cluster * mainCluster;
-extern Duration default_preemption();
-
-void ?{} (cluster & this, const char * name, Duration preemption_rate);
-void ^?{}(cluster & this);
-
-static inline void ?{} (cluster & this)                           { this{"Anonymous Cluster", default_preemption()}; }
-static inline void ?{} (cluster & this, Duration preemption_rate) { this{"Anonymous Cluster", preemption_rate}; }
-static inline void ?{} (cluster & this, const char * name)        { this{name, default_preemption()}; }
-
-//-----------------------------------------------------------------------------
-// Processor
 enum FinishOpCode { No_Action, Release, Schedule, Release_Schedule, Release_Multi, Release_Multi_Schedule };
 
@@ -98 +74 @@
 
         // Cluster from which to get threads
-        cluster * cltr;
+        struct cluster * cltr;
 
         // Name of the processor
@@ -124 +100 @@
         bool pending_preemption;
 
+        // Idle lock
+
+        // Link lists fields
+        struct {
+                struct processor * next;
+                struct processor * prev;
+        } node;
+
 #ifdef __CFA_DEBUG__
         // Last function to enable preemption on this processor
@@ -130 +114 @@
 };
 
-void  ?{}(processor & this, const char * name, cluster & cltr);
+void  ?{}(processor & this, const char * name, struct cluster & cltr);
 void ^?{}(processor & this);
 
 static inline void  ?{}(processor & this)                    { this{ "Anonymous Processor", *mainCluster}; }
-static inline void  ?{}(processor & this, cluster & cltr)    { this{ "Anonymous Processor", cltr}; }
+static inline void  ?{}(processor & this, struct cluster & cltr)    { this{ "Anonymous Processor", cltr}; }
 static inline void  ?{}(processor & this, const char * name) { this{name, *mainCluster }; }
+
+static inline [processor *&, processor *& ] __get( processor & this ) {
+        return this.node.[next, prev];
+}
+
+//-----------------------------------------------------------------------------
+// Cluster
+struct cluster {
+        // Ready queue locks
+        __spinlock_t ready_queue_lock;
+
+        // Ready queue for threads
+        __queue_t(thread_desc) ready_queue;
+
+        // Name of the cluster
+        const char * name;
+
+        // Preemption rate on this cluster
+        Duration preemption_rate;
+
+        // List of processors
+        __spinlock_t proc_list_lock;
+        __dllist_t(struct processor) procs;
+        __dllist_t(struct processor) idles;
+
+        // Link lists fields
+        struct {
+                cluster * next;
+                cluster * prev;
+        } node;
+};
+extern Duration default_preemption();
+
+void ?{} (cluster & this, const char * name, Duration preemption_rate);
+void ^?{}(cluster & this);
+
+static inline void ?{} (cluster & this)                           { this{"Anonymous Cluster", default_preemption()}; }
+static inline void ?{} (cluster & this, Duration preemption_rate) { this{"Anonymous Cluster", preemption_rate}; }
+static inline void ?{} (cluster & this, const char * name)        { this{name, default_preemption()}; }
+
+static inline [cluster *&, cluster *& ] __get( cluster & this ) {
+        return this.node.[next, prev];
+}
 
 // Local Variables: //

src/libcfa/concurrency/kernel.c

@@ -49 +49 @@
 thread_desc * mainThread;
 
+struct { __dllist_t(thread_desc) list; __spinlock_t lock; } global_threads ;
+struct { __dllist_t(cluster    ) list; __spinlock_t lock; } global_clusters;
+
 //-----------------------------------------------------------------------------
 // Global state
@@ -56 +59 @@
 // volatile thread_local unsigned short disable_preempt_count = 1;
 
-thread_local struct KernelThreadData kernelThreadData = {
+thread_local struct KernelThreadData kernelTLS = {
         NULL,
         NULL,
@@ -117 +120 @@
         self_mon_p = &self_mon;
         next = NULL;
-        __cfaabi_dbg_debug_do(
-                dbg_next = NULL;
-                dbg_prev = NULL;
-                __cfaabi_dbg_thread_register(&this);
-        )
+
+        node.next = NULL;
+        node.prev = NULL;
+        doregister(this);
 
         monitors{ &self_mon_p, 1, (fptr_t)0 };
@@ -155 +157 @@
                 terminate(&this);
                 verify(this.do_terminate);
-                verify(TL_GET( this_processor ) != &this);
+                verify( kernelTLS.this_processor != &this);
                 P( terminated );
-                verify(TL_GET( this_processor ) != &this);
+                verify( kernelTLS.this_processor != &this);
                 pthread_join( kernel_thread, NULL );
         }
@@ -167 +169 @@
         ready_queue{};
         ready_queue_lock{};
+
+        procs{ __get };
+        idles{ __get };
+
+        doregister(this);
 }
 
 void ^?{}(cluster & this) {
-
+        unregister(this);
 }
 
@@ -183 +190 @@
         __cfaabi_dbg_print_safe("Kernel : core %p starting\n", this);
 
+        doregister(this->cltr, this);
+
         {
                 // Setup preemption data
@@ -196 +205 @@
                         if(readyThread)
                         {
-                                verify( ! TL_GET( preemption_state ).enabled );
+                                verify( ! kernelTLS.preemption_state.enabled );
 
                                 runThread(this, readyThread);
 
-                                verify( ! TL_GET( preemption_state ).enabled );
+                                verify( ! kernelTLS.preemption_state.enabled );
 
                                 //Some actions need to be taken from the kernel
@@ -216 +225 @@
         }
 
+        unregister(this->cltr, this);
+
         V( this->terminated );
 
@@ -221 +232 @@
 }
 
+// KERNEL ONLY
 // runThread runs a thread by context switching
 // from the processor coroutine to the target thread
@@ -228 +240 @@
         coroutine_desc * thrd_cor = dst->curr_cor;
 
-        //Reset the terminating actions here
+        // Reset the terminating actions here
         this->finish.action_code = No_Action;
 
-        //Update global state
-        TL_SET( this_thread, dst );
+        // Update global state
+        kernelTLS.this_thread = dst;
 
         // Context Switch to the thread
@@ -239 +251 @@
 }
 
+// KERNEL_ONLY
 void returnToKernel() {
-        coroutine_desc * proc_cor = get_coroutine(TL_GET( this_processor )->runner);
-        coroutine_desc * thrd_cor = TL_GET( this_thread )->curr_cor = TL_GET( this_coroutine );
+        coroutine_desc * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
+        coroutine_desc * thrd_cor = kernelTLS.this_thread->curr_cor = kernelTLS.this_coroutine;
         ThreadCtxSwitch(thrd_cor, proc_cor);
 }
 
+// KERNEL_ONLY
 // Once a thread has finished running, some of
 // its final actions must be executed from the kernel
 void finishRunning(processor * this) with( this->finish ) {
         if( action_code == Release ) {
-                verify( ! TL_GET( preemption_state ).enabled );
+                verify( ! kernelTLS.preemption_state.enabled );
                 unlock( *lock );
         }
@@ -256 +270 @@
         }
         else if( action_code == Release_Schedule ) {
-                verify( ! TL_GET( preemption_state ).enabled );
+                verify( ! kernelTLS.preemption_state.enabled );
                 unlock( *lock );
                 ScheduleThread( thrd );
         }
         else if( action_code == Release_Multi ) {
-                verify( ! TL_GET( preemption_state ).enabled );
+                verify( ! kernelTLS.preemption_state.enabled );
                 for(int i = 0; i < lock_count; i++) {
                         unlock( *locks[i] );
@@ -285 +299 @@
 }
 
+// KERNEL_ONLY
 // Context invoker for processors
 // This is the entry point for processors (kernel threads)
@@ -290 +305 @@
 void * CtxInvokeProcessor(void * arg) {
         processor * proc = (processor *) arg;
-        TL_SET( this_processor, proc );
-        TL_SET( this_coroutine, NULL );
-        TL_SET( this_thread, NULL );
-        TL_GET( preemption_state ).[enabled, disable_count] = [false, 1];
+        kernelTLS.this_processor = proc;
+        kernelTLS.this_coroutine = NULL;
+        kernelTLS.this_thread    = NULL;
+        kernelTLS.preemption_state.[enabled, disable_count] = [false, 1];
         // SKULLDUGGERY: We want to create a context for the processor coroutine
         // which is needed for the 2-step context switch. However, there is no reason
@@ -305 +320 @@
 
         //Set global state
-        TL_SET( this_coroutine, get_coroutine(proc->runner) );
-        TL_SET( this_thread, NULL );
+        kernelTLS.this_coroutine = get_coroutine(proc->runner);
+        kernelTLS.this_thread    = NULL;
 
         //We now have a proper context from which to schedule threads
@@ -333 +348 @@
 }
 
+// KERNEL_ONLY
 void kernel_first_resume(processor * this) {
-        coroutine_desc * src = TL_GET( this_coroutine );
+        coroutine_desc * src = kernelTLS.this_coroutine;
         coroutine_desc * dst = get_coroutine(this->runner);
 
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         create_stack(&dst->stack, dst->stack.size);
         CtxStart(&this->runner, CtxInvokeCoroutine);
 
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         dst->last = src;
@@ -351 +367 @@
 
         // set new coroutine that task is executing
-        TL_SET( this_coroutine, dst );
+        kernelTLS.this_coroutine = dst;
 
         // SKULLDUGGERY normally interrupts are enable before leaving a coroutine ctxswitch.
@@ -368 +384 @@
         src->state = Active;
 
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 }
 
 //-----------------------------------------------------------------------------
 // Scheduler routines
+
+// KERNEL ONLY
 void ScheduleThread( thread_desc * thrd ) {
-        // if( ! thrd ) return;
         verify( thrd );
         verify( thrd->self_cor.state != Halted );
 
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
@@ -388 +405 @@
         }
 
-        verify( ! TL_GET( preemption_state ).enabled );
-}
-
+        verify( ! kernelTLS.preemption_state.enabled );
+}
+
+// KERNEL ONLY
 thread_desc * nextThread(cluster * this) with( *this ) {
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         lock( ready_queue_lock __cfaabi_dbg_ctx2 );
         thread_desc * head = pop_head( ready_queue );
         unlock( ready_queue_lock );
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         return head;
 }
@@ -402 +420 @@
 void BlockInternal() {
         disable_interrupts();
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         returnToKernel();
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
 }
@@ -410 +428 @@
 void BlockInternal( __spinlock_t * lock ) {
         disable_interrupts();
-        with( *TL_GET( this_processor ) ) {
+        with( *kernelTLS.this_processor ) {
                 finish.action_code = Release;
                 finish.lock        = lock;
         }
 
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         returnToKernel();
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -424 +442 @@
 void BlockInternal( thread_desc * thrd ) {
         disable_interrupts();
-        with( *TL_GET( this_processor ) ) {
+        with( * kernelTLS.this_processor ) {
                 finish.action_code = Schedule;
                 finish.thrd        = thrd;
         }
 
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         returnToKernel();
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -439 +457 @@
         assert(thrd);
         disable_interrupts();
-        with( *TL_GET( this_processor ) ) {
+        with( * kernelTLS.this_processor ) {
                 finish.action_code = Release_Schedule;
                 finish.lock        = lock;
@@ -445 +463 @@
         }
 
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         returnToKernel();
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -454 +472 @@
 void BlockInternal(__spinlock_t * locks [], unsigned short count) {
         disable_interrupts();
-        with( *TL_GET( this_processor ) ) {
+        with( * kernelTLS.this_processor ) {
                 finish.action_code = Release_Multi;
                 finish.locks       = locks;
@@ -460 +478 @@
         }
 
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         returnToKernel();
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -469 +487 @@
 void BlockInternal(__spinlock_t * locks [], unsigned short lock_count, thread_desc * thrds [], unsigned short thrd_count) {
         disable_interrupts();
-        with( *TL_GET( this_processor ) ) {
+        with( *kernelTLS.this_processor ) {
                 finish.action_code = Release_Multi_Schedule;
                 finish.locks       = locks;
@@ -477 +495 @@
         }
 
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         returnToKernel();
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
 }
 
+// KERNEL ONLY
 void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
-        verify( ! TL_GET( preemption_state ).enabled );
-        with( *TL_GET( this_processor ) ) {
+        verify( ! kernelTLS.preemption_state.enabled );
+        with( * kernelTLS.this_processor ) {
                 finish.action_code = thrd ? Release_Schedule : Release;
                 finish.lock        = lock;
@@ -501 +520 @@
 // Kernel boot procedures
 void kernel_startup(void) {
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         __cfaabi_dbg_print_safe("Kernel : Starting\n");
+
+        global_threads. list{ __get };
+        global_threads. lock{};
+        global_clusters.list{ __get };
+        global_clusters.lock{};
 
         // Initialize the main cluster
@@ -547 +571 @@
 
         //initialize the global state variables
-        TL_SET( this_processor, mainProcessor );
-        TL_SET( this_thread, mainThread );
-        TL_SET( this_coroutine, &mainThread->self_cor );
+        kernelTLS.this_processor = mainProcessor;
+        kernelTLS.this_thread    = mainThread;
+        kernelTLS.this_coroutine = &mainThread->self_cor;
 
         // Enable preemption
@@ -561 +585 @@
         // 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.
-        kernel_first_resume( TL_GET( this_processor ) );
+        kernel_first_resume( kernelTLS.this_processor );
 
 
@@ -568 +592 @@
         __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n");
 
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
-        verify( TL_GET( preemption_state ).enabled );
+        verify( TL_GET( preemption_state.enabled ) );
 }
 
@@ -576 +600 @@
         __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
 
-        verify( TL_GET( preemption_state ).enabled );
+        verify( TL_GET( preemption_state.enabled ) );
         disable_interrupts();
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         // SKULLDUGGERY: Notify the mainProcessor it needs to terminates.
@@ -604 +628 @@
 
 //=============================================================================================
+// Kernel Quiescing
+//=============================================================================================
+
+// void halt(processor * this) with( this ) {
+//      pthread_mutex_lock( &idle.lock );
+
+
+
+//      // SKULLDUGGERY: Even if spurious wake-up is a thing
+//      // spuriously waking up a kernel thread is not a big deal
+//      // if it is very rare.
+//      pthread_cond_wait( &idle.cond, &idle.lock);
+//      pthread_mutex_unlock( &idle.lock );
+// }
+
+// void wake(processor * this) with( this ) {
+//      pthread_mutex_lock  (&idle.lock);
+//      pthread_cond_signal (&idle.cond);
+//      pthread_mutex_unlock(&idle.lock);
+// }
+
+//=============================================================================================
 // Unexpected Terminating logic
 //=============================================================================================
@@ -609 +655 @@
 
 static __spinlock_t kernel_abort_lock;
-static __spinlock_t kernel_debug_lock;
 static bool kernel_abort_called = false;
 
-void * kernel_abort    (void) __attribute__ ((__nothrow__)) {
+void * kernel_abort(void) __attribute__ ((__nothrow__)) {
         // abort cannot be recursively entered by the same or different processors because all signal handlers return when
         // the globalAbort flag is true.
@@ -618 +663 @@
 
         // first task to abort ?
-        if ( ! kernel_abort_called ) {                  // not first task to abort ?
+        if ( kernel_abort_called ) {                    // not first task to abort ?
+                unlock( kernel_abort_lock );
+
+                sigset_t mask;
+                sigemptyset( &mask );
+                sigaddset( &mask, SIGALRM );            // block SIGALRM signals
+                sigsuspend( &mask );                    // block the processor to prevent further damage during abort
+                _exit( EXIT_FAILURE );                  // if processor unblocks before it is killed, terminate it
+        }
+        else {
                 kernel_abort_called = true;
                 unlock( kernel_abort_lock );
         }
-        else {
-                unlock( kernel_abort_lock );
-
-                sigset_t mask;
-                sigemptyset( &mask );
-                sigaddset( &mask, SIGALRM );                    // block SIGALRM signals
-                sigaddset( &mask, SIGUSR1 );                    // block SIGUSR1 signals
-                sigsuspend( &mask );                            // block the processor to prevent further damage during abort
-                _exit( EXIT_FAILURE );                          // if processor unblocks before it is killed, terminate it
-        }
-
-        return TL_GET( this_thread );
+
+        return kernelTLS.this_thread;
 }
 
@@ -639 +683 @@
         thread_desc * thrd = kernel_data;
 
-        int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->self_cor.name, thrd );
-        __cfaabi_dbg_bits_write( abort_text, len );
-
-        if ( get_coroutine(thrd) != TL_GET( this_coroutine ) ) {
-                len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", TL_GET( this_coroutine )->name, TL_GET( this_coroutine ) );
+        if(thrd) {
+                int len = snprintf( abort_text, abort_text_size, "Error occurred while executing thread %.256s (%p)", thrd->self_cor.name, thrd );
                 __cfaabi_dbg_bits_write( abort_text, len );
+
+                if ( get_coroutine(thrd) != kernelTLS.this_coroutine ) {
+                        len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", kernelTLS.this_coroutine->name, kernelTLS.this_coroutine );
+                        __cfaabi_dbg_bits_write( abort_text, len );
+                }
+                else {
+                        __cfaabi_dbg_bits_write( ".\n", 2 );
+                }
         }
         else {
-                __cfaabi_dbg_bits_write( ".\n", 2 );
+                int len = snprintf( abort_text, abort_text_size, "Error occurred outside of any thread.\n" );
         }
 }
 
 int kernel_abort_lastframe( void ) __attribute__ ((__nothrow__)) {
-        return get_coroutine(TL_GET( this_thread )) == get_coroutine(mainThread) ? 4 : 2;
-}
+        return get_coroutine(kernelTLS.this_thread) == get_coroutine(mainThread) ? 4 : 2;
+}
+
+static __spinlock_t kernel_debug_lock;
 
 extern "C" {
@@ -682 +733 @@
         if ( count < 0 ) {
                 // queue current task
-                append( waiting, (thread_desc *)TL_GET( this_thread ) );
+                append( waiting, kernelTLS.this_thread );
 
                 // atomically release spin lock and block
@@ -708 +759 @@
 
 //-----------------------------------------------------------------------------
+// Global Queues
+void doregister( thread_desc & thrd ) {
+        // lock      ( global_thread.lock );
+        // push_front( global_thread.list, thrd );
+        // unlock    ( global_thread.lock );
+}
+
+void unregister( thread_desc & thrd ) {
+        // lock  ( global_thread.lock );
+        // remove( global_thread.list, thrd );
+        // unlock( global_thread.lock );
+}
+
+void doregister( cluster     & cltr ) {
+        // lock      ( global_cluster.lock );
+        // push_front( global_cluster.list, cltr );
+        // unlock    ( global_cluster.lock );
+}
+
+void unregister( cluster     & cltr ) {
+        // lock  ( global_cluster.lock );
+        // remove( global_cluster.list, cltr );
+        // unlock( global_cluster.lock );
+}
+
+
+void doregister( cluster * cltr, processor * proc ) {
+        // lock      (cltr->proc_list_lock __cfaabi_dbg_ctx2);
+        // push_front(cltr->procs, *proc);
+        // unlock    (cltr->proc_list_lock);
+}
+
+void unregister( cluster * cltr, processor * proc ) {
+        // lock  (cltr->proc_list_lock __cfaabi_dbg_ctx2);
+        // remove(cltr->procs, *proc );
+        // unlock(cltr->proc_list_lock);
+}
+
+//-----------------------------------------------------------------------------
 // Debug
 __cfaabi_dbg_debug_do(
-        struct {
-                thread_desc * tail;
-        } __cfaabi_dbg_thread_list = { NULL };
-
-        void __cfaabi_dbg_thread_register( thread_desc * thrd ) {
-                if( !__cfaabi_dbg_thread_list.tail ) {
-                        __cfaabi_dbg_thread_list.tail = thrd;
-                        return;
-                }
-                __cfaabi_dbg_thread_list.tail->dbg_next = thrd;
-                thrd->dbg_prev = __cfaabi_dbg_thread_list.tail;
-                __cfaabi_dbg_thread_list.tail = thrd;
-        }
-
-        void __cfaabi_dbg_thread_unregister( thread_desc * thrd ) {
-                thread_desc * prev = thrd->dbg_prev;
-                thread_desc * next = thrd->dbg_next;
-
-                if( next ) { next->dbg_prev = prev; }
-                else       {
-                        assert( __cfaabi_dbg_thread_list.tail == thrd );
-                        __cfaabi_dbg_thread_list.tail = prev;
-                }
-
-                if( prev ) { prev->dbg_next = next; }
-
-                thrd->dbg_prev = NULL;
-                thrd->dbg_next = NULL;
-        }
-
         void __cfaabi_dbg_record(__spinlock_t & this, const char * prev_name) {
                 this.prev_name = prev_name;
-                this.prev_thrd = TL_GET( this_thread );
+                this.prev_thrd = kernelTLS.this_thread;
         }
 )

src/libcfa/concurrency/kernel_private.h

@@ -100 +100 @@
 #define KERNEL_STORAGE(T,X) static char storage_##X[sizeof(T)]
 
+
+void doregister( struct thread_desc & thrd );
+void unregister( struct thread_desc & thrd );
+
+void doregister( struct cluster     & cltr );
+void unregister( struct cluster     & cltr );
+
+void doregister( struct cluster * cltr, struct processor * proc );
+void unregister( struct cluster * cltr, struct processor * proc );
+
 // Local Variables: //
 // mode: c //

src/libcfa/concurrency/monitor.c

@@ -85 +85 @@
                 // Lock the monitor spinlock
                 lock( this->lock __cfaabi_dbg_ctx2 );
-                thread_desc * thrd = TL_GET( this_thread );
+                // Interrupts disable inside critical section
+                thread_desc * thrd = kernelTLS.this_thread;
 
                 __cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
@@ -134 +135 @@
                 // Lock the monitor spinlock
                 lock( this->lock __cfaabi_dbg_ctx2 );
-                thread_desc * thrd = TL_GET( this_thread );
+                // Interrupts disable inside critical section
+                thread_desc * thrd = kernelTLS.this_thread;
 
                 __cfaabi_dbg_print_safe( "Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
@@ -168 +170 @@
 
                         // Create the node specific to this wait operation
-                        wait_ctx_primed( TL_GET( this_thread ), 0 )
+                        wait_ctx_primed( thrd, 0 )
 
                         // Some one else has the monitor, wait for him to finish and then run
@@ -179 +181 @@
                         __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
 
-                        wait_ctx( TL_GET( this_thread ), 0 )
+                        wait_ctx( thrd, 0 )
                         this->dtor_node = &waiter;
 
@@ -199 +201 @@
                 lock( this->lock __cfaabi_dbg_ctx2 );
 
-                __cfaabi_dbg_print_safe( "Kernel : %10p Leaving mon %p (%p)\n", TL_GET( this_thread ), this, this->owner);
-
-                verifyf( TL_GET( this_thread ) == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", TL_GET( this_thread ), this->owner, this->recursion, this );
+                __cfaabi_dbg_print_safe( "Kernel : %10p Leaving mon %p (%p)\n", kernelTLS.this_thread, this, this->owner);
+
+                verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
 
                 // Leaving a recursion level, decrement the counter
@@ -289 +291 @@
 // Sorts monitors before entering
 void ?{}( monitor_guard_t & this, monitor_desc * m [], __lock_size_t count, fptr_t func ) {
+        thread_desc * thrd = TL_GET( this_thread );
+
         // Store current array
         this.m = m;
@@ -297 +301 @@
 
         // Save previous thread context
-        this.prev = TL_GET( this_thread )->monitors;
+        this.prev = thrd->monitors;
 
         // Update thread context (needed for conditions)
-        (TL_GET( this_thread )->monitors){m, count, func};
+        (thrd->monitors){m, count, func};
 
         // __cfaabi_dbg_print_safe( "MGUARD : enter %d\n", count);
@@ -328 +332 @@
 // Sorts monitors before entering
 void ?{}( monitor_dtor_guard_t & this, monitor_desc * m [], fptr_t func ) {
+        // optimization
+        thread_desc * thrd = TL_GET( this_thread );
+
         // Store current array
         this.m = *m;
 
         // Save previous thread context
-        this.prev = TL_GET( this_thread )->monitors;
+        this.prev = thrd->monitors;
 
         // Update thread context (needed for conditions)
-        (TL_GET( this_thread )->monitors){m, 1, func};
+        (thrd->monitors){m, 1, func};
 
         __enter_monitor_dtor( this.m, func );
@@ -473 +480 @@
 
         // Create the node specific to this wait operation
-        wait_ctx_primed( TL_GET( this_thread ), 0 )
+        wait_ctx_primed( kernelTLS.this_thread, 0 )
 
         //save contexts
@@ -566 +573 @@
 
                                 // Create the node specific to this wait operation
-                                wait_ctx_primed( TL_GET( this_thread ), 0 );
+                                wait_ctx_primed( kernelTLS.this_thread, 0 );
 
                                 // Save monitor states
@@ -612 +619 @@
 
         // Create the node specific to this wait operation
-        wait_ctx_primed( TL_GET( this_thread ), 0 );
+        wait_ctx_primed( kernelTLS.this_thread, 0 );
 
         monitor_save;
@@ -618 +625 @@
 
         for( __lock_size_t i = 0; i < count; i++) {
-                verify( monitors[i]->owner == TL_GET( this_thread ) );
+                verify( monitors[i]->owner == kernelTLS.this_thread );
         }
 

src/libcfa/concurrency/preemption.c

@@ -149 +149 @@
         // Disable interrupts by incrementing the counter
         void disable_interrupts() {
-                with( TL_GET( preemption_state ) ) {
+                with( kernelTLS.preemption_state ) {
                         enabled = false;
                         __attribute__((unused)) unsigned short new_val = disable_count + 1;
@@ -160 +160 @@
         // If counter reaches 0, execute any pending CtxSwitch
         void enable_interrupts( __cfaabi_dbg_ctx_param ) {
-                processor   * proc = TL_GET( this_processor ); // Cache the processor now since interrupts can start happening after the atomic add
-                thread_desc * thrd = TL_GET( this_thread );       // Cache the thread now since interrupts can start happening after the atomic add
-
-                with( TL_GET( preemption_state ) ){
+                processor   * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic add
+                thread_desc * thrd = kernelTLS.this_thread;       // Cache the thread now since interrupts can start happening after the atomic add
+
+                with( kernelTLS.preemption_state ){
                         unsigned short prev = disable_count;
                         disable_count -= 1;
@@ -185 +185 @@
         // Don't execute any pending CtxSwitch even if counter reaches 0
         void enable_interrupts_noPoll() {
-                unsigned short prev = TL_GET( preemption_state ).disable_count;
-                TL_GET( preemption_state ).disable_count -= 1;
+                unsigned short prev = kernelTLS.preemption_state.disable_count;
+                kernelTLS.preemption_state.disable_count -= 1;
                 verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
                 if( prev == 1 ) {
-                        TL_GET( preemption_state ).enabled = true;
+                        kernelTLS.preemption_state.enabled = true;
                 }
         }
@@ -234 +234 @@
 }
 
-
+// KERNEL ONLY
 // Check if a CtxSwitch signal handler shoud defer
 // If true  : preemption is safe
 // If false : preemption is unsafe and marked as pending
 static inline bool preemption_ready() {
-        bool ready = TL_GET( preemption_state ).enabled && !TL_GET( preemption_state ).in_progress; // Check if preemption is safe
-        TL_GET( this_processor )->pending_preemption = !ready;                  // Adjust the pending flag accordingly
+        // Check if preemption is safe
+        bool ready = kernelTLS.preemption_state.enabled && ! kernelTLS.preemption_state.in_progress;
+
+        // Adjust the pending flag accordingly
+        kernelTLS.this_processor->pending_preemption = !ready;
         return ready;
 }
@@ -254 +257 @@
 
         // Start with preemption disabled until ready
-        TL_GET( preemption_state ).enabled = false;
-        TL_GET( preemption_state ).disable_count = 1;
+        kernelTLS.preemption_state.enabled = false;
+        kernelTLS.preemption_state.disable_count = 1;
 
         // Initialize the event kernel
@@ -320 +323 @@
         // before the kernel thread has even started running. When that happens an iterrupt
         // we a null 'this_processor' will be caught, just ignore it.
-        if(!TL_GET( this_processor )) return;
+        if(! kernelTLS.this_processor ) return;
 
         choose(sfp->si_value.sival_int) {
                 case PREEMPT_NORMAL   : ;// Normal case, nothing to do here
-                case PREEMPT_TERMINATE: verify(TL_GET( this_processor )->do_terminate);
+                case PREEMPT_TERMINATE: verify( kernelTLS.this_processor->do_terminate);
                 default:
                         abort( "internal error, signal value is %d", sfp->si_value.sival_int );
@@ -332 +335 @@
         if( !preemption_ready() ) { return; }
 
-        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", TL_GET( this_processor ), TL_GET( this_thread ) );
-
-        TL_GET( preemption_state ).in_progress = true;  // Sync flag : prevent recursive calls to the signal handler
-        signal_unblock( SIGUSR1 );                          // We are about to CtxSwitch out of the signal handler, let other handlers in
-        TL_GET( preemption_state ).in_progress = false; // Clear the in progress flag
+        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", kernelTLS.this_processor, kernelTLS.this_thread );
+
+        // Sync flag : prevent recursive calls to the signal handler
+        kernelTLS.preemption_state.in_progress = true;
+
+        // We are about to CtxSwitch out of the signal handler, let other handlers in
+        signal_unblock( SIGUSR1 );
+
+        // TODO: this should go in finish action
+        // Clear the in progress flag
+        kernelTLS.preemption_state.in_progress = false;
 
         // Preemption can occur here
 
-        BlockInternal( (thread_desc*)TL_GET( this_thread ) ); // Do the actual CtxSwitch
+        BlockInternal( kernelTLS.this_thread ); // Do the actual CtxSwitch
 }
 
@@ -348 +357 @@
         // Block sigalrms to control when they arrive
         sigset_t mask;
+        sigfillset(&mask);
+        if ( pthread_sigmask( SIG_BLOCK, &mask, NULL ) == -1 ) {
+            abort( "internal error, pthread_sigmask" );
+        }
+
         sigemptyset( &mask );
         sigaddset( &mask, SIGALRM );
-
-        if ( pthread_sigmask( SIG_BLOCK, &mask, NULL ) == -1 ) {
-            abort( "internal error, pthread_sigmask" );
-        }
 
         // Main loop
@@ -409 +419 @@
 
 void __cfaabi_check_preemption() {
-        bool ready = TL_GET( preemption_state ).enabled;
+        bool ready = kernelTLS.preemption_state.enabled;
         if(!ready) { abort("Preemption should be ready"); }
 

src/libcfa/concurrency/thread.c

@@ -39 +39 @@
         curr_cluster = &cl;
         next = NULL;
-        __cfaabi_dbg_debug_do(
-                dbg_next = NULL;
-                dbg_prev = NULL;
-                __cfaabi_dbg_thread_register(&this);
-        )
+
+        node.next = NULL;
+        node.prev = NULL;
+        doregister(this);
 
         monitors{ &self_mon_p, 1, (fptr_t)0 };
@@ -49 +48 @@
 
 void ^?{}(thread_desc& this) with( this ) {
+        unregister(this);
         ^self_cor{};
 }
@@ -81 +81 @@
         disable_interrupts();
         create_stack(&thrd_c->stack, thrd_c->stack.size);
-        TL_SET( this_coroutine, thrd_c );
+        kernelTLS.this_coroutine = thrd_c;
         CtxStart(&this, CtxInvokeThread);
         assert( thrd_c->last->stack.context );
@@ -91 +91 @@
 
 extern "C" {
+        // KERNEL ONLY
         void __finish_creation(void) {
-                coroutine_desc* thrd_c = TL_GET( this_coroutine );
+                coroutine_desc* thrd_c = kernelTLS.this_coroutine;
                 ThreadCtxSwitch( thrd_c, thrd_c->last );
         }
@@ -98 +99 @@
 
 void yield( void ) {
-        verify( TL_GET( preemption_state ).enabled );
+        // Safety note : This could cause some false positives due to preemption
+      verify( TL_GET( preemption_state.enabled ) );
         BlockInternal( TL_GET( this_thread ) );
-        verify( TL_GET( preemption_state ).enabled );
+        // Safety note : This could cause some false positives due to preemption
+      verify( TL_GET( preemption_state.enabled ) );
 }
 
@@ -109 +112 @@
 }
 
+// KERNEL ONLY
 void ThreadCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
         // set state of current coroutine to inactive
@@ -116 +120 @@
         // set new coroutine that the processor is executing
         // and context switch to it
-        TL_SET( this_coroutine, dst );
+        kernelTLS.this_coroutine = dst;
         assert( src->stack.context );
         CtxSwitch( src->stack.context, dst->stack.context );
-        TL_SET( this_coroutine, src );
+        kernelTLS.this_coroutine = src;
 
         // set state of new coroutine to active

src/libcfa/interpose.c

@@ -10 +10 @@
 // Created On       : Wed Mar 29 16:10:31 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue May  1 15:05:35 2018
-// Update Count     : 83
-//
-
-#include <stdarg.h>
-#include <stddef.h>
-
-extern "C" {
-#include <stdio.h>
-#include <string.h>
-#include <dlfcn.h>
-#include <unistd.h>
+// Last Modified On : Sat May  5 11:37:35 2018
+// Update Count     : 111
+//
+
+#include <stdarg.h>                                                                             // va_start, va_end
+#include <string.h>                                                                             // strlen
+#include <unistd.h>                                                                             // _exit, getpid
 #define __USE_GNU
 #include <signal.h>
 #undef __USE_GNU
-#include <execinfo.h>
+extern "C" {
+#include <dlfcn.h>                                                                              // dlopen, dlsym
+#include <execinfo.h>                                                                   // backtrace, messages
 }
 
 #include "bits/debug.h"
 #include "bits/defs.h"
-#include "bits/signal.h"
-#include "startup.h"
+#include "bits/signal.h"                                                                // sigHandler_?
+#include "startup.h"                                                                    // STARTUP_PRIORITY_CORE
 
 //=============================================================================================
@@ -37 +34 @@
 //=============================================================================================
 
-typedef void (*generic_fptr_t)(void);
-generic_fptr_t interpose_symbol( const char* symbol, const char *version ) {
+typedef void (* generic_fptr_t)(void);
+generic_fptr_t interpose_symbol( const char * symbol, const char * version ) {
         const char * error;
 
@@ -55 +52 @@
         } // if
 
-        union { generic_fptr_t fptr; void* ptr; } originalFunc;
+        union { generic_fptr_t fptr; void * ptr; } originalFunc;
 
         #if defined( _GNU_SOURCE )
@@ -73 +70 @@
 }
 
-forall(dtype T)
-static inline void ptr_from_symbol( T** symbol_ptr, const char * symbol_name, const char * version) {
-        union {
-                generic_fptr_t gp;
-                T* tp;
-        } u;
-
-        u.gp = interpose_symbol( symbol_name, version );
-
-        *symbol_ptr = u.tp;
-}
-
-#define INTERPOSE_LIBC( x, ver ) ptr_from_symbol( (void**)&__cabi_libc.x, #x, ver)
-
-//=============================================================================================
-// Terminating Signals logic
+#define INTERPOSE_LIBC( x, ver ) __cabi_libc.x = (typeof(__cabi_libc.x))interpose_symbol( #x, ver )
+
+//=============================================================================================
+// Interposition Startup logic
 //=============================================================================================
 
@@ -98 +83 @@
 
 struct {
-        void (* exit)( int ) __attribute__ (( __noreturn__ ));
-        void (* abort)( void ) __attribute__ (( __noreturn__ ));
+        void (* exit)( int ) __attribute__(( __noreturn__ ));
+        void (* abort)( void ) __attribute__(( __noreturn__ ));
 } __cabi_libc;
 
@@ -107 +92 @@
                 const char *version = NULL;
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdiscarded-qualifiers"
                 INTERPOSE_LIBC( abort, version );
                 INTERPOSE_LIBC( exit , version );
-
-                __cfaabi_sigaction( SIGSEGV, sigHandler_segv , SA_SIGINFO ); // Failure handler
-                __cfaabi_sigaction( SIGBUS , sigHandler_segv , SA_SIGINFO ); // Failure handler
-                __cfaabi_sigaction( SIGILL , sigHandler_ill  , SA_SIGINFO ); // Failure handler
-                __cfaabi_sigaction( SIGFPE , sigHandler_fpe  , SA_SIGINFO ); // Failure handler
-                __cfaabi_sigaction( SIGABRT, sigHandler_abort, SA_SIGINFO ); // Failure handler
-                __cfaabi_sigaction( SIGTERM, sigHandler_term , SA_SIGINFO ); // Failure handler
-                __cfaabi_sigaction( SIGINT , sigHandler_term , SA_SIGINFO ); // Failure handler
+#pragma GCC diagnostic pop
+
+                // Failure handler
+                __cfaabi_sigaction( SIGSEGV, sigHandler_segv , SA_SIGINFO );
+                __cfaabi_sigaction( SIGBUS , sigHandler_segv , SA_SIGINFO );
+                __cfaabi_sigaction( SIGILL , sigHandler_ill  , SA_SIGINFO );
+                __cfaabi_sigaction( SIGFPE , sigHandler_fpe  , SA_SIGINFO );
+                __cfaabi_sigaction( SIGABRT, sigHandler_abort, SA_SIGINFO | SA_RESETHAND);
+                __cfaabi_sigaction( SIGTERM, sigHandler_term , SA_SIGINFO );
+                __cfaabi_sigaction( SIGINT , sigHandler_term , SA_SIGINFO );
         }
 }
@@ -125 +114 @@
 
 // Forward declare abort after the __typeof__ call to avoid ambiguities
-void exit( int status, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
-void abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
+void exit( int status, const char fmt[], ... ) __attribute__(( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
+void abort( const char fmt[], ... ) __attribute__(( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
 
 extern "C" {
-        void abort( void ) __attribute__ (( __nothrow__, __leaf__, __noreturn__ )) {
+        void abort( void ) __attribute__(( __nothrow__, __leaf__, __noreturn__ )) {
                 abort( NULL );
         }
 
-        void __cabi_abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ )) {
+        void __cabi_abort( const char fmt[], ... ) __attribute__(( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ )) {
                 va_list argp;
                 va_start( argp, fmt );
@@ -140 +129 @@
         }
 
-        void exit( int status ) __attribute__ (( __nothrow__, __leaf__, __noreturn__ )) {
+        void exit( int status ) __attribute__(( __nothrow__, __leaf__, __noreturn__ )) {
                 __cabi_libc.exit( status );
         }
 }
 
-void * kernel_abort    ( void ) __attribute__ (( __nothrow__, __leaf__, __weak__ )) { return NULL; }
-void   kernel_abort_msg( void * data, char * buffer, int size ) __attribute__ (( __nothrow__, __leaf__, __weak__ )) {}
-int kernel_abort_lastframe( void ) __attribute__ (( __nothrow__, __leaf__, __weak__ )) { return 4; }
+void * kernel_abort    ( void ) __attribute__(( __nothrow__, __leaf__, __weak__ )) { return NULL; }
+void   kernel_abort_msg( void * data, char * buffer, int size ) __attribute__(( __nothrow__, __leaf__, __weak__ )) {}
+int kernel_abort_lastframe( void ) __attribute__(( __nothrow__, __leaf__, __weak__ )) { return 4; }
 
 enum { abort_text_size = 1024 };
@@ -153 +142 @@
 static int abort_lastframe;
 
-void exit( int status, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ )) {
+void exit( int status, const char fmt[], ... ) __attribute__(( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ )) {
     va_list args;
     va_start( args, fmt );
@@ -161 +150 @@
 }
 
-void abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ )) {
+void abort( const char fmt[], ... ) __attribute__(( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ )) {
         void * kernel_data = kernel_abort();                    // must be done here to lock down kernel
         int len;

src/libcfa/stdlib

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jan  2 12:21:04 2018
-// Update Count     : 292
+// Last Modified On : Sun May 13 23:22:23 2018
+// Update Count     : 299
 //
 
 #pragma once
 
-//#define _XOPEN_SOURCE 600                                                             // posix_memalign, *rand48
+#define __USE_ISOC11                                                                    // aligned_alloc
 #include <stdlib.h>                                                                             // strto*, *abs
 
@@ -28 +28 @@
 //---------------------------------------
 
-// allocation, non-array types
-static inline forall( dtype T | sized(T) ) T * malloc( void ) {
-        // printf( "* malloc\n" );
-        return (T *)(void *)malloc( (size_t)sizeof(T) );        // C malloc
-} // malloc
-
-// static inline forall( dtype T | sized(T) ) T & malloc( void ) {
-//      int & p = *(T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
-//      printf( "& malloc %p\n", &p );
-//      return p;
-// //   return (T &)*(T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
-// } // malloc
-
-extern "C" { void * calloc( size_t dim, size_t size ); } // default C routine
-static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) {
-        //printf( "X2\n" );
-        return (T *)(void *)calloc( dim, sizeof(T) );           // C cmalloc
-}
-
-extern "C" { void * realloc( void * ptr, size_t size ); } // default C routine for void *
-static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) {
-        //printf( "X3\n" );
-        return (T *)(void *)realloc( (void *)ptr, size );
-}
-
-extern "C" { void * memalign( size_t align, size_t size ); } // use default C routine for void *
-static inline forall( dtype T | sized(T) ) T * memalign( size_t align ) {
-        //printf( "X4\n" );
-        return (T *)memalign( align, sizeof(T) );
-} // memalign
-
-static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t align ) {
-        //printf( "X5\n" );
-        return (T *)memalign( align, sizeof(T) );
-} // aligned_alloc
-
-extern "C" { int posix_memalign( void ** ptr, size_t align, size_t size ); } // use default C routine for void *
-static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t align ) {
-        //printf( "X6\n" );
-        return posix_memalign( (void **)ptr, align, sizeof(T) );
-} // posix_memalign
-
-
-extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void *
-
-static inline forall( dtype T | sized(T) ) T * alloc( void ) {
-        //printf( "X7\n" );
-        return (T *)(void *)malloc( (size_t)sizeof(T) );        // C malloc
-} // alloc
-static inline forall( dtype T | sized(T) ) T * alloc( char fill ) {
-        //printf( "X8\n" );
-        T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );     // C malloc
-    return (T *)memset( ptr, (int)fill, sizeof(T) );    // initial with fill value
-} // alloc
-
-static inline forall( dtype T | sized(T) ) T * alloc( size_t dim ) {
-        //printf( "X9\n" );
-        return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
-} // alloc
-static inline forall( dtype T | sized(T) ) T * alloc( size_t dim, char fill ) {
-        //printf( "X10\n" );
-        T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
-    return (T *)memset( ptr, (int)fill, dim * sizeof(T) );
-} // alloc
-
-static inline forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim ) {
-        //printf( "X11\n" );
-        return (T *)(void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
-} // alloc
+// C dynamic allocation
+static inline forall( dtype T | sized(T) ) {
+        T * malloc( void ) {
+                // printf( "* malloc\n" );
+                return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+        } // malloc
+
+        // T & malloc( void ) {
+        //      int & p = *(T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+        //      printf( "& malloc %p\n", &p );
+        //      return p;
+        //      //      return (T &)*(T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+        // } // malloc
+
+        T * calloc( size_t dim ) {
+                //printf( "X2\n" );
+                return (T *)(void *)calloc( dim, sizeof(T) );   // C calloc
+        } // calloc
+
+        T * realloc( T * ptr, size_t size ) {
+                //printf( "X3\n" );
+                return (T *)(void *)realloc( (void *)ptr, size );
+        } // realloc
+
+        extern "C" { void * memalign( size_t align, size_t size ); } // use default C routine for void *
+        T * memalign( size_t align ) {
+                //printf( "X4\n" );
+                return (T *)memalign( align, sizeof(T) );
+        } // memalign
+
+        extern "C" { void * aligned_alloc( size_t align, size_t size ); } // use default C routine for void *
+        T * aligned_alloc( size_t align ) {
+                //printf( "X5\n" );
+                return (T *)aligned_alloc( align, sizeof(T) );
+        } // aligned_alloc
+
+        int posix_memalign( T ** ptr, size_t align ) {
+                //printf( "X6\n" );
+                return posix_memalign( (void **)ptr, align, sizeof(T) ); // C posix_memalign
+        } // posix_memalign
+
+
+        // Cforall dynamic allocation
+        extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void *
+
+        T * alloc( void ) {
+                //printf( "X7\n" );
+                return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+        } // alloc
+
+        T * alloc( char fill ) {
+                //printf( "X8\n" );
+                T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );     // C malloc
+                return (T *)memset( ptr, (int)fill, sizeof(T) );        // initial with fill value
+        } // alloc
+
+        T * alloc( size_t dim ) {
+                //printf( "X9\n" );
+                return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
+        } // alloc
+
+        T * alloc( size_t dim, char fill ) {
+                //printf( "X10\n" );
+                T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
+                return (T *)memset( ptr, (int)fill, dim * sizeof(T) );    // initial with fill value
+        } // alloc
+
+        T * alloc( T ptr[], size_t dim ) {
+                //printf( "X11\n" );
+                return (T *)(void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
+        } // alloc
+} // distribution
+
+
 forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
 

src/libcfa/time.c

@@ -10 +10 @@
 // Created On       : Tue Mar 27 13:33:14 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Apr 12 14:41:00 2018
-// Update Count     : 22
+// Last Modified On : Sun May  6 22:26:00 2018
+// Update Count     : 37
 // 
 
@@ -17 +17 @@
 #include "iostream"
 #include <stdio.h>                                                                              // snprintf
+#include <assert.h>
 
 static char * nanomsd( long int ns, char * buf ) {              // most significant digits
@@ -87 +88 @@
         time_t s = tv / TIMEGRAN;
         tm tm;
-        gmtime_r( &s, &tm );
+        gmtime_r( &s, &tm );                                                            // tm_mon <= 11, tm_mday <= 31
+#if defined(__GNUC__) && __GNUC__ >= 7
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat-truncation"
+#endif
         snprintf( buf, 9, "%02d/%02d/%02d", tm.tm_year % 99, tm.tm_mon + 1, tm.tm_mday );
+#if defined(__GNUC__) && __GNUC__ >= 7
+#pragma GCC diagnostic pop
+#endif
         return buf;
 } // yy_mm_dd
@@ -95 +103 @@
         time_t s = tv / TIMEGRAN;
         tm tm;
-        gmtime_r( &s, &tm );
+        gmtime_r( &s, &tm );                                                            // tm_mon <= 11, tm_mday <= 31
+#if defined(__GNUC__) && __GNUC__ >= 7
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat-truncation"
+#endif
         snprintf( buf, 9, "%02d/%02d/%02d", tm.tm_mon + 1, tm.tm_mday, tm.tm_year % 99 );
+#if defined(__GNUC__) && __GNUC__ >= 7
+#pragma GCC diagnostic pop
+#endif
         return buf;
 } // mm_dd_yy
@@ -103 +118 @@
         time_t s = tv / TIMEGRAN;
         tm tm;
-        gmtime_r( &s, &tm );
+        gmtime_r( &s, &tm );                                                            // tm_mon <= 11, tm_mday <= 31
+#if defined(__GNUC__) && __GNUC__ >= 7
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat-truncation"
+#endif
         snprintf( buf, 9, "%02d/%02d/%02d", tm.tm_mday, tm.tm_mon + 1, tm.tm_year % 99 );
+#if defined(__GNUC__) && __GNUC__ >= 7
+#pragma GCC diagnostic pop
+#endif
         return buf;
 } // dd_mm_yy

src/main.cc

@@ -10 +10 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed May  2 14:59:02 2018
-// Update Count     : 490
+// Last Modified On : Mon May  7 14:35:57 2018
+// Update Count     : 492
 //
 
@@ -64 +64 @@
 
 #define PASS(name, pass)                   \
-        if ( errorp ) { cerr << #name << endl; } \
-        HeapStats::newPass(#name);               \
+        if ( errorp ) { cerr << name << endl; } \
+        HeapStats::newPass(name);               \
         pass;
 
@@ -371 +371 @@
                 } // if
                 return 1;
-        } // try
+        } catch(...) {
+                std::exception_ptr eptr = std::current_exception();
+                try {
+                        if (eptr) {
+                                std::rethrow_exception(eptr);
+                        }
+                        else {
+                                std::cerr << "Exception Uncaught and Unkown" << std::endl;
+                        }
+                } catch(const std::exception& e) {
+                        std::cerr << "Unaught Exception \"" << e.what() << "\"\n";
+                }
+                return 1;
+        }// try
 
         deleteAll( translationUnit );
-        HeapStats::printStats();
+        if(!libcfap && !treep) HeapStats::printStats();
         return 0;
 } // main
@@ -407 +420 @@
         opterr = 0;                                                                                     // (global) prevent getopt from printing error messages
 
-        bool Werror = false;
+        bool Wsuppress = false, Werror = false;
         int c;
         while ( (c = getopt_long( argc, argv, "abBcCdefgGlLmnNpqrstTvwW:yzZD:F:", long_opts, &long_index )) != -1 ) {
@@ -495 +508 @@
                         break;
                   case 'w':
-                        SemanticWarning_SuppressAll();
+                        Wsuppress = true;
                         break;
                   case 'W':
@@ -534 +547 @@
                                 assertf( false, "Unknown option: %s\n", argv[optind - 1] );
                         } // if
-                        #if __GNUC__ < 7
-                        #else
+                        #if defined(__GNUC__) && __GNUC__ >= 7
                                 __attribute__((fallthrough));
                         #endif
@@ -545 +557 @@
         if ( Werror ) {
                 SemanticWarning_WarningAsError();
+        } // if
+        if ( Wsuppress ) {
+                SemanticWarning_SuppressAll();
         } // if
         // for ( const auto w : WarningFormats ) {

src/tests/coroutine/fmtLines.c

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 // 
-// fmtLines.cc -- 
+// fmtLines.cc -- format characters into blocks of 4 and groups of 5 blocks per line
 // 
 // Author           : Peter A. Buhr
 // Created On       : Sun Sep 17 21:56:15 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Dec  5 21:56:35 2017
-// Update Count     : 38
+// Last Modified On : Tue May 15 12:25:33 2018
+// Update Count     : 42
 // 
 
@@ -21 +21 @@
         int g, b;                                                                                       // global because used in destructor
 };
-
-void ?{}( Format & fmt ) {
-        resume( fmt );                                                                          // prime (start) coroutine
-}
-
-void ^?{}( Format & fmt ) with( fmt ) {
-        if ( g != 0 || b != 0 ) sout | endl;
-}
 
 void main( Format & fmt ) with( fmt ) {
@@ -46 +38 @@
 } // main
 
-void prt( Format & fmt, char ch ) {
-        fmt.ch = ch;
+void ?{}( Format & fmt ) {
+        resume( fmt );                                                                          // prime (start) coroutine
+}
+
+void ^?{}( Format & fmt ) with( fmt ) {
+        if ( g != 0 || b != 0 ) sout | endl;
+}
+
+void format( Format & fmt ) {
         resume( fmt );
 } // prt
 
 int main() {
-        Format fmt;                                                                                     // format characters into blocks of 4 and groups of 5 blocks per line
-        char ch;
+        Format fmt;
 
-        Eof: for ( ;; ) {                                                                       // read until end of file
-                sin | ch;                                                                               // read one character
-          if ( eof( sin ) ) break Eof;                                          // eof ?
-                prt( fmt, ch );                                                                 // push character for formatting
+        eof: for ( ;; ) {                                                                       // read until end of file
+                sin | fmt.ch;                                                                   // read one character
+          if ( eof( sin ) ) break eof;                                          // eof ?
+                format( fmt );                                                                  // push character for formatting
         } // for
 } // main