Changes in / [cf5e5b1:25fcb84]

Location:

src/libcfa

Files:

• bits/containers.h (modified) (2 diffs)
• concurrency/kernel (modified) (2 diffs)
• concurrency/kernel.c (modified) (5 diffs)
• concurrency/kernel_private.h (modified) (1 diff)
• concurrency/mutex.c (modified) (1 diff)
• concurrency/preemption.c (modified) (1 diff)

src/libcfa/bits/containers.h

@@ -186 +186 @@
 
         forall(dtype T | is_node(T))
-        static inline bool ?!=?( __queue(T) & this, zero_t zero ) {
-                return this.head != 0;
+        static inline bool ?!=?( __queue(T) & this, zero_t zero ) with( this ) {
+                return head != 0;
         }
 #endif
@@ -266 +266 @@
                 __get( node ).prev = NULL;
         }
-
-        forall(dtype T | sized(T))
-        static inline bool ?!=?( __dllist(T) & this, zero_t zero ) {
-                return this.head != 0;
-        }
         #undef next
         #undef prev

src/libcfa/concurrency/kernel

@@ -23 +23 @@
 extern "C" {
 #include <pthread.h>
-#include <semaphore.h>
 }
 
@@ -132 +131 @@
 
         // Idle lock
-        sem_t idleLock;
 
         // Link lists fields

src/libcfa/concurrency/kernel.c

@@ -143 +143 @@
         runner.proc = &this;
 
-        sem_init(&idleLock, 0, 0);
-
         start( &this );
 }
@@ -158 +156 @@
                 pthread_join( kernel_thread, NULL );
         }
-
-        sem_destroy(&idleLock);
 }
 
@@ -293 +289 @@
 // TODO : find some strategy to put cores to sleep after some time
 void spin(processor * this, unsigned int * spin_count) {
-        // (*spin_count)++;
-        halt(this);
+        (*spin_count)++;
 }
 
@@ -399 +394 @@
         with( *thrd->curr_cluster ) {
                 lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
-                bool was_empty = !(ready_queue != 0);
                 append( ready_queue, thrd );
                 unlock( ready_queue_lock );
-
-                if( was_empty ) {
-                        lock      (proc_list_lock __cfaabi_dbg_ctx2);
-                        if(idles) {
-                                wake(idles.head);
-                        }
-                        unlock    (proc_list_lock);
-                }
         }
 
@@ -653 +639 @@
 //=============================================================================================
 
-void halt(processor * this) with( *this ) {
-        with( *cltr ) {
-                lock      (proc_list_lock __cfaabi_dbg_ctx2);
-                remove    (procs, *this);
-                push_front(idles, *this);
-                unlock    (proc_list_lock);
-        }
-
-        __cfaabi_dbg_print_safe("Kernel : Processor %p ready to sleep\n", this);
-
-        sem_wait(&idleLock);
-
-        __cfaabi_dbg_print_safe("Kernel : Processor %p woke up and ready to run\n", this);
-
-        with( *cltr ) {
-                lock      (proc_list_lock __cfaabi_dbg_ctx2);
-                remove    (idles, *this);
-                push_front(procs, *this);
-                unlock    (proc_list_lock);
-        }
-}
-
-void wake(processor * this) {
-        __cfaabi_dbg_print_safe("Kernel : Waking up processor %p\n", this);
-        sem_post(&this->idleLock);
-}
+// 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);
+// }
 
 //=============================================================================================

src/libcfa/concurrency/kernel_private.h

@@ -57 +57 @@
 void runThread(processor * this, thread_desc * dst);
 void finishRunning(processor * this);
-void halt(processor * this);
-void wake(processor * this);
 void terminate(processor * this);
 void spin(processor * this, unsigned int * spin_count);

src/libcfa/concurrency/mutex.c

@@ -167 +167 @@
         }
         BlockInternal( __unlock );
-        lock(l);
 }
 

src/libcfa/concurrency/preemption.c

@@ -266 +266 @@
 void terminate(processor * this) {
         this->do_terminate = true;
-        wake(this);
         sigval_t value = { PREEMPT_TERMINATE };
         pthread_sigqueue( this->kernel_thread, SIGUSR1, value );