Changes in libcfa/src/concurrency/ready_queue.cfa [c993b15:fc59df78]

File:

• libcfa/src/concurrency/ready_queue.cfa (modified) (8 diffs)

libcfa/src/concurrency/ready_queue.cfa

@@ -93 +93 @@
         this.alloc = 0;
         this.ready = 0;
+        this.lock  = false;
         this.data  = alloc(this.max);
-        this.write_lock  = false;
-
+
+        /*paranoid*/ verify( 0 == (((uintptr_t)(this.data    )) % 64) );
+        /*paranoid*/ verify( 0 == (((uintptr_t)(this.data + 1)) % 64) );
         /*paranoid*/ verify(__atomic_is_lock_free(sizeof(this.alloc), &this.alloc));
         /*paranoid*/ verify(__atomic_is_lock_free(sizeof(this.ready), &this.ready));
@@ -104 +106 @@
 }
 
+void ?{}( __scheduler_lock_id_t & this, __processor_id_t * proc ) {
+        this.handle = proc;
+        this.lock   = false;
+        #ifdef __CFA_WITH_VERIFY__
+                this.owned  = false;
+        #endif
+}
 
 //=======================================================================
 // Lock-Free registering/unregistering of threads
-unsigned register_proc_id( void ) with(*__scheduler_lock) {
+void register_proc_id( struct __processor_id_t * proc ) with(*__scheduler_lock) {
         __cfadbg_print_safe(ready_queue, "Kernel : Registering proc %p for RW-Lock\n", proc);
-        bool * handle = (bool *)&kernelTLS().sched_lock;
 
         // Step - 1 : check if there is already space in the data
@@ -116 +124 @@
         // Check among all the ready
         for(uint_fast32_t i = 0; i < s; i++) {
-                bool * volatile * cell = (bool * volatile *)&data[i]; // Cforall is bugged and the double volatiles causes problems
-                /* paranoid */ verify( handle != *cell );
-
-                bool * null = 0p; // Re-write every loop since compare thrashes it
-                if( __atomic_load_n(cell, (int)__ATOMIC_RELAXED) == null
-                        && __atomic_compare_exchange_n( cell, &null, handle, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-                        /* paranoid */ verify(i < ready);
-                        /* paranoid */ verify( (kernelTLS().sched_id = i, true) );
-                        return i;
+                __processor_id_t * null = 0p; // Re-write every loop since compare thrashes it
+                if( __atomic_load_n(&data[i].handle, (int)__ATOMIC_RELAXED) == null
+                        && __atomic_compare_exchange_n( &data[i].handle, &null, proc, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
+                        /*paranoid*/ verify(i < ready);
+                        /*paranoid*/ verify(0 == (__alignof__(data[i]) % cache_line_size));
+                        /*paranoid*/ verify((((uintptr_t)&data[i]) % cache_line_size) == 0);
+                        proc->id = i;
                 }
         }
@@ -135 +141 @@
 
         // Step - 3 : Mark space as used and then publish it.
-        data[n] = handle;
+        __scheduler_lock_id_t * storage = (__scheduler_lock_id_t *)&data[n];
+        (*storage){ proc };
         while() {
                 unsigned copy = n;
@@ -147 +154 @@
 
         // Return new spot.
-        /* paranoid */ verify(n < ready);
-        /* paranoid */ verify( (kernelTLS().sched_id = n, true) );
-        return n;
-}
-
-void unregister_proc_id( unsigned id ) with(*__scheduler_lock) {
-        /* paranoid */ verify(id < ready);
-        /* paranoid */ verify(id == kernelTLS().sched_id);
-        /* paranoid */ verify(data[id] == &kernelTLS().sched_lock);
-
-        bool * volatile * cell = (bool * volatile *)&data[id]; // Cforall is bugged and the double volatiles causes problems
-
-        __atomic_store_n(cell, 0p, __ATOMIC_RELEASE);
+        /*paranoid*/ verify(n < ready);
+        /*paranoid*/ verify(__alignof__(data[n]) == (2 * cache_line_size));
+        /*paranoid*/ verify((((uintptr_t)&data[n]) % cache_line_size) == 0);
+        proc->id = n;
+}
+
+void unregister_proc_id( struct __processor_id_t * proc ) with(*__scheduler_lock) {
+        unsigned id = proc->id;
+        /*paranoid*/ verify(id < ready);
+        /*paranoid*/ verify(proc == __atomic_load_n(&data[id].handle, __ATOMIC_RELAXED));
+        __atomic_store_n(&data[id].handle, 0p, __ATOMIC_RELEASE);
 
         __cfadbg_print_safe(ready_queue, "Kernel : Unregister proc %p\n", proc);
@@ -169 +174 @@
 uint_fast32_t ready_mutate_lock( void ) with(*__scheduler_lock) {
         /* paranoid */ verify( ! __preemption_enabled() );
-        /* paranoid */ verify( ! kernelTLS().sched_lock );
 
         // Step 1 : lock global lock
         // It is needed to avoid processors that register mid Critical-Section
         //   to simply lock their own lock and enter.
-        __atomic_acquire( &write_lock );
+        __atomic_acquire( &lock );
 
         // Step 2 : lock per-proc lock
@@ -182 +186 @@
         uint_fast32_t s = ready;
         for(uint_fast32_t i = 0; i < s; i++) {
-                volatile bool * llock = data[i];
-                if(llock) __atomic_acquire( llock );
+                __atomic_acquire( &data[i].lock );
         }
 
@@ -200 +203 @@
         // Alternative solution : return s in write_lock and pass it to write_unlock
         for(uint_fast32_t i = 0; i < last_s; i++) {
-                volatile bool * llock = data[i];
-                if(llock) __atomic_store_n(llock, (bool)false, __ATOMIC_RELEASE);
+                verify(data[i].lock);
+                __atomic_store_n(&data[i].lock, (bool)false, __ATOMIC_RELEASE);
         }
 
         // Step 2 : release global lock
-        /*paranoid*/ assert(true == write_lock);
-        __atomic_store_n(&write_lock, (bool)false, __ATOMIC_RELEASE);
+        /*paranoid*/ assert(true == lock);
+        __atomic_store_n(&lock, (bool)false, __ATOMIC_RELEASE);
 
         /* paranoid */ verify( ! __preemption_enabled() );