Changes in src/libcfa/concurrency/kernel.c [f32e53e:4aa2fb2]

File:

• src/libcfa/concurrency/kernel.c (modified) (22 diffs)

src/libcfa/concurrency/kernel.c

@@ -72 +72 @@
 // Main thread construction
 struct current_stack_info_t {
-        machine_context_t ctx;
+        machine_context_t ctx;  
         unsigned int size;              // size of stack
         void *base;                             // base of stack
@@ -82 +82 @@
 
 void ?{}( current_stack_info_t * this ) {
-        CtxGet( this->ctx );
+        CtxGet( &this->ctx );
         this->base = this->ctx.FP;
         this->storage = this->ctx.SP;
@@ -106 +106 @@
 
 void ?{}( coroutine_desc * this, current_stack_info_t * info) {
-        (&this->stack){ info };
+        (&this->stack){ info }; 
         this->name = "Main Thread";
         this->errno_ = 0;
@@ -184 +184 @@
 
 void ^?{}(cluster * this) {
-
+        
 }
 
@@ -203 +203 @@
 
                 thread_desc * readyThread = NULL;
-                for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ )
+                for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ ) 
                 {
                         readyThread = nextThread( this->cltr );
@@ -229 +229 @@
 }
 
-// runThread runs a thread by context switching
-// from the processor coroutine to the target thread
+// runThread runs a thread by context switching 
+// from the processor coroutine to the target thread 
 void runThread(processor * this, thread_desc * dst) {
         coroutine_desc * proc_cor = get_coroutine(this->runner);
         coroutine_desc * thrd_cor = get_coroutine(dst);
-
+        
         //Reset the terminating actions here
         this->finish.action_code = No_Action;
@@ -246 +246 @@
 }
 
-// Once a thread has finished running, some of
+// Once a thread has finished running, some of 
 // its final actions must be executed from the kernel
 void finishRunning(processor * this) {
@@ -256 +256 @@
         }
         else if( this->finish.action_code == Release_Schedule ) {
-                unlock( this->finish.lock );
+                unlock( this->finish.lock );            
                 ScheduleThread( this->finish.thrd );
         }
@@ -291 +291 @@
         // SKULLDUGGERY: We want to create a context for the processor coroutine
         // which is needed for the 2-step context switch. However, there is no reason
-        // to waste the perfectly valid stack create by pthread.
+        // to waste the perfectly valid stack create by pthread. 
         current_stack_info_t info;
         machine_context_t ctx;
@@ -306 +306 @@
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx);
 
-        // SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't
-        // resume it to start it like it normally would, it will just context switch
-        // back to here. Instead directly call the main since we already are on the
+        // SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't 
+        // resume it to start it like it normally would, it will just context switch 
+        // back to here. Instead directly call the main since we already are on the 
         // appropriate stack.
         proc_cor_storage.__cor.state = Active;
@@ -315 +315 @@
 
         // Main routine of the core returned, the core is now fully terminated
-        LIB_DEBUG_PRINT_SAFE("Kernel : core %p main ended (%p)\n", proc, proc->runner);
+        LIB_DEBUG_PRINT_SAFE("Kernel : core %p main ended (%p)\n", proc, proc->runner); 
 
         return NULL;
@@ -322 +322 @@
 void start(processor * this) {
         LIB_DEBUG_PRINT_SAFE("Kernel : Starting core %p\n", this);
-
+        
         pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
 
-        LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);
+        LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);       
 }
 
@@ -334 +334 @@
 
         verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
-
+        
         lock( &systemProcessor->proc.cltr->lock );
         append( &systemProcessor->proc.cltr->ready_queue, thrd );
@@ -392 +392 @@
 // Kernel boot procedures
 void kernel_startup(void) {
-        LIB_DEBUG_PRINT_SAFE("Kernel : Starting\n");
+        LIB_DEBUG_PRINT_SAFE("Kernel : Starting\n");    
 
         // Start by initializing the main thread
-        // SKULLDUGGERY: the mainThread steals the process main thread
+        // SKULLDUGGERY: the mainThread steals the process main thread 
         // which will then be scheduled by the systemProcessor normally
         mainThread = (thread_desc *)&mainThread_storage;
@@ -417 +417 @@
         systemProcessor{ systemCluster, (processorCtx_t *)&systemProcessorCtx_storage };
 
-        // Add the main thread to the ready queue
+        // Add the main thread to the ready queue 
         // once resume is called on systemProcessor->runner the mainThread needs to be scheduled like any normal thread
         ScheduleThread(mainThread);
@@ -428 +428 @@
         // SKULLDUGGERY: Force a context switch to the system processor to set the main thread's context to the current UNIX
         // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
-        // mainThread is on the ready queue when this call is made.
+        // mainThread is on the ready queue when this call is made. 
         resume( systemProcessor->proc.runner );
 
@@ -457 +457 @@
         ^(mainThread){};
 
-        LIB_DEBUG_PRINT_SAFE("Kernel : Shutdown complete\n");
+        LIB_DEBUG_PRINT_SAFE("Kernel : Shutdown complete\n");   
 }
 
@@ -473 +473 @@
                 kernel_abort_called = true;
                 unlock( &kernel_abort_lock );
-        }
+        } 
         else {
                 unlock( &kernel_abort_lock );
-
+                
                 sigset_t mask;
                 sigemptyset( &mask );
@@ -482 +482 @@
                 sigaddset( &mask, SIGUSR1 );                    // block SIGUSR1 signals
                 sigsuspend( &mask );                            // block the processor to prevent further damage during abort
-                _exit( EXIT_FAILURE );                          // if processor unblocks before it is killed, terminate it
+                _exit( EXIT_FAILURE );                          // if processor unblocks before it is killed, terminate it              
         }
 
@@ -497 +497 @@
                 len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", this_coroutine()->name, this_coroutine() );
                 __lib_debug_write( STDERR_FILENO, abort_text, len );
-        }
+        } 
         else {
                 __lib_debug_write( STDERR_FILENO, ".\n", 2 );
@@ -590 +590 @@
                 }
                 head->next = NULL;
-        }
+        }       
         return head;
 }
@@ -609 +609 @@
                 this->top = top->next;
                 top->next = NULL;
-        }
+        }       
         return top;
 }