Changes in / [124c1b7:7d94bfe3]

Location:

libcfa/src/concurrency

Files:

• kernel.cfa (modified) (8 diffs)
• ready_queue.cfa (modified) (5 diffs)
• snzi.hfa (modified) (1 diff)

libcfa/src/concurrency/kernel.cfa

@@ -228 +228 @@
 static void * __invoke_processor(void * arg);
 
-static init(processor & this, const char name[], cluster & _cltr) with( this ) {
+void ?{}(processor & this, const char name[], cluster & _cltr) with( this ) {
         this.name = name;
         this.cltr = &_cltr;
         id = -1u;
+        terminated{ 0 };
         destroyer = 0p;
         do_terminate = false;
         preemption_alarm = 0p;
         pending_preemption = false;
+        runner.proc = &this;
 
         #if !defined(__CFA_NO_STATISTICS__)
@@ -242 +244 @@
         #endif
 
+        idle{};
+
+        __cfadbg_print_safe(runtime_core, "Kernel : Starting core %p\n", &this);
+
+        this.stack = __create_pthread( &this.kernel_thread, __invoke_processor, (void *)&this );
         __atomic_fetch_add( &cltr->nprocessors, 1u, __ATOMIC_SEQ_CST );
 
-        id = doregister((__processor_id_t*)&this);
-
-        // Lock the RWlock so no-one pushes/pops while we are changing the queue
-        uint_fast32_t last_size = ready_mutate_lock();
-
-                // Adjust the ready queue size
-                ready_queue_grow( cltr );
-
-        // Unlock the RWlock
-        ready_mutate_unlock( last_size );
-
         __cfadbg_print_safe(runtime_core, "Kernel : core %p created\n", &this);
-}
-
-// Not a ctor, it just preps the destruction but should not destroy members
-void deinit(processor & this) {
-        // Lock the RWlock so no-one pushes/pops while we are changing the queue
-        uint_fast32_t last_size = ready_mutate_lock();
-
-                // Adjust the ready queue size
-                ready_queue_shrink( this.cltr );
-
-                // Make sure we aren't on the idle queue
-                unsafe_remove( this.cltr->idles, &this );
-
-        // Unlock the RWlock
-        ready_mutate_unlock( last_size );
-
-        // Finally we don't need the read_lock any more
-        unregister((__processor_id_t*)&this);
-}
-
-void ?{}(processor & this, const char name[], cluster & _cltr) {
-        ( this.idle ){};
-        ( this.terminated ){ 0 };
-        ( this.runner ){};
-        init( this, name, _cltr );
-
-        __cfadbg_print_safe(runtime_core, "Kernel : Starting core %p\n", &this);
-
-        this.stack = __create_pthread( &this.kernel_thread, __invoke_processor, (void *)&this );
-
 }
 
@@ -303 +269 @@
 
         free( this.stack );
-
-        deinit( this );
 
         __atomic_fetch_sub( &cltr->nprocessors, 1u, __ATOMIC_SEQ_CST );
@@ -354 +318 @@
 
         __cfadbg_print_safe(runtime_core, "Kernel : core %p starting\n", this);
-        #if !defined(__CFA_NO_STATISTICS__)
-                if( this->print_halts ) {
-                        __cfaabi_bits_print_safe( STDOUT_FILENO, "Processor : %d - %s (%p)\n", this->id, this->name, (void*)this);
-                }
-        #endif
+
+        // register the processor unless it's the main thread which is handled in the boot sequence
+        if(this != mainProcessor) {
+                this->id = doregister((__processor_id_t*)this);
+                #if !defined(__CFA_NO_STATISTICS__)
+                        if( this->print_halts ) {
+                                __cfaabi_bits_print_safe( STDOUT_FILENO, "Processor : %d - %s (%p)\n", this->id, this->name, (void*)this);
+                        }
+                #endif
+
+                // Lock the RWlock so no-one pushes/pops while we are changing the queue
+                uint_fast32_t last_size = ready_mutate_lock();
+
+                        // Adjust the ready queue size
+                        ready_queue_grow( this->cltr );
+
+                // Unlock the RWlock
+                ready_mutate_unlock( last_size );
+        }
 
         {
@@ -397 +375 @@
         V( this->terminated );
 
-        if(this == mainProcessor) {
+        // unregister the processor unless it's the main thread which is handled in the boot sequence
+        if(this != mainProcessor) {
+                // Lock the RWlock so no-one pushes/pops while we are changing the queue
+                uint_fast32_t last_size = ready_mutate_lock();
+
+                        // Adjust the ready queue size
+                        ready_queue_shrink( this->cltr );
+
+                        // Make sure we aren't on the idle queue
+                        #if !defined(__CFA_NO_STATISTICS__)
+                                bool removed =
+                        #endif
+                        unsafe_remove( this->cltr->idles, this );
+
+                        #if !defined(__CFA_NO_STATISTICS__)
+                                if(removed) __tls_stats()->ready.sleep.exits++;
+                        #endif
+
+                // Unlock the RWlock
+                ready_mutate_unlock( last_size );
+
+                // Finally we don't need the read_lock any more
+                unregister((__processor_id_t*)this);
+        }
+        else {
                 // HACK : the coroutine context switch expects this_thread to be set
                 // and it make sense for it to be set in all other cases except here
@@ -857 +859 @@
 
         void ?{}(processor & this) with( this ) {
-                ( this.idle ){};
-                ( this.terminated ){ 0 };
-                ( this.runner ){};
-                init( this, "Main Processor", *mainCluster );
+                name = "Main Processor";
+                cltr = mainCluster;
+                terminated{ 0 };
+                do_terminate = false;
+                preemption_alarm = 0p;
+                pending_preemption = false;
                 kernel_thread = pthread_self();
+                id = -1u;
+
+                #if !defined(__CFA_NO_STATISTICS__)
+                        print_stats = false;
+                        print_halts = false;
+                #endif
 
                 runner{ &this };
                 __cfadbg_print_safe(runtime_core, "Kernel : constructed main processor context %p\n", &runner);
+
+                __atomic_fetch_add( &cltr->nprocessors, 1u, __ATOMIC_SEQ_CST );
         }
 
@@ -871 +883 @@
         mainProcessor = (processor *)&storage_mainProcessor;
         (*mainProcessor){};
+
+        mainProcessor->id = doregister( (__processor_id_t*)mainProcessor);
 
         //initialize the global state variables
@@ -930 +944 @@
         kernel_stop_preemption();
 
+        unregister((__processor_id_t*)mainProcessor);
+
         // Destroy the main processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
         void ^?{}(processor & this) with( this ){
-                deinit( this );
-
                 /* paranoid */ verify( this.do_terminate == true );
                 __atomic_fetch_sub( &cltr->nprocessors, 1u, __ATOMIC_SEQ_CST );

libcfa/src/concurrency/ready_queue.cfa

@@ -186 +186 @@
 //=======================================================================
 void ?{}(__ready_queue_t & this) with (this) {
-        lanes.data  = 0p;
-        lanes.count = 0;
+
+        lanes.data = alloc(4);
+        for( i; 4 ) {
+                (lanes.data[i]){};
+        }
+        lanes.count = 4;
+        snzi{ log2( lanes.count / 8 ) };
 }
 
 void ^?{}(__ready_queue_t & this) with (this) {
-        verify( 0  == lanes.count );
+        verify( 4  == lanes.count );
         verify( !query( snzi ) );
+
+        ^(snzi){};
+
+        for( i; 4 ) {
+                ^(lanes.data[i]){};
+        }
         free(lanes.data);
 }
@@ -484 +495 @@
 }
 
-#warning remove when alloc is fixed
-forall( dtype T | sized(T) )
-static inline T * correct_alloc( T ptr[], size_t dim ) {
-        if( dim == 0 ) {
-                free(ptr);
-                return 0p;
-        }
-        T * temp = alloc( dim );
-        if(ptr) {
-                memcpy( temp, ptr, dim * sizeof(T));
-                free(ptr);
-        }
-        return temp;
-}
-
 // Grow the ready queue
 void ready_queue_grow  (struct cluster * cltr) {
@@ -517 +513 @@
 
                 // Allocate new array (uses realloc and memcpies the data)
-                lanes.data = correct_alloc(lanes.data, ncount);
+                lanes.data = alloc(lanes.data, ncount);
 
                 // Fix the moved data
@@ -562 +558 @@
                 size_t ocount = lanes.count;
                 // Check that we have some space left
-                if(ocount < 4) abort("Program attempted to destroy more Ready Queues than were created");
+                if(ocount < 8) abort("Program attempted to destroy more Ready Queues than were created");
 
                 // reduce the actual count so push doesn't use the old queues
@@ -604 +600 @@
 
                 // Allocate new array (uses realloc and memcpies the data)
-                lanes.data = correct_alloc(lanes.data, lanes.count);
+                lanes.data = alloc(lanes.data, lanes.count);
 
                 // Fix the moved data

libcfa/src/concurrency/snzi.hfa

@@ -120 +120 @@
 //--------------------------------------------------
 // SNZI object
-void  ?{}( __snzi_t & this ) {
-        this.mask = 0;
-        this.root = 0;
-        this.nodes = 0p;
-}
-
 void  ?{}( __snzi_t & this, unsigned depth ) with( this ) {
         mask = (1 << depth) - 1;