Changes in / [7b28e4a:90cedbdd]

Location:

src

Files:

• libcfa/bits/locks.h (modified) (3 diffs)
• libcfa/concurrency/kernel (modified) (2 diffs)
• libcfa/concurrency/kernel.c (modified) (7 diffs)
• libcfa/concurrency/kernel_private.h (modified) (2 diffs)
• libcfa/concurrency/preemption.c (modified) (1 diff)
• tests/preempt_longrun/Makefile.am (modified) (1 diff)
• tests/preempt_longrun/Makefile.in (modified) (1 diff)
• tests/preempt_longrun/enter.c (modified) (2 diffs)
• tests/preempt_longrun/processor.c (modified) (2 diffs)

src/libcfa/bits/locks.h

@@ -126 +126 @@
 
         struct __bin_sem_t {
-                bool                    signaled;
-                pthread_mutex_t         lock;
-                pthread_cond_t          cond;
+                int_fast8_t     counter;
+                pthread_mutex_t lock;
+                pthread_cond_t  cond;
         };
 
         static inline void ?{}(__bin_sem_t & this) with( this ) {
-                signaled = false;
+                counter = 0;
                 pthread_mutex_init(&lock, NULL);
                 pthread_cond_init (&cond, NULL);
@@ -145 +145 @@
                 verify(__cfaabi_dbg_in_kernel());
                 pthread_mutex_lock(&lock);
-                        if(!signaled) {   // this must be a loop, not if!
-                                pthread_cond_wait(&cond, &lock);
-                        }
-                        signaled = false;
+                if(counter != 0) {   // this must be a loop, not if!
+                        pthread_cond_wait(&cond, &lock);
+                }
+                counter = 1;
                 pthread_mutex_unlock(&lock);
         }
@@ -154 +154 @@
         static inline void post(__bin_sem_t & this) with( this ) {
                 verify(__cfaabi_dbg_in_kernel());
-
                 pthread_mutex_lock(&lock);
-                        bool needs_signal = !signaled;
-                        signaled = true;
+                bool needs_signal = counter == 0;
+                counter = 1;
                 pthread_mutex_unlock(&lock);
-
-                if (needs_signal)
+                if (!needs_signal)
                         pthread_cond_signal(&cond);
-        }
+                }
 #endif

src/libcfa/concurrency/kernel

@@ -113 +113 @@
         pthread_t kernel_thread;
 
+        // Termination
+        // Set to true to notify the processor should terminate
+        volatile bool do_terminate;
+
+        // Termination synchronisation
+        semaphore terminated;
+
         // RunThread data
         // Action to do after a thread is ran
@@ -125 +132 @@
 
         // Idle lock
-        __bin_sem_t idleLock;
-
-        // Termination
-        // Set to true to notify the processor should terminate
-        volatile bool do_terminate;
-
-        // Termination synchronisation
-        semaphore terminated;
+        sem_t idleLock;
+        // __bin_sem_t idleLock;
 
         // Link lists fields

src/libcfa/concurrency/kernel.c

@@ -147 +147 @@
         runner.proc = &this;
 
-        idleLock{};
+        sem_init(&idleLock, 0, 0);
 
         start( &this );
@@ -155 +155 @@
         if( ! __atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) ) {
                 __cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
-
-                __atomic_store_n(&do_terminate, true, __ATOMIC_RELAXED);
-                wake( &this );
-
+                terminate(&this);
+                verify( __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
+                verify( kernelTLS.this_processor != &this);
                 P( terminated );
                 verify( kernelTLS.this_processor != &this);
-        }
-
-        pthread_join( kernel_thread, NULL );
+                pthread_join( kernel_thread, NULL );
+        }
+
+        sem_destroy(&idleLock);
 }
 
@@ -295 +295 @@
 }
 
+// Handles spinning logic
+// TODO : find some strategy to put cores to sleep after some time
+void spin(processor * this, unsigned int * spin_count) {
+        // (*spin_count)++;
+        halt(this);
+}
+
 // KERNEL_ONLY
 // Context invoker for processors
@@ -401 +408 @@
                 unlock( ready_queue_lock );
 
-                if(was_empty) {
+                if( was_empty ) {
                         lock      (proc_list_lock __cfaabi_dbg_ctx2);
                         if(idles) {
-                                wake_fast(idles.head);
+                                wake(idles.head);
                         }
                         unlock    (proc_list_lock);
                 }
-                else if( struct processor * idle = idles.head ) {
-                        wake_fast(idle);
-                }
-
         }
 
@@ -657 +660 @@
 
 void halt(processor * this) with( *this ) {
-        // verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
+        verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
 
         with( *cltr ) {
@@ -668 +671 @@
         __cfaabi_dbg_print_safe("Kernel : Processor %p ready to sleep\n", this);
 
-        wait( idleLock );
+        // #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);
+        // 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);
@@ -678 +691 @@
                 unlock    (proc_list_lock);
         }
+}
+
+void wake(processor * this) {
+        __cfaabi_dbg_print_safe("Kernel : Waking up processor %p\n", this);
+        int __attribute__((unused)) ret = sem_post(&this->idleLock);
+        // 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 );
 }
 

src/libcfa/concurrency/kernel_private.h

@@ -58 +58 @@
 void finishRunning(processor * this);
 void halt(processor * this);
-
-static inline void wake_fast(processor * this) {
-        __cfaabi_dbg_print_safe("Kernel : Waking up processor %p\n", this);
-        post( this->idleLock );
-}
-
-static inline void wake(processor * this) {
-        disable_interrupts();
-        wake_fast(this);
-        enable_interrupts( __cfaabi_dbg_ctx );
-}
+void wake(processor * this);
+void terminate(processor * this);
+void spin(processor * this, unsigned int * spin_count);
 
 struct event_kernel_t {
@@ -76 +68 @@
 
 extern event_kernel_t * event_kernel;
+
+//extern thread_local coroutine_desc * volatile this_coroutine;
+//extern thread_local thread_desc *    volatile this_thread;
+//extern thread_local processor *      volatile this_processor;
+
+// extern volatile thread_local bool preemption_in_progress;
+// extern volatile thread_local bool preemption_enabled;
+// extern volatile thread_local unsigned short disable_preempt_count;
 
 struct __cfa_kernel_preemption_state_t {

src/libcfa/concurrency/preemption.c

@@ -260 +260 @@
 static void preempt( processor * this ) {
         sigval_t value = { PREEMPT_NORMAL };
+        pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
+}
+
+// kill wrapper : signal a processor
+void terminate(processor * 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 );
 }

src/tests/preempt_longrun/Makefile.am

@@ -34 +34 @@
 
 clean-local:
-        rm -f ${TESTS} core* out.log
+        rm -f ${TESTS}
 
 % : %.c ${CC}

src/tests/preempt_longrun/Makefile.in

@@ -878 +878 @@
 
 clean-local:
-        rm -f ${TESTS} core* out.log
+        rm -f ${TESTS}
 
 % : %.c ${CC}

src/tests/preempt_longrun/enter.c

@@ -15 +15 @@
 
 monitor mon_t {};
+
+mon_t mon;
+
 void foo( mon_t & mutex this ) {}
 
-mon_t mon;
 thread worker_t {};
+
 void main( worker_t & this ) {
         for( unsigned long i = 0; i < N; i++ ) {
@@ -25 +28 @@
 }
 
+extern "C" {
+static worker_t * workers;
+}
+
 int main(int argc, char * argv[] ) {
         processor p;
         {
                 worker_t w[7];
+                workers = w;
         }
 }

src/tests/preempt_longrun/processor.c

@@ -13 +13 @@
 }
 
-static const unsigned long N = 50_000ul;
+static const unsigned long N = 5_000ul;
 
 int main(int argc, char* argv[]) {
         processor * p[15];
-        write(STDOUT_FILENO, "Preparing\n", sizeof("Preparing\n"));
+        write(STDERR_FILENO, "Preparing\n", sizeof("Preparing\n"));
         for ( int pi = 0; pi < 15; pi++ ) {
                 p[pi] = new();
         }
-        write(STDOUT_FILENO, "Starting\n", sizeof("Starting\n"));
+        write(STDERR_FILENO, "Starting\n", sizeof("Starting\n"));
         for ( int i = 0; i < N; i++) {
                 int pi = i % 15;
@@ -27 +27 @@
                 p[pi] = new();
         }
-        write(STDOUT_FILENO, "Stopping\n", sizeof("Stopping\n"));
+        write(STDERR_FILENO, "Stopping\n", sizeof("Stopping\n"));
         for ( int pi = 0; pi < 15; pi++ ) {
                 delete( p[pi] );
         }
-        write(STDOUT_FILENO, "Done\n", sizeof("Done\n"));
+        write(STDERR_FILENO, "Done\n", sizeof("Done\n"));
 }