Changeset 12c1eef for libcfa/src/concurrency/kernel

Timestamp:

Jan 19, 2022, 2:36:56 PM (4 years ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum, stuck-waitfor-destruct

Children:

97c215f

Parents:

5235d49 (diff), 6a33e40 (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:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

libcfa/src/concurrency/kernel

Files:

• fwd.hfa (modified) (3 diffs)
• startup.cfa (modified) (11 diffs)

libcfa/src/concurrency/kernel/fwd.hfa

@@ -77 +77 @@
 
                 static inline uint64_t __tls_rand() {
+                        return
                         #if defined(__SIZEOF_INT128__)
-                                return __lehmer64( kernelTLS().rand_seed );
+                                lehmer64( kernelTLS().rand_seed );
                         #else
-                                return __xorshift64( kernelTLS().rand_seed );
+                                xorshift_13_7_17( 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;
+                        return LCGBI_fwd( kernelTLS().ready_rng.fwd_seed );
                 }
 
                 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
+                        return LCGBI_bck( kernelTLS().ready_rng.bck_seed );
+                }
 
                 static inline void __tls_rand_advance_bck(void) {
@@ -112 +97 @@
                 }
         }
-
-
 
         extern void disable_interrupts();
@@ -142 +125 @@
                         }
                 }
-
-                extern uint64_t thread_rand();
 
                 // Semaphore which only supports a single thread

libcfa/src/concurrency/kernel/startup.cfa

@@ -34 +34 @@
 #include "kernel_private.hfa"
 #include "startup.hfa"          // STARTUP_PRIORITY_XXX
+#include "limits.hfa"
 #include "math.hfa"
 
@@ -101 +102 @@
 extern void __wake_proc(processor *);
 extern int cfa_main_returned;                                                   // from interpose.cfa
+extern uint32_t __global_random_seed;
 
 //-----------------------------------------------------------------------------
@@ -176 +178 @@
 
 
-
 //=============================================================================================
 // Kernel Setup logic
@@ -279 +280 @@
         // When its coroutine terminates, it return control to the mainThread
         // which is currently here
+        /* paranoid */ verify( !__atomic_load_n(&mainProcessor->do_terminate, __ATOMIC_ACQUIRE) );
         __atomic_store_n(&mainProcessor->do_terminate, true, __ATOMIC_RELEASE);
+        __wake_proc( mainProcessor );
         __kernel_last_resume( __cfaabi_tls.this_processor );
         mainThread->self_cor.state = Halted;
@@ -403 +406 @@
 
         __cfaabi_tls.this_thread->curr_cor = dst;
-        __stack_prepare( &dst->stack, 65000 );
+        __stack_prepare( &dst->stack, DEFAULT_STACK_SIZE );
         __cfactx_start(main, dst, this->runner, __cfactx_invoke_coroutine);
 
@@ -487 +490 @@
         preferred = ready_queue_new_preferred();
         last_proc = 0p;
+        random_state = __global_random_seed;
         #if defined( __CFA_WITH_VERIFY__ )
                 canary = 0x0D15EA5E0D15EA5Ep;
@@ -511 +515 @@
         this.rdq.its = 0;
         this.rdq.itr = 0;
-        this.rdq.id  = -1u;
-        this.rdq.target = -1u;
-        this.rdq.last = -1u;
-        this.rdq.cutoff = 0ull;
+        this.rdq.id  = MAX;
+        this.rdq.target = MAX;
+        this.rdq.last = MAX;
+        this.rdq.cpu = 0;
+        // this.rdq.cutoff = 0ull;
         do_terminate = false;
         preemption_alarm = 0p;
@@ -564 +569 @@
 extern size_t __page_size;
 void ^?{}(processor & this) with( this ){
-        if( ! __atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) ) {
-                __cfadbg_print_safe(runtime_core, "Kernel : core %p signaling termination\n", &this);
-
-                __atomic_store_n(&do_terminate, true, __ATOMIC_RELAXED);
+        /* paranoid */ verify( !__atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) );
+        __cfadbg_print_safe(runtime_core, "Kernel : core %p signaling termination\n", &this);
+
+        __atomic_store_n(&do_terminate, true, __ATOMIC_RELAXED);
+        __disable_interrupts_checked();
                 __wake_proc( &this );
-
-                wait( terminated );
-                /* paranoid */ verify( active_processor() != &this);
-        }
+        __enable_interrupts_checked();
+
+        wait( terminated );
+        /* paranoid */ verify( active_processor() != &this);
 
         __destroy_pthread( kernel_thread, this.stack, 0p );
@@ -682 +688 @@
         [this->unique_id, last_size] = ready_mutate_register();
 
+                this->rdq.cpu = __kernel_getcpu();
+
                 this->cltr->procs.total += 1u;
                 insert_last(this->cltr->procs.actives, *this);
@@ -721 +729 @@
         check( pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
 
-        size_t stacksize;
-        // default stack size, normally defined by shell limit
-        check( pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
-        assert( stacksize >= PTHREAD_STACK_MIN );
+        size_t stacksize = DEFAULT_STACK_SIZE;
 
         void * stack;
@@ -749 +754 @@
         #endif
 
-
         check( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
-
         check( pthread_create( pthread, &attr, start, arg ), "pthread_create" );
         return stack;