Changes in libcfa/src/concurrency/kernel/cluster.cfa [5024df4:cd3fc46]

File:

• libcfa/src/concurrency/kernel/cluster.cfa (modified) (13 diffs)

libcfa/src/concurrency/kernel/cluster.cfa

@@ -93 +93 @@
 //=======================================================================
 void  ?{}(__scheduler_RWLock_t & this) {
-        this.max   = __max_processors();
-        this.alloc = 0;
-        this.ready = 0;
-        this.data  = alloc(this.max);
-        this.write_lock  = false;
-
-        /*paranoid*/ verify(__atomic_is_lock_free(sizeof(this.alloc), &this.alloc));
-        /*paranoid*/ verify(__atomic_is_lock_free(sizeof(this.ready), &this.ready));
+        this.lock.max   = __max_processors();
+        this.lock.alloc = 0;
+        this.lock.ready = 0;
+        this.lock.data  = alloc(this.lock.max);
+        this.lock.write_lock  = false;
+
+        /*paranoid*/ verify(__atomic_is_lock_free(sizeof(this.lock.alloc), &this.lock.alloc));
+        /*paranoid*/ verify(__atomic_is_lock_free(sizeof(this.lock.ready), &this.lock.ready));
 
 }
 void ^?{}(__scheduler_RWLock_t & this) {
-        free(this.data);
+        free(this.lock.data);
 }
 
@@ -110 +110 @@
 //=======================================================================
 // Lock-Free registering/unregistering of threads
-unsigned register_proc_id( void ) with(*__scheduler_lock) {
+unsigned register_proc_id( void ) with(__scheduler_lock.lock) {
         __kernel_rseq_register();
 
@@ -132 +132 @@
         }
 
-        if(max <= alloc) abort("Trying to create more than %ud processors", __scheduler_lock->max);
+        if(max <= alloc) abort("Trying to create more than %ud processors", __scheduler_lock.lock.max);
 
         // Step - 2 : F&A to get a new spot in the array.
         uint_fast32_t n = __atomic_fetch_add(&alloc, 1, __ATOMIC_SEQ_CST);
-        if(max <= n) abort("Trying to create more than %ud processors", __scheduler_lock->max);
+        if(max <= n) abort("Trying to create more than %ud processors", __scheduler_lock.lock.max);
 
         // Step - 3 : Mark space as used and then publish it.
@@ -154 +154 @@
 }
 
-void unregister_proc_id( unsigned id ) with(*__scheduler_lock) {
+void unregister_proc_id( unsigned id ) with(__scheduler_lock.lock) {
         /* paranoid */ verify(id < ready);
         /* paranoid */ verify(id == kernelTLS().sched_id);
@@ -169 +169 @@
 // Writer side : acquire when changing the ready queue, e.g. adding more
 //  queues or removing them.
-uint_fast32_t ready_mutate_lock( void ) with(*__scheduler_lock) {
+uint_fast32_t ready_mutate_lock( void ) with(__scheduler_lock.lock) {
         /* paranoid */ verify( ! __preemption_enabled() );
 
@@ -196 +196 @@
 }
 
-void ready_mutate_unlock( uint_fast32_t last_s ) with(*__scheduler_lock) {
+void ready_mutate_unlock( uint_fast32_t last_s ) with(__scheduler_lock.lock) {
         /* paranoid */ verify( ! __preemption_enabled() );
 
@@ -229 +229 @@
                         for( idx ; lanes_count ) {
                                 __intrusive_lane_t & sl = readyQ.data[idx];
-                                assert(!readyQ.data[idx].lock);
+                                assert(!readyQ.data[idx].l.lock);
 
                                         if(is_empty(sl)) {
-                                                assert( sl.anchor.next == 0p );
-                                                assert( sl.anchor.ts   == MAX );
-                                                assert( mock_head(sl)  == sl.prev );
+                                                assert( sl.l.anchor.next == 0p );
+                                                assert( sl.l.anchor.ts   == MAX );
+                                                assert( mock_head(sl)  == sl.l.prev );
                                         } else {
-                                                assert( sl.anchor.next != 0p );
-                                                assert( sl.anchor.ts   != MAX );
-                                                assert( mock_head(sl)  != sl.prev );
+                                                assert( sl.l.anchor.next != 0p );
+                                                assert( sl.l.anchor.ts   != MAX );
+                                                assert( mock_head(sl)  != sl.l.prev );
                                         }
                         }
@@ -249 +249 @@
 static inline void fix(__intrusive_lane_t & ll) {
         if(is_empty(ll)) {
-                verify(ll.anchor.next == 0p);
-                ll.prev = mock_head(ll);
+                verify(ll.l.anchor.next == 0p);
+                ll.l.prev = mock_head(ll);
         }
 }
@@ -278 +278 @@
 
 #if defined(CFA_HAVE_LINUX_IO_URING_H)
-        static void assign_io($io_context ** data, size_t count, dlist(processor) & list) {
+        static void assign_io(io_context$ ** data, size_t count, dlist(processor) & list) {
                 processor * it = &list`first;
                 while(it) {
@@ -299 +299 @@
         tscs = alloc(count, tscs`realloc);
         for(i; count) {
-                tscs[i].tv = rdtscl();
-                tscs[i].ma = 0;
+                tscs[i].t.tv = rdtscl();
+                tscs[i].t.ma = 0;
         }
 }
@@ -400 +400 @@
                 for( idx; ncount ~ ocount) {
                         // Lock is not strictly needed but makes checking invariants much easier
-                        __attribute__((unused)) bool locked = __atomic_try_acquire(&readyQ.data[idx].lock);
+                        __attribute__((unused)) bool locked = __atomic_try_acquire(&readyQ.data[idx].l.lock);
                         verify(locked);
 
@@ -418 +418 @@
 
                         // Unlock the lane
-                        __atomic_unlock(&readyQ.data[idx].lock);
+                        __atomic_unlock(&readyQ.data[idx].l.lock);
 
                         // TODO print the queue statistics here
@@ -467 +467 @@
 }
 
+#define nested_offsetof(type, field) ((off_t)(&(((type*)0)-> field)))
+
 // Ctor
 void ?{}( __intrusive_lane_t & this ) {
-        this.lock = false;
-        this.prev = mock_head(this);
-        this.anchor.next = 0p;
-        this.anchor.ts   = MAX;
+        this.l.lock = false;
+        this.l.prev = mock_head(this);
+        this.l.anchor.next = 0p;
+        this.l.anchor.ts   = MAX;
         #if !defined(__CFA_NO_STATISTICS__)
-                this.cnt  = 0;
+                this.l.cnt  = 0;
         #endif
 
         // We add a boat-load of assertions here because the anchor code is very fragile
-        /* paranoid */ _Static_assert( offsetof( thread$, link ) == offsetof(__intrusive_lane_t, anchor) );
-        /* paranoid */ verify( offsetof( thread$, link ) == offsetof(__intrusive_lane_t, anchor) );
-        /* paranoid */ verify( ((uintptr_t)( mock_head(this) ) + offsetof( thread$, link )) == (uintptr_t)(&this.anchor) );
-        /* paranoid */ verify( &mock_head(this)->link.next == &this.anchor.next );
-        /* paranoid */ verify( &mock_head(this)->link.ts   == &this.anchor.ts   );
+        /* paranoid */ _Static_assert( offsetof( thread$, link ) == nested_offsetof(__intrusive_lane_t, l.anchor) );
+        /* paranoid */ verify( offsetof( thread$, link ) == nested_offsetof(__intrusive_lane_t, l.anchor) );
+        /* paranoid */ verify( ((uintptr_t)( mock_head(this) ) + offsetof( thread$, link )) == (uintptr_t)(&this.l.anchor) );
+        /* paranoid */ verify( &mock_head(this)->link.next == &this.l.anchor.next );
+        /* paranoid */ verify( &mock_head(this)->link.ts   == &this.l.anchor.ts   );
         /* paranoid */ verify( mock_head(this)->link.next == 0p );
         /* paranoid */ verify( mock_head(this)->link.ts   == MAX );
-        /* paranoid */ verify( mock_head(this) == this.prev );
-        /* paranoid */ verify( __alignof__(__intrusive_lane_t) == 128 );
-        /* paranoid */ verify( __alignof__(this) == 128 );
-        /* paranoid */ verifyf( ((intptr_t)(&this) % 128) == 0, "Expected address to be aligned %p %% 128 == %zd", &this, ((intptr_t)(&this) % 128) );
-}
+        /* paranoid */ verify( mock_head(this) == this.l.prev );
+        /* paranoid */ verify( __alignof__(__intrusive_lane_t) == 64 );
+        /* paranoid */ verify( __alignof__(this) == 64 );
+        /* paranoid */ verifyf( ((intptr_t)(&this) % 64) == 0, "Expected address to be aligned %p %% 64 == %zd", &this, ((intptr_t)(&this) % 64) );
+}
+
+#undef nested_offsetof
 
 // Dtor is trivial
 void ^?{}( __intrusive_lane_t & this ) {
         // Make sure the list is empty
-        /* paranoid */ verify( this.anchor.next == 0p );
-        /* paranoid */ verify( this.anchor.ts   == MAX );
-        /* paranoid */ verify( mock_head(this)  == this.prev );
+        /* paranoid */ verify( this.l.anchor.next == 0p );
+        /* paranoid */ verify( this.l.anchor.ts   == MAX );
+        /* paranoid */ verify( mock_head(this)    == this.l.prev );
 }