Changeset 95487027

Timestamp:

Jun 7, 2018, 1:29:41 PM (6 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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:

08b5a7e

Parents:

8551b859 (diff), a43c561 (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 plg2:software/cfa/cfa-cc

Location:

src

Files:

• libcfa/bits/locks.h (modified) (2 diffs)
• libcfa/concurrency/kernel (modified) (2 diffs)
• libcfa/concurrency/kernel.c (modified) (12 diffs)
• libcfa/concurrency/preemption.c (modified) (3 diffs)
• libcfa/stdhdr/assert.h (modified) (1 diff)
• prelude/sync-builtins.cf (modified) (2 diffs)
• tests/preempt_longrun/processor.c (modified) (3 diffs)

src/libcfa/bits/locks.h

@@ -18 +18 @@
 #include "bits/debug.h"
 #include "bits/defs.h"
+#include <assert.h>
+
+#ifdef __cforall
+        extern "C" {
+                #include <pthread.h>
+        }
+#endif
 
 // pause to prevent excess processor bus usage
@@ -112 +119 @@
                 __atomic_clear( &this.lock, __ATOMIC_RELEASE );
         }
+
+
+        #ifdef __CFA_WITH_VERIFY__
+                extern bool __cfaabi_dbg_in_kernel();
+        #endif
+
+        struct __bin_sem_t {
+                int_fast8_t     counter;
+                pthread_mutex_t lock;
+                pthread_cond_t  cond;
+        };
+
+        static inline void ?{}(__bin_sem_t & this) with( this ) {
+                counter = 0;
+                pthread_mutex_init(&lock, NULL);
+                pthread_cond_init (&cond, NULL);
+        }
+
+        static inline void ^?{}(__bin_sem_t & this) with( this ) {
+                pthread_mutex_destroy(&lock);
+                pthread_cond_destroy (&cond);
+        }
+
+        static inline void wait(__bin_sem_t & this) with( this ) {
+                verify(__cfaabi_dbg_in_kernel());
+                pthread_mutex_lock(&lock);
+                if(counter != 0) {   // this must be a loop, not if!
+                        pthread_cond_wait(&cond, &lock);
+                }
+                counter = 1;
+                pthread_mutex_unlock(&lock);
+        }
+
+        static inline void post(__bin_sem_t & this) with( this ) {
+                verify(__cfaabi_dbg_in_kernel());
+                pthread_mutex_lock(&lock);
+                bool needs_signal = counter == 0;
+                counter = 1;
+                pthread_mutex_unlock(&lock);
+                if (!needs_signal)
+                        pthread_cond_signal(&cond);
+                }
 #endif

src/libcfa/concurrency/kernel

@@ -133 +133 @@
         // Idle lock
         sem_t idleLock;
+        // __bin_sem_t idleLock;
 
         // Link lists fields
-        struct {
+        struct __dbg_node_proc {
                 struct processor * next;
                 struct processor * prev;
@@ -182 +183 @@
 
         // Link lists fields
-        struct {
+        struct __dbg_node_cltr {
                 cluster * next;
                 cluster * prev;

src/libcfa/concurrency/kernel.c

@@ -17 +17 @@
 #include <stddef.h>
 #include <errno.h>
+#include <string.h>
 extern "C" {
 #include <stdio.h>
@@ -50 +51 @@
 thread_desc * mainThread;
 
-struct { __dllist_t(cluster) list; __spinlock_t lock; } global_clusters;
+extern "C" {
+struct { __dllist_t(cluster) list; __spinlock_t lock; } __cfa_dbg_global_clusters;
+}
 
 //-----------------------------------------------------------------------------
@@ -150 +153 @@
 
 void ^?{}(processor & this) with( this ){
-        if( ! do_terminate ) {
+        if( ! __atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) ) {
                 __cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
                 terminate(&this);
-                verify(this.do_terminate);
+                verify( __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
                 verify( kernelTLS.this_processor != &this);
                 P( terminated );
@@ -199 +202 @@
 
                 thread_desc * readyThread = NULL;
-                for( unsigned int spin_count = 0; ! this->do_terminate; spin_count++ )
+                for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ )
                 {
                         readyThread = nextThread( this->cltr );
@@ -218 +221 @@
                         else
                         {
-                                spin(this, &spin_count);
+                                // spin(this, &spin_count);
+                                halt(this);
                         }
                 }
@@ -545 +549 @@
         __cfaabi_dbg_print_safe("Kernel : Starting\n");
 
-        global_clusters.list{ __get };
-        global_clusters.lock{};
+        __cfa_dbg_global_clusters.list{ __get };
+        __cfa_dbg_global_clusters.lock{};
 
         // Initialize the main cluster
@@ -627 +631 @@
         // When its coroutine terminates, it return control to the mainThread
         // which is currently here
-        mainProcessor->do_terminate = true;
+        __atomic_store_n(&mainProcessor->do_terminate, true, __ATOMIC_RELEASE);
         returnToKernel();
+        mainThread->self_cor.state = Halted;
 
         // THE SYSTEM IS NOW COMPLETELY STOPPED
@@ -644 +649 @@
         ^(mainThread){};
 
-        ^(global_clusters.list){};
-        ^(global_clusters.lock){};
+        ^(__cfa_dbg_global_clusters.list){};
+        ^(__cfa_dbg_global_clusters.lock){};
 
         __cfaabi_dbg_print_safe("Kernel : Shutdown complete\n");
@@ -655 +660 @@
 
 void halt(processor * this) with( *this ) {
+        verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
+
         with( *cltr ) {
                 lock      (proc_list_lock __cfaabi_dbg_ctx2);
@@ -664 +671 @@
         __cfaabi_dbg_print_safe("Kernel : Processor %p ready to sleep\n", this);
 
-        verify( ({int sval = 0; sem_getvalue(&this->idleLock, &sval); sval; }) < 200);
+        // #ifdef __CFA_WITH_VERIFY__
+        //      int sval = 0;
+        //      sem_getvalue(&this->idleLock, &sval);
+        //      verifyf(sval < 200, "Binary semaphore reached value %d : \n", sval);
+        // #endif
+
+        verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
         int __attribute__((unused)) ret = sem_wait(&idleLock);
-        verify(ret > 0 || errno == EINTR);
+        // verifyf(ret >= 0 || errno == EINTR, "Sem_wait returned %d (errno %d : %s\n", ret, errno, strerror(errno));
+
+        // wait( idleLock );
 
         __cfaabi_dbg_print_safe("Kernel : Processor %p woke up and ready to run\n", this);
@@ -681 +696 @@
         __cfaabi_dbg_print_safe("Kernel : Waking up processor %p\n", this);
         int __attribute__((unused)) ret = sem_post(&this->idleLock);
-        verify(ret > 0 || errno == EINTR);
-        verify( ({int sval = 0; sem_getvalue(&this->idleLock, &sval); sval; }) < 200);
+        // verifyf(ret >= 0 || errno == EINTR, "Sem_post returned %d (errno %d : %s\n", ret, errno, strerror(errno));
+
+        // #ifdef __CFA_WITH_VERIFY__
+        //      int sval = 0;
+        //      sem_getvalue(&this->idleLock, &sval);
+        //      verifyf(sval < 200, "Binary semaphore reached value %d\n", sval);
+        // #endif
+
+        // post( this->idleLock );
 }
 
@@ -798 +820 @@
 // Global Queues
 void doregister( cluster     & cltr ) {
-        lock      ( global_clusters.lock __cfaabi_dbg_ctx2);
-        push_front( global_clusters.list, cltr );
-        unlock    ( global_clusters.lock );
+        lock      ( __cfa_dbg_global_clusters.lock __cfaabi_dbg_ctx2);
+        push_front( __cfa_dbg_global_clusters.list, cltr );
+        unlock    ( __cfa_dbg_global_clusters.lock );
 }
 
 void unregister( cluster     & cltr ) {
-        lock  ( global_clusters.lock __cfaabi_dbg_ctx2);
-        remove( global_clusters.list, cltr );
-        unlock( global_clusters.lock );
+        lock  ( __cfa_dbg_global_clusters.lock __cfaabi_dbg_ctx2);
+        remove( __cfa_dbg_global_clusters.list, cltr );
+        unlock( __cfa_dbg_global_clusters.lock );
 }
 

src/libcfa/concurrency/preemption.c

@@ -265 +265 @@
 // kill wrapper : signal a processor
 void terminate(processor * this) {
-        this->do_terminate = true;
-        wake(this);
+        disable_interrupts();
+        __atomic_store_n(&this->do_terminate, true, __ATOMIC_SEQ_CST);
+        wake( this );
         sigval_t value = { PREEMPT_TERMINATE };
+        enable_interrupts( __cfaabi_dbg_ctx );
         pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
 }
@@ -369 +371 @@
         choose(sfp->si_value.sival_int) {
                 case PREEMPT_NORMAL   : ;// Normal case, nothing to do here
-                case PREEMPT_TERMINATE: verify( kernelTLS.this_processor->do_terminate);
+                case PREEMPT_TERMINATE: verify( __atomic_load_n( &kernelTLS.this_processor->do_terminate, __ATOMIC_SEQ_CST ) );
                 default:
                         abort( "internal error, signal value is %d", sfp->si_value.sival_int );
@@ -488 +490 @@
 }
 
+#ifdef __CFA_WITH_VERIFY__
+bool __cfaabi_dbg_in_kernel() {
+        return !kernelTLS.preemption_state.enabled;
+}
+#endif
+
 // Local Variables: //
 // mode: c //

src/libcfa/stdhdr/assert.h

@@ -33 +33 @@
         #define verify(x) assert(x)
         #define verifyf(x, ...) assertf(x, __VA_ARGS__)
+        #define __CFA_WITH_VERIFY__
 #else
         #define verify(x)

src/prelude/sync-builtins.cf

@@ -248 +248 @@
 #endif
 
+_Bool __atomic_load_n(const volatile _Bool *, int);
+void __atomic_load(const volatile _Bool *, volatile _Bool *, int);
 char __atomic_load_n(const volatile char *, int);
 char __atomic_load_1(const volatile char *, int);
@@ -285 +287 @@
 
 void __atomic_store_n(volatile _Bool *, _Bool, int);
-void __atomic_store_1(volatile _Bool *, _Bool, int);
 void __atomic_store(volatile _Bool *, _Bool *, int);
 void __atomic_store_n(volatile char *, char, int);

src/tests/preempt_longrun/processor.c

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