Changeset 15c93d8 for libcfa/src/concurrency

Timestamp:

Oct 28, 2022, 5:30:57 PM (2 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, master

Children:

f1f481a

Parents:

be5f0a5

Message:

Renamed ready-queue link fields to rdy_link

Location:

libcfa/src/concurrency

Files:

• invoke.h (modified) (1 diff)
• kernel.cfa (modified) (3 diffs)
• kernel/cluster.cfa (modified) (1 diff)
• kernel/startup.cfa (modified) (1 diff)
• ready_subqueue.hfa (modified) (5 diffs)
• thread.cfa (modified) (1 diff)

libcfa/src/concurrency/invoke.h

@@ -159 +159 @@
                 // Link lists fields
                 // instrusive link field for threads
-                struct __thread_desc_link link;
+                struct __thread_desc_link rdy_link;
 
                 // current execution status for coroutine

libcfa/src/concurrency/kernel.cfa

@@ -291 +291 @@
         /* paranoid */ verify( ! __preemption_enabled() );
         /* paranoid */ verifyf( thrd_dst->state == Ready || thrd_dst->preempted != __NO_PREEMPTION, "state : %d, preempted %d\n", thrd_dst->state, thrd_dst->preempted);
-        /* paranoid */ verifyf( thrd_dst->link.next == 0p, "Expected null got %p", thrd_dst->link.next );
+        /* paranoid */ verifyf( thrd_dst->rdy_link.next == 0p, "Expected null got %p", thrd_dst->rdy_link.next );
         __builtin_prefetch( thrd_dst->context.SP );
 
@@ -454 +454 @@
                                         "Error preempted thread marked as not currently running, state %d, preemption %d\n", thrd->state, thrd->preempted );
         /* paranoid */ #endif
-        /* paranoid */ verifyf( thrd->link.next == 0p, "Expected null got %p", thrd->link.next );
+        /* paranoid */ verifyf( thrd->rdy_link.next == 0p, "Expected null got %p", thrd->rdy_link.next );
         /* paranoid */ verify( 0x0D15EA5E0D15EA5Ep == thrd->canary );
 
@@ -628 +628 @@
                 // If that is the case, abandon the preemption.
                 bool preempted = false;
-                if(thrd->link.next == 0p) {
+                if(thrd->rdy_link.next == 0p) {
                         preempted = true;
                         thrd->preempted = reason;

libcfa/src/concurrency/kernel/cluster.cfa

@@ -483 +483 @@
 
         // We add a boat-load of assertions here because the anchor code is very fragile
-        /* 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 */ _Static_assert( offsetof( thread$, rdy_link ) == nested_offsetof(__intrusive_lane_t, l.anchor) );
+        /* paranoid */ verify( offsetof( thread$, rdy_link ) == nested_offsetof(__intrusive_lane_t, l.anchor) );
+        /* paranoid */ verify( ((uintptr_t)( mock_head(this) ) + offsetof( thread$, rdy_link )) == (uintptr_t)(&this.l.anchor) );
+        /* paranoid */ verify( &mock_head(this)->rdy_link.next == &this.l.anchor.next );
+        /* paranoid */ verify( &mock_head(this)->rdy_link.ts   == &this.l.anchor.ts   );
+        /* paranoid */ verify( mock_head(this)->rdy_link.next == 0p );
+        /* paranoid */ verify( mock_head(this)->rdy_link.ts   == MAX );
         /* paranoid */ verify( mock_head(this) == this.l.prev );
         /* paranoid */ verify( __alignof__(__intrusive_lane_t) == 64 );

libcfa/src/concurrency/kernel/startup.cfa

@@ -525 +525 @@
         self_mon.recursion = 1;
         self_mon_p = &self_mon;
-        link.next = 0p;
-        link.ts   = MAX;
+        rdy_link.next = 0p;
+        rdy_link.ts   = MAX;
         preferred = ready_queue_new_preferred();
         last_proc = 0p;

libcfa/src/concurrency/ready_subqueue.hfa

@@ -25 +25 @@
 static inline thread$ * mock_head(const __intrusive_lane_t & this) {
         thread$ * rhead = (thread$ *)(
-                (uintptr_t)( &this.l.anchor ) - __builtin_offsetof( thread$, link )
+                (uintptr_t)( &this.l.anchor ) - __builtin_offsetof( thread$, rdy_link )
         );
         return rhead;
@@ -34 +34 @@
 static inline void push( __intrusive_lane_t & this, thread$ * node ) {
         /* paranoid */ verify( this.l.lock );
-        /* paranoid */ verify( node->link.next == 0p );
-        /* paranoid */ verify( __atomic_load_n(&node->link.ts, __ATOMIC_RELAXED) == MAX  );
-        /* paranoid */ verify( this.l.prev->link.next == 0p );
-        /* paranoid */ verify( __atomic_load_n(&this.l.prev->link.ts, __ATOMIC_RELAXED)   == MAX  );
+        /* paranoid */ verify( node->rdy_link.next == 0p );
+        /* paranoid */ verify( __atomic_load_n(&node->rdy_link.ts, __ATOMIC_RELAXED) == MAX  );
+        /* paranoid */ verify( this.l.prev->rdy_link.next == 0p );
+        /* paranoid */ verify( __atomic_load_n(&this.l.prev->rdy_link.ts, __ATOMIC_RELAXED)   == MAX  );
         if( this.l.anchor.next == 0p ) {
                 /* paranoid */ verify( this.l.anchor.next == 0p );
@@ -51 +51 @@
 
         // Get the relevant nodes locally
-        this.l.prev->link.next = node;
-        __atomic_store_n(&this.l.prev->link.ts, rdtscl(), __ATOMIC_RELAXED);
+        this.l.prev->rdy_link.next = node;
+        __atomic_store_n(&this.l.prev->rdy_link.ts, rdtscl(), __ATOMIC_RELAXED);
         this.l.prev = node;
         #if !defined(__CFA_NO_STATISTICS__)
@@ -70 +70 @@
         // Get the relevant nodes locally
         thread$ * node = this.l.anchor.next;
-        this.l.anchor.next = node->link.next;
-        __atomic_store_n(&this.l.anchor.ts, __atomic_load_n(&node->link.ts, __ATOMIC_RELAXED), __ATOMIC_RELAXED);
+        this.l.anchor.next = node->rdy_link.next;
+        __atomic_store_n(&this.l.anchor.ts, __atomic_load_n(&node->rdy_link.ts, __ATOMIC_RELAXED), __ATOMIC_RELAXED);
         bool is_empty = this.l.anchor.next == 0p;
-        node->link.next = 0p;
-        __atomic_store_n(&node->link.ts, ULLONG_MAX, __ATOMIC_RELAXED);
+        node->rdy_link.next = 0p;
+        __atomic_store_n(&node->rdy_link.ts, ULLONG_MAX, __ATOMIC_RELAXED);
         #if !defined(__CFA_NO_STATISTICS__)
                 this.l.cnt--;
@@ -83 +83 @@
 
         unsigned long long ats = __atomic_load_n(&this.l.anchor.ts, __ATOMIC_RELAXED);
-        /* paranoid */ verify( node->link.next == 0p );
-        /* paranoid */ verify( __atomic_load_n(&node->link.ts , __ATOMIC_RELAXED) == MAX );
-        /* paranoid */ verify( __atomic_load_n(&node->link.ts , __ATOMIC_RELAXED) != 0   );
+        /* paranoid */ verify( node->rdy_link.next == 0p );
+        /* paranoid */ verify( __atomic_load_n(&node->rdy_link.ts , __ATOMIC_RELAXED) == MAX );
+        /* paranoid */ verify( __atomic_load_n(&node->rdy_link.ts , __ATOMIC_RELAXED) != 0   );
         /* paranoid */ verify( ats != 0 );
         /* paranoid */ verify( (ats == MAX) == is_empty );

libcfa/src/concurrency/thread.cfa

@@ -44 +44 @@
         self_mon_p = &self_mon;
         curr_cluster = &cl;
-        link.next = 0p;
-        link.ts   = MAX;
+        rdy_link.next = 0p;
+        rdy_link.ts   = MAX;
         preferred = ready_queue_new_preferred();
         last_proc = 0p;