Changeset e67a82d for libcfa/src/concurrency/kernel

Timestamp:

Aug 20, 2020, 11:48:15 PM (4 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

d685cb0

Parents:

67ca73e (diff), 013b028 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

fix conflicts

Location:

libcfa/src/concurrency/kernel

Files:

• fwd.hfa (modified) (2 diffs)
• startup.cfa (modified) (9 diffs)

libcfa/src/concurrency/kernel/fwd.hfa

@@ -50 +50 @@
                                 uint64_t rand_seed;
                         #endif
+                        struct {
+                                uint64_t fwd_seed;
+                                uint64_t bck_seed;
+                        } ready_rng;
                 } kernelTLS __attribute__ ((tls_model ( "initial-exec" )));
+
+
 
                 static inline uint64_t __tls_rand() {
@@ -58 +64 @@
                                 return __xorshift64( kernelTLS.rand_seed );
                         #endif
+                }
+
+                #define M  (1_l64u << 48_l64u)
+                #define A  (25214903917_l64u)
+                #define AI (18446708753438544741_l64u)
+                #define C  (11_l64u)
+                #define D  (16_l64u)
+
+                static inline unsigned __tls_rand_fwd() {
+
+                        kernelTLS.ready_rng.fwd_seed = (A * kernelTLS.ready_rng.fwd_seed + C) & (M - 1);
+                        return kernelTLS.ready_rng.fwd_seed >> D;
+                }
+
+                static inline unsigned __tls_rand_bck() {
+                        unsigned int r = kernelTLS.ready_rng.bck_seed >> D;
+                        kernelTLS.ready_rng.bck_seed = AI * (kernelTLS.ready_rng.bck_seed - C) & (M - 1);
+                        return r;
+                }
+
+                #undef M
+                #undef A
+                #undef AI
+                #undef C
+                #undef D
+
+                static inline void __tls_rand_advance_bck(void) {
+                        kernelTLS.ready_rng.bck_seed = kernelTLS.ready_rng.fwd_seed;
                 }
         }

libcfa/src/concurrency/kernel/startup.cfa

@@ -78 +78 @@
 static void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info);
 
+#if defined(__CFA_WITH_VERIFY__)
+        static bool verify_fwd_bck_rng(void);
+#endif
+
 //-----------------------------------------------------------------------------
 // Forward Declarations for other modules
@@ -87 +91 @@
 //-----------------------------------------------------------------------------
 // Other Forward Declarations
-extern bool __wake_proc(processor *);
+extern void __wake_proc(processor *);
 
 //-----------------------------------------------------------------------------
@@ -158 +162 @@
         __cfa_dbg_global_clusters.list{ __get };
         __cfa_dbg_global_clusters.lock{};
+
+        /* paranoid */ verify( verify_fwd_bck_rng() );
 
         // Initialize the global scheduler lock
@@ -475 +481 @@
         #endif
 
-        int target = __atomic_add_fetch( &cltr->nprocessors, 1u, __ATOMIC_SEQ_CST );
+        lock( this.cltr->idles );
+                int target = this.cltr->idles.total += 1u;
+        unlock( this.cltr->idles );
 
         id = doregister((__processor_id_t*)&this);
@@ -493 +501 @@
 // Not a ctor, it just preps the destruction but should not destroy members
 static void deinit(processor & this) {
-
-        int target = __atomic_sub_fetch( &this.cltr->nprocessors, 1u, __ATOMIC_SEQ_CST );
+        lock( this.cltr->idles );
+                int target = this.cltr->idles.total -= 1u;
+        unlock( this.cltr->idles );
 
         // Lock the RWlock so no-one pushes/pops while we are changing the queue
@@ -501 +510 @@
                 // Adjust the ready queue size
                 ready_queue_shrink( this.cltr, target );
-
-                // Make sure we aren't on the idle queue
-                unsafe_remove( this.cltr->idles, &this );
 
         // Unlock the RWlock
@@ -516 +522 @@
         ( this.terminated ){ 0 };
         ( this.runner ){};
-        init( this, name, _cltr );
+
+        disable_interrupts();
+                init( this, name, _cltr );
+        enable_interrupts( __cfaabi_dbg_ctx );
 
         __cfadbg_print_safe(runtime_core, "Kernel : Starting core %p\n", &this);
@@ -540 +549 @@
         free( this.stack );
 
-        deinit( this );
+        disable_interrupts();
+                deinit( this );
+        enable_interrupts( __cfaabi_dbg_ctx );
 }
 
 //-----------------------------------------------------------------------------
 // Cluster
+static void ?{}(__cluster_idles & this) {
+        this.lock  = 0;
+        this.idle  = 0;
+        this.total = 0;
+        (this.list){};
+}
+
 void ?{}(cluster & this, const char name[], Duration preemption_rate, unsigned num_io, const io_context_params & io_params) with( this ) {
         this.name = name;
         this.preemption_rate = preemption_rate;
-        this.nprocessors = 0;
         ready_queue{};
 
@@ -666 +683 @@
         return stack;
 }
+
+#if defined(__CFA_WITH_VERIFY__)
+static bool verify_fwd_bck_rng(void) {
+        kernelTLS.ready_rng.fwd_seed = 25214903917_l64u * (rdtscl() ^ (uintptr_t)&verify_fwd_bck_rng);
+
+        unsigned values[10];
+        for(i; 10) {
+                values[i] = __tls_rand_fwd();
+        }
+
+        __tls_rand_advance_bck();
+
+        for ( i; 9 -~= 0 ) {
+                if(values[i] != __tls_rand_bck()) {
+                        return false;
+                }
+        }
+
+        return true;
+}
+#endif