Changeset 9c35431 for src

Timestamp:

Nov 29, 2017, 2:00:32 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

c13e8dc8

Parents:

c6e2c18 (diff), 389528b0 (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' into cleanup-dtors

Location:

src

Files:

• Concurrency/Waitfor.cc (modified) (1 diff)
• GenPoly/InstantiateGeneric.cc (modified) (5 diffs)
• Parser/ParseNode.h (modified) (2 diffs)
• Parser/parser.yy (modified) (3 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• SynTree/Expression.cc (modified) (1 diff)
• benchmark/Makefile.am (modified) (7 diffs)
• benchmark/Makefile.in (modified) (6 diffs)
• benchmark/bench.h (modified) (2 diffs)
• benchmark/creation/JavaThread.java (added)
• benchmark/creation/goroutine.go (added)
• benchmark/ctxswitch/JavaThread.java (added)
• benchmark/ctxswitch/goroutine.go (added)
• benchmark/mutex/JavaThread.java (added)
• benchmark/mutex/fetch_add.c (added)
• benchmark/schedint/JavaThread.java (added)
• libcfa/Makefile.am (modified) (1 diff)
• libcfa/Makefile.in (modified) (2 diffs)
• libcfa/bits/containers.h (modified) (10 diffs)
• libcfa/bits/defs.h (modified) (2 diffs)
• libcfa/bits/locks.h (modified) (1 diff)
• libcfa/concurrency/invoke.h (modified) (8 diffs)
• libcfa/concurrency/kernel (modified) (2 diffs)
• libcfa/concurrency/kernel.c (modified) (2 diffs)
• libcfa/concurrency/monitor (modified) (6 diffs)
• libcfa/concurrency/monitor.c (modified) (17 diffs)
• libcfa/exception.h (modified) (2 diffs)
• libcfa/stdhdr/assert.h (modified) (3 diffs)
• libcfa/virtual.h (modified) (2 diffs)
• tests/.expect/32/functions.txt (added)
• tests/.expect/64/functions.txt (added)
• tests/Makefile.am (modified) (2 diffs)
• tests/Makefile.in (modified) (1 diff)
• tests/designations.c (modified) (1 diff)
• tests/functions.c (modified) (3 diffs)

src/Concurrency/Waitfor.cc

@@ -416 +416 @@
                                 makeAccStatement( acceptables, index, "is_dtor", detectIsDtor( clause.target.function )                                    , indexer ),
                                 makeAccStatement( acceptables, index, "func"   , new CastExpr( clause.target.function, fptr_t )                            , indexer ),
-                                makeAccStatement( acceptables, index, "list"   , new VariableExpr( monitors )                                              , indexer ),
+                                makeAccStatement( acceptables, index, "data"   , new VariableExpr( monitors )                                              , indexer ),
                                 makeAccStatement( acceptables, index, "size"   , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ), indexer ),
                                 setter->clone()

src/GenPoly/InstantiateGeneric.cc

@@ -21 +21 @@
 #include <vector>                      // for vector
 
+#include "CodeGen/OperatorTable.h"
 #include "Common/PassVisitor.h"        // for PassVisitor, WithDeclsToAdd
 #include "Common/ScopedMap.h"          // for ScopedMap
@@ -27 +28 @@
 #include "Common/utility.h"            // for deleteAll, cloneAll
 #include "GenPoly.h"                   // for isPolyType, typesPolyCompatible
+#include "InitTweak/InitTweak.h"
 #include "ResolvExpr/typeops.h"
 #include "ScopedSet.h"                 // for ScopedSet, ScopedSet<>::iterator
@@ -154 +156 @@
 
         /// Add cast to dtype-static member expressions so that type information is not lost in GenericInstantiator
-        struct FixDtypeStatic final {
+        struct FixDtypeStatic final : public WithGuards, public WithVisitorRef<FixDtypeStatic>, public WithShortCircuiting, public WithStmtsToAdd {
                 Expression * postmutate( MemberExpr * memberExpr );
+
+                void premutate( ApplicationExpr * appExpr );
+                void premutate( AddressExpr * addrExpr );
 
                 template<typename AggrInst>
                 Expression * fixMemberExpr( AggrInst * inst, MemberExpr * memberExpr );
+
+                bool isLvalueArg = false;
         };
 
@@ -501 +508 @@
                 if ( isDtypeStatic( baseParams ) ) {
                         if ( ! ResolvExpr::typesCompatible( memberExpr->result, memberExpr->member->get_type(), SymTab::Indexer() ) ) {
-                                // type of member and type of expression differ, so add cast to actual type
-                                return new CastExpr( memberExpr, memberExpr->result->clone() );
+                                // type of member and type of expression differ
+                                Type * concType = memberExpr->result->clone();
+                                if ( isLvalueArg ) {
+                                        // result must be C lvalue, so make a new reference variable with the correct actual type to replace the member expression
+                                        //   forall(dtype T)
+                                        //   struct Ptr {
+                                        //     T * x
+                                        //   };
+                                        //   Ptr(int) p;
+                                        //   int i;
+                                        //   p.x = &i;
+                                        // becomes
+                                        //   int *& _dtype_static_member_0 = (int **)&p.x;
+                                        //   _dtype_static_member_0 = &i;
+                                        // Note: this currently creates more temporaries than is strictly necessary, since it does not check for duplicate uses of the same member expression.
+                                        static UniqueName tmpNamer( "_dtype_static_member_" );
+                                        Expression * init = new CastExpr( new AddressExpr( memberExpr ), new PointerType( Type::Qualifiers(), concType->clone() ) );
+                                        ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), new ReferenceType( Type::Qualifiers(), concType ), new SingleInit( init ) );
+                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, tmp ) );
+                                        return new VariableExpr( tmp );
+                                } else {
+                                        // can simply add a cast to actual type
+                                        return new CastExpr( memberExpr, concType );
+                                }
                         }
                 }
@@ -520 +549 @@
         }
 
+        void FixDtypeStatic::premutate( ApplicationExpr * appExpr ) {
+                GuardValue( isLvalueArg );
+                isLvalueArg = false;
+                DeclarationWithType * function = InitTweak::getFunction( appExpr );
+                if ( function->linkage == LinkageSpec::Intrinsic && CodeGen::isAssignment( function->name ) ) {
+                        // explicitly visit children because only the first argument must be a C lvalue.
+                        visit_children = false;
+                        appExpr->env = maybeMutate( appExpr->env, *visitor );
+                        appExpr->result = maybeMutate( appExpr->result, *visitor );
+                        appExpr->function = maybeMutate( appExpr->function, *visitor );
+                        isLvalueArg = true;
+                        for ( Expression * arg : appExpr->args ) {
+                                arg = maybeMutate( arg, *visitor );
+                                isLvalueArg = false;
+                        }
+                }
+        }
+
+        void FixDtypeStatic::premutate( AddressExpr * ) {
+                // argument of & must be C lvalue
+                GuardValue( isLvalueArg );
+                isLvalueArg = true;
+        }
 } // namespace GenPoly
 

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Sep 23 18:11:22 2017
-// Update Count     : 821
+// Last Modified On : Mon Nov 27 17:33:35 2017
+// Update Count     : 824
 //
 
@@ -292 +292 @@
         DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
   public:
+        DeclarationNode * get_last() { return (DeclarationNode *)ParseNode::get_last(); }
+
         struct Variable_t {
 //              const std::string * name;

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Nov 26 11:36:36 2017
-// Update Count     : 2969
+// Last Modified On : Mon Nov 27 17:23:35 2017
+// Update Count     : 2992
 //
 
@@ -1364 +1364 @@
                         $$ = $3->addQualifiers( $1 )->addQualifiers( $2 );
                 }
-        | cfa_function_declaration pop ',' push identifier_or_type_name
-                {
-                        typedefTable.addToEnclosingScope( *$5, TypedefTable::ID );
-                        $$ = $1->appendList( $1->cloneType( $5 ) );
+        | cfa_function_declaration pop ',' push identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')'
+                {
+                        // Append the return type at the start (left-hand-side) to each identifier in the list.
+                        DeclarationNode * ret = new DeclarationNode;
+                        ret->type = maybeClone( $1->type->base );
+                        $$ = $1->appendList( DeclarationNode::newFunction( $5, ret, $8, nullptr, true ) );
                 }
         ;
@@ -2416 +2418 @@
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
-                        $$ = $1->addFunctionBody( $3 );
+                        // Add the function body to the last identifier in the function definition list, i.e., foo3:
+                        //   [const double] foo1(), foo2( int ), foo3( double ) { return 3.0; }
+                        $1->get_last()->addFunctionBody( $3 );
+                        $$ = $1;
                 }
         | declaration_specifier function_declarator with_clause_opt compound_statement

src/ResolvExpr/AlternativeFinder.cc

@@ -897 +897 @@
                 // sum cost and accumulate actuals
                 std::list<Expression*>& args = appExpr->get_args();
-                Cost cost = Cost::zero;
+                Cost cost = func.cost;
                 const ArgPack* pack = &result;
                 while ( pack->expr ) {

src/SynTree/Expression.cc

@@ -356 +356 @@
         Type * res = member->get_type()->clone();
         sub.apply( res );
-        set_result( res );
-        get_result()->set_lvalue( true );
+        result = res;
+        result->set_lvalue( true );
+        result->get_qualifiers() |= aggregate->result->get_qualifiers();
 }
 

src/benchmark/Makefile.am

@@ -94 +94 @@
         ctxswitch-cfa_thread.run        \
         ctxswitch-upp_coroutine.run     \
-        ctxswitch-upp_thread.run
+        ctxswitch-upp_thread.run        \
+        ctxswitch-goroutine.run         \
+        ctxswitch-java_thread.run
 
 ctxswitch-cfa_coroutine$(EXEEXT):
@@ -111 +113 @@
         @@BACKEND_CC@ ctxswitch/pthreads.c  -DBENCH_N=50000000  -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
+ctxswitch-goroutine$(EXEEXT):
+        @go build -o a.out ctxswitch/goroutine.go
+
+ctxswitch-java_thread$(EXEEXT):
+        @javac ctxswitch/JavaThread.java
+        @echo "#!/bin/sh" > a.out
+        @echo "cd ctxswitch && java JavaThread" >> a.out
+        @chmod a+x a.out
+
 ## =========================================================================================================
 mutex$(EXEEXT) :\
         mutex-function.run      \
+        mutex-fetch_add.run     \
         mutex-pthread_lock.run  \
         mutex-upp.run           \
         mutex-cfa1.run          \
         mutex-cfa2.run          \
-        mutex-cfa4.run
+        mutex-cfa4.run          \
+        mutex-java_thread.run
 
 mutex-function$(EXEEXT):
         @@BACKEND_CC@ mutex/function.c    -DBENCH_N=500000000   -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
+mutex-fetch_add$(EXEEXT):
+        @@BACKEND_CC@ mutex/fetch_add.c   -DBENCH_N=500000000   -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+
 mutex-pthread_lock$(EXEEXT):
         @@BACKEND_CC@ mutex/pthreads.c    -DBENCH_N=50000000    -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
@@ -137 +153 @@
 mutex-cfa4$(EXEEXT):
         @${CC}        mutex/cfa4.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+
+mutex-java_thread$(EXEEXT):
+        @javac mutex/JavaThread.java
+        @echo "#!/bin/sh" > a.out
+        @echo "cd mutex && java JavaThread" >> a.out
+        @chmod a+x a.out
 
 ## =========================================================================================================
@@ -143 +165 @@
         signal-cfa1.run         \
         signal-cfa2.run         \
-        signal-cfa4.run
+        signal-cfa4.run         \
+        signal-java_thread.run
 
 signal-upp$(EXEEXT):
@@ -156 +179 @@
 signal-cfa4$(EXEEXT):
         @${CC}        schedint/cfa4.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+
+signal-java_thread$(EXEEXT):
+        @javac schedint/JavaThread.java
+        @echo "#!/bin/sh" > a.out
+        @echo "cd schedint && java JavaThread" >> a.out
+        @chmod a+x a.out
+
 
 ## =========================================================================================================
@@ -183 +213 @@
         creation-cfa_thread.run                 \
         creation-upp_coroutine.run              \
-        creation-upp_thread.run
+        creation-upp_thread.run                 \
+        creation-goroutine.run                  \
+        creation-java_thread.run
 
 creation-cfa_coroutine$(EXEEXT):
@@ -202 +234 @@
 creation-pthread$(EXEEXT):
         @@BACKEND_CC@ creation/pthreads.c  -DBENCH_N=250000     -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+
+creation-goroutine$(EXEEXT):
+        @go build -o a.out creation/goroutine.go
+
+creation-java_thread$(EXEEXT):
+        @javac creation/JavaThread.java
+        @echo "#!/bin/sh" > a.out
+        @echo "cd creation && java JavaThread" >> a.out
+        @chmod a+x a.out
 
 ## =========================================================================================================

src/benchmark/Makefile.in

@@ -507 +507 @@
         ctxswitch-cfa_thread.run        \
         ctxswitch-upp_coroutine.run     \
-        ctxswitch-upp_thread.run
+        ctxswitch-upp_thread.run        \
+        ctxswitch-goroutine.run         \
+        ctxswitch-java_thread.run
 
 ctxswitch-cfa_coroutine$(EXEEXT):
@@ -524 +526 @@
         @@BACKEND_CC@ ctxswitch/pthreads.c  -DBENCH_N=50000000  -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
+ctxswitch-goroutine$(EXEEXT):
+        @go build -o a.out ctxswitch/goroutine.go
+
+ctxswitch-java_thread$(EXEEXT):
+        @javac ctxswitch/JavaThread.java
+        @echo "#!/bin/sh" > a.out
+        @echo "cd ctxswitch && java JavaThread" >> a.out
+        @chmod a+x a.out
+
 mutex$(EXEEXT) :\
         mutex-function.run      \
+        mutex-fetch_add.run     \
         mutex-pthread_lock.run  \
         mutex-upp.run           \
         mutex-cfa1.run          \
         mutex-cfa2.run          \
-        mutex-cfa4.run
+        mutex-cfa4.run          \
+        mutex-java_thread.run
 
 mutex-function$(EXEEXT):
         @@BACKEND_CC@ mutex/function.c    -DBENCH_N=500000000   -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
+mutex-fetch_add$(EXEEXT):
+        @@BACKEND_CC@ mutex/fetch_add.c   -DBENCH_N=500000000   -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+
 mutex-pthread_lock$(EXEEXT):
         @@BACKEND_CC@ mutex/pthreads.c    -DBENCH_N=50000000    -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
@@ -549 +565 @@
 mutex-cfa4$(EXEEXT):
         @${CC}        mutex/cfa4.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+
+mutex-java_thread$(EXEEXT):
+        @javac mutex/JavaThread.java
+        @echo "#!/bin/sh" > a.out
+        @echo "cd mutex && java JavaThread" >> a.out
+        @chmod a+x a.out
 
 signal$(EXEEXT) :\
@@ -567 +589 @@
 signal-cfa4$(EXEEXT):
         @${CC}        schedint/cfa4.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+
+signal-java_thread$(EXEEXT):
+        @javac schedint/JavaThread.java
+        @echo "#!/bin/sh" > a.out
+        @echo "cd schedint && java JavaThread" >> a.out
+        @chmod a+x a.out
 
 waitfor$(EXEEXT) :\
@@ -592 +620 @@
         creation-cfa_thread.run                 \
         creation-upp_coroutine.run              \
-        creation-upp_thread.run
+        creation-upp_thread.run                 \
+        creation-goroutine.run                  \
+        creation-java_thread.run
 
 creation-cfa_coroutine$(EXEEXT):
@@ -611 +641 @@
 creation-pthread$(EXEEXT):
         @@BACKEND_CC@ creation/pthreads.c  -DBENCH_N=250000     -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+
+creation-goroutine$(EXEEXT):
+        @go build -o a.out creation/goroutine.go
+
+creation-java_thread$(EXEEXT):
+        @javac creation/JavaThread.java
+        @echo "#!/bin/sh" > a.out
+        @echo "cd creation && java JavaThread" >> a.out
+        @chmod a+x a.out
 
 compile$(EXEEXT) :\

src/benchmark/bench.h

@@ -1 +1 @@
 #pragma once
 
-#if defined(__CFORALL__)
+#if defined(__cforall)
 extern "C" {
 #endif
@@ -8 +8 @@
         #include <sys/times.h>                                  // times
         #include <time.h>
-#if defined(__CFORALL__)
+#if defined(__cforall)
 }
 #endif

src/libcfa/Makefile.am

@@ -100 +100 @@
         math                            \
         gmp                             \
+        bits/containers.h               \
         bits/defs.h             \
         bits/locks.h            \

src/libcfa/Makefile.in

@@ -264 +264 @@
         containers/result containers/vector concurrency/coroutine \
         concurrency/thread concurrency/kernel concurrency/monitor \
-        ${shell echo stdhdr/*} math gmp bits/defs.h bits/locks.h \
-        concurrency/invoke.h libhdr.h libhdr/libalign.h \
+        ${shell echo stdhdr/*} math gmp bits/containers.h bits/defs.h \
+        bits/locks.h concurrency/invoke.h libhdr.h libhdr/libalign.h \
         libhdr/libdebug.h libhdr/libtools.h
 HEADERS = $(nobase_cfa_include_HEADERS)
@@ -437 +437 @@
         math                            \
         gmp                             \
+        bits/containers.h               \
         bits/defs.h             \
         bits/locks.h            \

src/libcfa/bits/containers.h

@@ -15 +15 @@
 #pragma once
 
-#include <stddef.h>
+#include "bits/defs.h"
+#include "libhdr.h"
 
-#include "libhdr.h"
+//-----------------------------------------------------------------------------
+// Array
+//-----------------------------------------------------------------------------
+
+#ifdef __cforall
+        forall(dtype T)
+#else
+        #define T void
+#endif
+struct __small_array {
+        T *           data;
+        __lock_size_t size;
+};
+#undef T
+
+#ifdef __cforall
+        #define __small_array_t(T) __small_array(T)
+#else
+        #define __small_array_t(T) struct __small_array
+#endif
+
+#ifdef __cforall
+        // forall(otype T | sized(T))
+        // static inline void ?{}(__small_array(T) & this) {}
+
+        forall(dtype T | sized(T))
+        static inline T& ?[?]( __small_array(T) & this, __lock_size_t idx) {
+                return ((typeof(this.data))this.data)[idx];
+        }
+
+        forall(dtype T | sized(T))
+        static inline T& ?[?]( const __small_array(T) & this, __lock_size_t idx) {
+                return ((typeof(this.data))this.data)[idx];
+        }
+
+        forall(dtype T | sized(T))
+        static inline T* begin( const __small_array(T) & this ) {
+                return ((typeof(this.data))this.data);
+        }
+
+        forall(dtype T | sized(T))
+        static inline T* end( const __small_array(T) & this ) {
+                return ((typeof(this.data))this.data) + this.size;
+        }
+#endif
 
 //-----------------------------------------------------------------------------
@@ -23 +68 @@
 //-----------------------------------------------------------------------------
 
-#ifdef __CFORALL__
+#ifdef __cforall
         trait is_node(dtype T) {
                 T*& get_next( T& );
@@ -32 +77 @@
 // Stack
 //-----------------------------------------------------------------------------
-#ifdef __CFORALL__
+#ifdef __cforall
         forall(dtype TYPE | is_node(TYPE))
         #define T TYPE
@@ -41 +86 @@
         T * top;
 };
+#undef T
 
-#ifdef __CFORALL__
+#ifdef __cforall
 #define __stack_t(T) __stack(T)
 #else
@@ -48 +94 @@
 #endif
 
-#ifdef __CFORALL__
+#ifdef __cforall
         forall(dtype T | is_node(T))
-        void ?{}( __stack(T) & this ) {
-                this.top = NULL;
+        static inline void ?{}( __stack(T) & this ) {
+                (this.top){ NULL };
         }
 
         forall(dtype T | is_node(T) | sized(T))
-        void push( __stack(T) & this, T * val ) {
+        static inline void push( __stack(T) & this, T * val ) {
                 verify( !get_next( *val ) );
                 get_next( *val ) = this.top;
@@ -62 +108 @@
 
         forall(dtype T | is_node(T) | sized(T))
-        T * pop( __stack(T) & this ) {
+        static inline T * pop( __stack(T) & this ) {
                 T * top = this.top;
                 if( top ) {
@@ -75 +121 @@
 // Queue
 //-----------------------------------------------------------------------------
-#ifdef __CFORALL__
-        forall(dtype T | is_node(T))
+#ifdef __cforall
+        forall(dtype TYPE | is_node(TYPE))
         #define T TYPE
 #else
@@ -85 +131 @@
         T ** tail;
 };
+#undef T
 
-#ifdef __CFORALL__
+#ifdef __cforall
+#define __queue_t(T) __queue(T)
+#else
+#define __queue_t(T) struct __queue
+#endif
+
+#ifdef __cforall
         forall(dtype T | is_node(T))
-        void ?{}( __queue(T) & this ) {
-                this.head = NULL;
-                this.tail = &this.head;
+        static inline void ?{}( __queue(T) & this ) {
+                (this.head){ NULL };
+                (this.tail){ &this.head };
         }
 
         forall(dtype T | is_node(T) | sized(T))
-        void append( __queue(T) & this, T * val ) {
+        static inline void append( __queue(T) & this, T * val ) {
                 verify(this.tail != NULL);
                 *this.tail = val;
@@ -101 +154 @@
 
         forall(dtype T | is_node(T) | sized(T))
-        T * pop_head( __queue(T) & this ) {
+        static inline T * pop_head( __queue(T) & this ) {
                 T * head = this.head;
                 if( head ) {
@@ -114 +167 @@
 
         forall(dtype T | is_node(T) | sized(T))
-        T * remove( __queue(T) & this, T ** it ) {
+        static inline T * remove( __queue(T) & this, T ** it ) {
                 T * val = *it;
                 verify( val );

src/libcfa/bits/defs.h

@@ -17 +17 @@
 
 #include <stdbool.h>
+#include <stddef.h>
 #include <stdint.h>
 
@@ -22 +23 @@
 #define likely  (x)    __builtin_expect(!!(x), 1)
 #define thread_local _Thread_local
+
+typedef void (*fptr_t)();
+typedef int_fast16_t __lock_size_t;
+
+#ifdef __cforall
+#define __cfa_anonymous_object
+#else
+#define __cfa_anonymous_object __cfa_anonymous_object
+#endif

src/libcfa/bits/locks.h

@@ -56 +56 @@
 } __ALIGN__;
 
-#ifdef __CFORALL__
+#ifdef __cforall
         extern void yield( unsigned int );
         extern thread_local struct thread_desc *    volatile this_thread;

src/libcfa/concurrency/invoke.h

@@ -14 +14 @@
 //
 
+#include "bits/containers.h"
 #include "bits/defs.h"
 #include "bits/locks.h"
 
-#ifdef __CFORALL__
+#ifdef __cforall
 extern "C" {
 #endif
@@ -25 +26 @@
 #define _INVOKE_H_
 
-        typedef void (*fptr_t)();
-        typedef int_fast16_t __lock_size_t;
-
-        struct __thread_queue_t {
-                struct thread_desc * head;
-                struct thread_desc ** tail;
-        };
-
-        struct __condition_stack_t {
-                struct __condition_criterion_t * top;
-        };
-
-        #ifdef __CFORALL__
+        #ifdef __cforall
         extern "Cforall" {
-                void ?{}( struct __thread_queue_t & );
-                void append( struct __thread_queue_t &, struct thread_desc * );
-                struct thread_desc * pop_head( struct __thread_queue_t & );
-                struct thread_desc * remove( struct __thread_queue_t &, struct thread_desc ** );
-
-                void ?{}( struct __condition_stack_t & );
-                void push( struct __condition_stack_t &, struct __condition_criterion_t * );
-                struct __condition_criterion_t * pop( struct __condition_stack_t & );
+                static inline struct thread_desc             * & get_next( struct thread_desc             & this );
+                static inline struct __condition_criterion_t * & get_next( struct __condition_criterion_t & this );
         }
         #endif
@@ -100 +83 @@
 
                 // list of acceptable functions, null if any
-                struct __acceptable_t * clauses;
-
-                // number of acceptable functions
-                __lock_size_t size;
+                __small_array_t(struct __acceptable_t) __cfa_anonymous_object;
         };
 
@@ -114 +94 @@
 
                 // queue of threads that are blocked waiting for the monitor
-                struct __thread_queue_t entry_queue;
+                __queue_t(struct thread_desc) entry_queue;
 
                 // stack of conditions to run next once we exit the monitor
-                struct __condition_stack_t signal_stack;
+                __stack_t(struct __condition_criterion_t) signal_stack;
 
                 // monitor routines can be called recursively, we need to keep track of that
@@ -131 +111 @@
         struct __monitor_group_t {
                 // currently held monitors
-                struct monitor_desc ** list;
-
-                // number of currently held monitors
-                __lock_size_t size;
+                __small_array_t(monitor_desc*) __cfa_anonymous_object;
 
                 // last function that acquired monitors
@@ -159 +136 @@
      };
 
-     #ifdef __CFORALL__
+     #ifdef __cforall
      extern "Cforall" {
-                static inline monitor_desc * ?[?]( const __monitor_group_t & this, ptrdiff_t index ) {
-                        return this.list[index];
+                static inline thread_desc * & get_next( thread_desc & this ) {
+                        return this.next;
+                }
+
+                static inline struct __condition_criterion_t * & get_next( struct __condition_criterion_t & this );
+
+                static inline void ?{}(__monitor_group_t & this) {
+                        (this.data){NULL};
+                        (this.size){0};
+                        (this.func){NULL};
+                }
+
+                static inline void ?{}(__monitor_group_t & this, struct monitor_desc ** data, __lock_size_t size, fptr_t func) {
+                        (this.data){data};
+                        (this.size){size};
+                        (this.func){func};
                 }
 
                 static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) {
-                        if( (lhs.list != 0) != (rhs.list != 0) ) return false;
+                        if( (lhs.data != 0) != (rhs.data != 0) ) return false;
                         if( lhs.size != rhs.size ) return false;
                         if( lhs.func != rhs.func ) return false;
@@ -177 +168 @@
 
                         return true;
+                }
+
+                static inline void ?=?(__monitor_group_t & lhs, const __monitor_group_t & rhs) {
+                        lhs.data = rhs.data;
+                        lhs.size = rhs.size;
+                        lhs.func = rhs.func;
                 }
         }
@@ -210 +207 @@
 #endif //_INVOKE_PRIVATE_H_
 #endif //! defined(__CFA_INVOKE_PRIVATE__)
-#ifdef __CFORALL__
+#ifdef __cforall
 }
 #endif

src/libcfa/concurrency/kernel

@@ -26 +26 @@
 //-----------------------------------------------------------------------------
 // Locks
-// // Lock the spinlock, spin if already acquired
-// void lock      ( spinlock * DEBUG_CTX_PARAM2 );
-
-// // Lock the spinlock, yield repeatedly if already acquired
-// void lock_yield( spinlock * DEBUG_CTX_PARAM2 );
-
-// // Lock the spinlock, return false if already acquired
-// bool try_lock  ( spinlock * DEBUG_CTX_PARAM2 );
-
-// // Unlock the spinlock
-// void unlock    ( spinlock * );
-
 struct semaphore {
         __spinlock_t lock;
         int count;
-        __thread_queue_t waiting;
+        __queue_t(thread_desc) waiting;
 };
 
@@ -57 +45 @@
 
         // Ready queue for threads
-        __thread_queue_t ready_queue;
+        __queue_t(thread_desc) ready_queue;
 
         // Preemption rate on this cluster

src/libcfa/concurrency/kernel.c

@@ -164 +164 @@
 
 void ?{}(cluster & this) {
-        ( this.ready_queue ){};
+        (this.ready_queue){};
         ( this.ready_queue_lock ){};
 
@@ -611 +611 @@
 }
 
-//-----------------------------------------------------------------------------
-// Queues
-void ?{}( __thread_queue_t & this ) {
-        this.head = NULL;
-        this.tail = &this.head;
-}
-
-void append( __thread_queue_t & this, thread_desc * t ) {
-        verify(this.tail != NULL);
-        *this.tail = t;
-        this.tail = &t->next;
-}
-
-thread_desc * pop_head( __thread_queue_t & this ) {
-        thread_desc * head = this.head;
-        if( head ) {
-                this.head = head->next;
-                if( !head->next ) {
-                        this.tail = &this.head;
-                }
-                head->next = NULL;
-        }
-        return head;
-}
-
-thread_desc * remove( __thread_queue_t & this, thread_desc ** it ) {
-        thread_desc * thrd = *it;
-        verify( thrd );
-
-        (*it) = thrd->next;
-
-        if( this.tail == &thrd->next ) {
-                this.tail = it;
-        }
-
-        thrd->next = NULL;
-
-        verify( (this.head == NULL) == (&this.head == this.tail) );
-        verify( *this.tail == NULL );
-        return thrd;
-}
-
-void ?{}( __condition_stack_t & this ) {
-        this.top = NULL;
-}
-
-void push( __condition_stack_t & this, __condition_criterion_t * t ) {
-        verify( !t->next );
-        t->next = this.top;
-        this.top = t;
-}
-
-__condition_criterion_t * pop( __condition_stack_t & this ) {
-        __condition_criterion_t * top = this.top;
-        if( top ) {
-                this.top = top->next;
-                top->next = NULL;
-        }
-        return top;
-}
-
 // Local Variables: //
 // mode: c //

src/libcfa/concurrency/monitor

@@ -34 +34 @@
         this.recursion     = 0;
         this.mask.accepted = NULL;
-        this.mask.clauses  = NULL;
+        this.mask.data     = NULL;
         this.mask.size     = 0;
         this.dtor_node     = NULL;
@@ -40 +40 @@
 
 struct monitor_guard_t {
-        monitor_desc ** m;
-        __lock_size_t   count;
-        monitor_desc ** prev_mntrs;
-        __lock_size_t   prev_count;
-        fptr_t          prev_func;
+        monitor_desc **         m;
+        __lock_size_t           count;
+        __monitor_group_t prev;
 };
 
@@ -51 +49 @@
 
 struct monitor_dtor_guard_t {
-        monitor_desc * m;
-        monitor_desc ** prev_mntrs;
-        __lock_size_t   prev_count;
-        fptr_t          prev_func;
+        monitor_desc *    m;
+        __monitor_group_t prev;
 };
 
@@ -83 +79 @@
 };
 
+static inline __condition_criterion_t * & get_next( __condition_criterion_t & this ) {
+        return this.next;
+}
+
 struct __condition_node_t {
         // Thread that needs to be woken when all criteria are met
@@ -100 +100 @@
 };
 
-struct __condition_blocked_queue_t {
-        __condition_node_t * head;
-        __condition_node_t ** tail;
-};
+static inline __condition_node_t * & get_next( __condition_node_t & this ) {
+        return this.next;
+}
 
 void ?{}(__condition_node_t & this, thread_desc * waiting_thread, __lock_size_t count, uintptr_t user_info );
@@ -109 +108 @@
 void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner );
 
-void ?{}( __condition_blocked_queue_t & );
-void append( __condition_blocked_queue_t &, __condition_node_t * );
-__condition_node_t * pop_head( __condition_blocked_queue_t & );
-
 struct condition {
         // Link list which contains the blocked threads as-well as the information needed to unblock them
-        __condition_blocked_queue_t blocked;
+        __queue_t(__condition_node_t) blocked;
 
         // Array of monitor pointers (Monitors are NOT contiguous in memory)

src/libcfa/concurrency/monitor.c

@@ -280 +280 @@
 static inline void enter( __monitor_group_t monitors ) {
         for( __lock_size_t i = 0; i < monitors.size; i++) {
-                __enter_monitor_desc( monitors.list[i], monitors );
+                __enter_monitor_desc( monitors[i], monitors );
         }
 }
@@ -303 +303 @@
 
         // Save previous thread context
-        this.[prev_mntrs, prev_count, prev_func] = this_thread->monitors.[list, size, func];
+        this.prev = this_thread->monitors;
 
         // Update thread context (needed for conditions)
-        this_thread->monitors.[list, size, func] = [m, count, func];
+        (this_thread->monitors){m, count, func};
 
         // LIB_DEBUG_PRINT_SAFE("MGUARD : enter %d\n", count);
@@ -328 +328 @@
 
         // Restore thread context
-        this_thread->monitors.[list, size, func] = this.[prev_mntrs, prev_count, prev_func];
+        this_thread->monitors = this.prev;
 }
 
@@ -338 +338 @@
 
         // Save previous thread context
-        this.[prev_mntrs, prev_count, prev_func] = this_thread->monitors.[list, size, func];
+        this.prev = this_thread->monitors;
 
         // Update thread context (needed for conditions)
-        this_thread->monitors.[list, size, func] = [m, 1, func];
+        (this_thread->monitors){m, 1, func};
 
         __enter_monitor_dtor( this.m, func );
@@ -352 +352 @@
 
         // Restore thread context
-        this_thread->monitors.[list, size, func] = this.[prev_mntrs, prev_count, prev_func];
+        this_thread->monitors = this.prev;
 }
 
@@ -437 +437 @@
 
                 for(int i = 0; i < this.monitor_count; i++) {
-                        if ( this.monitors[i] != this_thrd->monitors.list[i] ) {
-                                abortf( "Signal on condition %p made with different monitor, expected %p got %i", &this, this.monitors[i], this_thrd->monitors.list[i] );
+                        if ( this.monitors[i] != this_thrd->monitors[i] ) {
+                                abortf( "Signal on condition %p made with different monitor, expected %p got %i", &this, this.monitors[i], this_thrd->monitors[i] );
                         }
                 }
@@ -510 +510 @@
                 "Possible cause is not checking if the condition is empty before reading stored data."
         );
-        return this.blocked.head->user_info;
+        return ((typeof(this.blocked.head))this.blocked.head)->user_info;
 }
 
@@ -554 +554 @@
                 if( next ) {
                         *mask.accepted = index;
-                        if( mask.clauses[index].is_dtor ) {
+                        __acceptable_t& accepted = mask[index];
+                        if( accepted.is_dtor ) {
                                 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : dtor already there\n");
-                                verifyf( mask.clauses[index].size == 1        , "ERROR: Accepted dtor has more than 1 mutex parameter." );
-
-                                monitor_desc * mon2dtor = mask.clauses[index].list[0];
+                                verifyf( accepted.size == 1,  "ERROR: Accepted dtor has more than 1 mutex parameter." );
+
+                                monitor_desc * mon2dtor = accepted[0];
                                 verifyf( mon2dtor->dtor_node, "ERROR: Accepted monitor has no dtor_node." );
 
@@ -596 +597 @@
 
                         LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
-
                         return;
                 }
@@ -671 +671 @@
 static inline void reset_mask( monitor_desc * this ) {
         this->mask.accepted = NULL;
-        this->mask.clauses = NULL;
+        this->mask.data = NULL;
         this->mask.size = 0;
 }
@@ -697 +697 @@
 
 static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & group ) {
-        __acceptable_t * it = this->mask.clauses; // Optim
+        __acceptable_t * it = this->mask.data; // Optim
         __lock_size_t count = this->mask.size;
 
@@ -820 +820 @@
         if( !this.monitors ) {
                 // LIB_DEBUG_PRINT_SAFE("Branding\n");
-                assertf( thrd->monitors.list != NULL, "No current monitor to brand condition %p", thrd->monitors.list );
+                assertf( thrd->monitors.data != NULL, "No current monitor to brand condition %p", thrd->monitors.data );
                 this.monitor_count = thrd->monitors.size;
 
                 this.monitors = (monitor_desc **)malloc( this.monitor_count * sizeof( *this.monitors ) );
                 for( int i = 0; i < this.monitor_count; i++ ) {
-                        this.monitors[i] = thrd->monitors.list[i];
+                        this.monitors[i] = thrd->monitors[i];
                 }
         }
@@ -832 +832 @@
 static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t & mask, monitor_desc * monitors [], __lock_size_t count ) {
 
-        __thread_queue_t & entry_queue = monitors[0]->entry_queue;
+        __queue_t(thread_desc) & entry_queue = monitors[0]->entry_queue;
 
         // For each thread in the entry-queue
@@ -841 +841 @@
                 // For each acceptable check if it matches
                 int i = 0;
-                __acceptable_t * end = mask.clauses + mask.size;
-                for( __acceptable_t * it = mask.clauses; it != end; it++, i++ ) {
+                __acceptable_t * end   = end  (mask);
+                __acceptable_t * begin = begin(mask);
+                for( __acceptable_t * it = begin; it != end; it++, i++ ) {
                         // Check if we have a match
                         if( *it == (*thrd_it)->monitors ) {
@@ -872 +873 @@
         __lock_size_t max = 0;
         for( __lock_size_t i = 0; i < mask.size; i++ ) {
-                max += mask.clauses[i].size;
+                __acceptable_t & accepted = mask[i];
+                max += accepted.size;
         }
         return max;
@@ -880 +882 @@
         __lock_size_t size = 0;
         for( __lock_size_t i = 0; i < mask.size; i++ ) {
-                __libcfa_small_sort( mask.clauses[i].list, mask.clauses[i].size );
-                for( __lock_size_t j = 0; j < mask.clauses[i].size; j++) {
-                        insert_unique( storage, size, mask.clauses[i].list[j] );
+                __acceptable_t & accepted = mask[i];
+                __libcfa_small_sort( accepted.data, accepted.size );
+                for( __lock_size_t j = 0; j < accepted.size; j++) {
+                        insert_unique( storage, size, accepted[j] );
                 }
         }
@@ -888 +891 @@
         __libcfa_small_sort( storage, size );
         return size;
-}
-
-void ?{}( __condition_blocked_queue_t & this ) {
-        this.head = NULL;
-        this.tail = &this.head;
-}
-
-void append( __condition_blocked_queue_t & this, __condition_node_t * c ) {
-        verify(this.tail != NULL);
-        *this.tail = c;
-        this.tail = &c->next;
-}
-
-__condition_node_t * pop_head( __condition_blocked_queue_t & this ) {
-        __condition_node_t * head = this.head;
-        if( head ) {
-                this.head = head->next;
-                if( !head->next ) {
-                        this.tail = &this.head;
-                }
-                head->next = NULL;
-        }
-        return head;
 }
 

src/libcfa/exception.h

@@ -17 +17 @@
 
 
-#ifdef __CFORALL__
+#ifdef __cforall
 extern "C" {
 #endif
@@ -68 +68 @@
 struct __cfaehm__cleanup_hook {};
 
-#ifdef __CFORALL__
+#ifdef __cforall
 }
 #endif

src/libcfa/stdhdr/assert.h

@@ -4 +4 @@
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
-// 
-// assert.h -- 
-// 
+//
+// assert.h --
+//
 // Author           : Peter A. Buhr
 // Created On       : Mon Jul  4 23:25:26 2016
@@ -12 +12 @@
 // Last Modified On : Mon Jul 31 23:09:32 2017
 // Update Count     : 13
-// 
+//
 
-#ifdef __CFORALL__
+#ifdef __cforall
 extern "C" {
-#endif //__CFORALL__
+#endif //__cforall
 
 #include_next <assert.h>
@@ -30 +30 @@
 #endif
 
-#ifdef __CFORALL__
+#ifdef __cforall
 } // extern "C"
-#endif //__CFORALL__
+#endif //__cforall
 
 // Local Variables: //

src/libcfa/virtual.h

@@ -16 +16 @@
 #pragma once
 
-#ifdef __CFORALL__
+#ifdef __cforall
 extern "C" {
 #endif
@@ -35 +35 @@
                 struct __cfa__parent_vtable const * const * child );
 
-#ifdef __CFORALL__
+#ifdef __cforall
 }
 #endif

src/tests/Makefile.am

@@ -11 +11 @@
 ## Created On       : Sun May 31 09:08:15 2015
 ## Last Modified By : Peter A. Buhr
-## Last Modified On : Tue Oct 10 14:04:40 2017
-## Update Count     : 47
+## Last Modified On : Mon Nov 27 21:34:33 2017
+## Update Count     : 48
 ###############################################################################
 
@@ -118 +118 @@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 
+functions: functions.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
+
 KRfunctions : KRfunctions.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}

src/tests/Makefile.in

@@ -871 +871 @@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 
+functions: functions.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
+
 KRfunctions : KRfunctions.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}

src/tests/designations.c

@@ -17 +17 @@
 // In particular, since the syntax for designations in Cforall differs from that of C, preprocessor substitution
 // is used for the designation syntax
-#ifdef __CFORALL__
+#ifdef __cforall
 #define DES :
 #else

src/tests/functions.c

@@ -10 +10 @@
 // Created On       : Wed Aug 17 08:39:58 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug 17 08:40:52 2016
-// Update Count     : 1
+// Last Modified On : Mon Nov 27 18:08:54 2017
+// Update Count     : 11
 // 
 
@@ -66 +66 @@
 // Cforall extensions
 
-[] f( );
+// [] f( );
 [int] f( );
-[] f(int);
+// [] f(int);
 [int] f(int);
-[] f( ) {}
+// [] f( ) {}
 [int] f( ) {}
-[] f(int) {}
+// [] f(int) {}
 [int] f(int) {}
 
 [int x] f( );
-[] f(int x);
-[int x] f(int x);
-[int x] f( ) {}
-[] f(int x) {}
-[int x] f(int x) {}
+// [] f(int x);
+//[int x] f(int x);
+//[int x] f( ) {}
+// [] f(int x) {}
+//[int x] f(int x) {}
 
 [int, int x] f( );
-[] f(int, int x);
+// [] f(int, int x);
 [int, int x] f(int, int x);
 [int, int x] f( ) {}
-[] f(int, int x) {}
+// [] f(int, int x) {}
 [int, int x] f(int, int x) {}
 
 [int, int x, int] f( );
-[] f(int, int x, int);
+// [] f(int, int x, int);
 [int, int x, int] f(int, int x, int);
 [int, int x, int] f( ) {}
-[] f(int, int x, int) {}
+// [] f(int, int x, int) {}
 [int, int x, int] f(int, int x, int) {}
 
 [int, int x, * int y] f( );
-[] f(int, int x, * int y);
+// [] f(int, int x, * int y);
 [int, int x, * int y] f(int, int x, * int y);
 [int, int x, * int y] f( ) {}
-[] f(int, int x, * int y) {}
+// [] f(int, int x, * int y) {}
 [int, int x, * int y] f(int, int x, * int y) {}
 
-[ int ] f11( int ), f12;  // => int f11( int ), f12( int );
+// function prototypes
+
+[ int ] f11( int ), f12();  // => int f11( int ), f12( void );
+
+const double bar1(), bar2( int ), bar3( double );               // C version
+[const double] foo(), foo( int ), foo( double ) { return 3.0; } // CFA version
+struct S { int i; };
+[S] rtn( int ) {}
+
 
 [int] f(
@@ -109 +117 @@
         [int](int)
         ) {
-        int (*(*p)[][10])[][3];
+        int (*(*pc)[][10])[][3];
         * [][10] * [][3] int p;
         * [] * [int](int) p;