Index: src/libcfa/concurrency/alarm.c =================================================================== --- src/libcfa/concurrency/alarm.c (revision b706db104eccacb1970696b4e147de19fdfb616d) +++ src/libcfa/concurrency/alarm.c (revision e60e0dc41c51d3729b99dd9bd3c6864794d982ce) @@ -153,20 +153,18 @@ void register_self( alarm_node_t * this ) { + alarm_list_t * alarms = &event_kernel->alarms; + disable_interrupts(); - verify( !systemProcessor->pending_alarm ); - lock( &systemProcessor->alarm_lock DEBUG_CTX2 ); + lock( &event_kernel->lock DEBUG_CTX2 ); { - verify( validate( &systemProcessor->alarms ) ); - bool first = !systemProcessor->alarms.head; + verify( validate( alarms ) ); + bool first = !alarms->head; - insert( &systemProcessor->alarms, this ); - if( systemProcessor->pending_alarm ) { - tick_preemption(); - } + insert( alarms, this ); if( first ) { - __kernel_set_timer( systemProcessor->alarms.head->alarm - __kernel_get_time() ); + __kernel_set_timer( alarms->head->alarm - __kernel_get_time() ); } } - unlock( &systemProcessor->alarm_lock ); + unlock( &event_kernel->lock ); this->set = true; enable_interrupts( DEBUG_CTX ); @@ -174,14 +172,12 @@ void unregister_self( alarm_node_t * this ) { - // LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Kernel : unregister %p start\n", this ); disable_interrupts(); - lock( &systemProcessor->alarm_lock DEBUG_CTX2 ); + lock( &event_kernel->lock DEBUG_CTX2 ); { - verify( validate( &systemProcessor->alarms ) ); - remove( &systemProcessor->alarms, this ); + verify( validate( &event_kernel->alarms ) ); + remove( &event_kernel->alarms, this ); } - unlock( &systemProcessor->alarm_lock ); + unlock( &event_kernel->lock ); enable_interrupts( DEBUG_CTX ); this->set = false; - // LIB_DEBUG_PRINT_BUFFER_LOCAL( STDERR_FILENO, "Kernel : unregister %p end\n", this ); } Index: src/libcfa/concurrency/kernel =================================================================== --- src/libcfa/concurrency/kernel (revision b706db104eccacb1970696b4e147de19fdfb616d) +++ src/libcfa/concurrency/kernel (revision e60e0dc41c51d3729b99dd9bd3c6864794d982ce) @@ -28,8 +28,8 @@ //----------------------------------------------------------------------------- // Locks -bool try_lock ( spinlock * DEBUG_CTX_PARAM2 ); -void lock ( spinlock * DEBUG_CTX_PARAM2 ); -void lock_yield( spinlock * DEBUG_CTX_PARAM2 ); -void unlock ( spinlock * ); +void lock ( spinlock * DEBUG_CTX_PARAM2 ); // Lock the spinlock, spin if already acquired +void lock_yield( spinlock * DEBUG_CTX_PARAM2 ); // Lock the spinlock, yield repeatedly if already acquired +bool try_lock ( spinlock * DEBUG_CTX_PARAM2 ); // Lock the spinlock, return false if already acquired +void unlock ( spinlock * ); // Unlock the spinlock struct semaphore { @@ -48,6 +48,7 @@ // Cluster struct cluster { - __thread_queue_t ready_queue; - spinlock lock; + spinlock ready_queue_lock; // Ready queue locks + __thread_queue_t ready_queue; // Ready queue for threads + unsigned long long int preemption; // Preemption rate on this cluster }; @@ -76,20 +77,26 @@ static inline void ^?{}(FinishAction * this) {} +// Processor +// Wrapper around kernel threads struct processor { - struct processorCtx_t * runner; - cluster * cltr; - pthread_t kernel_thread; + // Main state + struct processorCtx_t * runner; // Coroutine ctx who does keeps the state of the processor + cluster * cltr; // Cluster from which to get threads + pthread_t kernel_thread; // Handle to pthreads - semaphore terminated; - volatile bool is_terminated; + // Termination + volatile bool do_terminate; // Set to true to notify the processor should terminate + semaphore terminated; // Termination synchronisation - struct FinishAction finish; + // RunThread data + struct FinishAction finish; // Action to do after a thread is ran - struct alarm_node_t * preemption_alarm; - unsigned int preemption; + // Preemption data + struct alarm_node_t * preemption_alarm; // Node which is added in the discrete event simulaiton + bool pending_preemption; // If true, a preemption was triggered in an unsafe region, the processor must preempt as soon as possible - bool pending_preemption; - - char * last_enable; +#ifdef __CFA_DEBUG__ + char * last_enable; // Last function to enable preemption on this processor +#endif }; Index: src/libcfa/concurrency/kernel.c =================================================================== --- src/libcfa/concurrency/kernel.c (revision b706db104eccacb1970696b4e147de19fdfb616d) +++ src/libcfa/concurrency/kernel.c (revision e60e0dc41c51d3729b99dd9bd3c6864794d982ce) @@ -47,4 +47,5 @@ KERNEL_STORAGE(cluster, systemCluster); KERNEL_STORAGE(system_proc_t, systemProcessor); +KERNEL_STORAGE(event_kernel_t, event_kernel); KERNEL_STORAGE(thread_desc, mainThread); KERNEL_STORAGE(machine_context_t, mainThreadCtx); @@ -52,4 +53,5 @@ cluster * systemCluster; system_proc_t * systemProcessor; +event_kernel_t * event_kernel; thread_desc * mainThread; @@ -131,7 +133,6 @@ this->cltr = cltr; (&this->terminated){ 0 }; - this->is_terminated = false; + this->do_terminate = false; this->preemption_alarm = NULL; - this->preemption = default_preemption(); this->pending_preemption = false; @@ -142,7 +143,6 @@ this->cltr = cltr; (&this->terminated){ 0 }; - this->is_terminated = false; + this->do_terminate = false; this->preemption_alarm = NULL; - this->preemption = default_preemption(); this->pending_preemption = false; this->kernel_thread = pthread_self(); @@ -156,9 +156,10 @@ void ?{}(system_proc_t * this, cluster * cltr, processorCtx_t * runner) { + (&this->proc){ cltr, runner }; +} + +void ?{}(event_kernel_t * this) { (&this->alarms){}; - (&this->alarm_lock){}; - this->pending_alarm = false; - - (&this->proc){ cltr, runner }; + (&this->lock){}; verify( validate( &this->alarms ) ); @@ -166,7 +167,7 @@ void ^?{}(processor * this) { - if( ! this->is_terminated ) { + if( ! this->do_terminate ) { LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", this); - this->is_terminated = true; + this->do_terminate = true; P( &this->terminated ); pthread_join( this->kernel_thread, NULL ); @@ -176,5 +177,7 @@ void ?{}(cluster * this) { ( &this->ready_queue ){}; - ( &this->lock ){}; + ( &this->ready_queue_lock ){}; + + this->preemption = default_preemption(); } @@ -199,5 +202,5 @@ thread_desc * readyThread = NULL; - for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ ) + for( unsigned int spin_count = 0; ! this->do_terminate; spin_count++ ) { readyThread = nextThread( this->cltr ); @@ -343,7 +346,7 @@ verifyf( thrd->next == NULL, "Expected null got %p", thrd->next ); - lock( &systemProcessor->proc.cltr->lock DEBUG_CTX2 ); + lock( &systemProcessor->proc.cltr->ready_queue_lock DEBUG_CTX2 ); append( &systemProcessor->proc.cltr->ready_queue, thrd ); - unlock( &systemProcessor->proc.cltr->lock ); + unlock( &systemProcessor->proc.cltr->ready_queue_lock ); verify( disable_preempt_count > 0 ); @@ -352,7 +355,7 @@ thread_desc * nextThread(cluster * this) { verify( disable_preempt_count > 0 ); - lock( &this->lock DEBUG_CTX2 ); + lock( &this->ready_queue_lock DEBUG_CTX2 ); thread_desc * head = pop_head( &this->ready_queue ); - unlock( &this->lock ); + unlock( &this->ready_queue_lock ); verify( disable_preempt_count > 0 ); return head; @@ -470,4 +473,8 @@ systemProcessor{ systemCluster, (processorCtx_t *)&systemProcessorCtxStorage }; + // Initialize the event kernel + event_kernel = (event_kernel_t *)&event_kernelStorage; + event_kernel{}; + // 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 @@ -504,5 +511,5 @@ // When its coroutine terminates, it return control to the mainThread // which is currently here - systemProcessor->proc.is_terminated = true; + systemProcessor->proc.do_terminate = true; suspend(); Index: src/libcfa/concurrency/kernel_private.h =================================================================== --- src/libcfa/concurrency/kernel_private.h (revision b706db104eccacb1970696b4e147de19fdfb616d) +++ src/libcfa/concurrency/kernel_private.h (revision e60e0dc41c51d3729b99dd9bd3c6864794d982ce) @@ -45,4 +45,5 @@ thread_desc * nextThread(cluster * this); +//Block current thread and release/wake-up the following resources void BlockInternal(void); void BlockInternal(spinlock * lock); @@ -67,13 +68,15 @@ struct system_proc_t { processor proc; +}; +struct event_kernel_t { alarm_list_t alarms; - spinlock alarm_lock; - - bool pending_alarm; + spinlock lock; }; extern cluster * systemCluster; extern system_proc_t * systemProcessor; +extern event_kernel_t * event_kernel; + extern volatile thread_local processor * this_processor; extern volatile thread_local coroutine_desc * this_coroutine; Index: src/libcfa/concurrency/preemption.c =================================================================== --- src/libcfa/concurrency/preemption.c (revision b706db104eccacb1970696b4e147de19fdfb616d) +++ src/libcfa/concurrency/preemption.c (revision e60e0dc41c51d3729b99dd9bd3c6864794d982ce) @@ -66,5 +66,5 @@ void tick_preemption() { - alarm_list_t * alarms = &systemProcessor->alarms; + alarm_list_t * alarms = &event_kernel->alarms; __cfa_time_t currtime = __kernel_get_time(); @@ -189,8 +189,4 @@ } -static inline void defer_alarm() { - systemProcessor->pending_alarm = true; -} - static void preempt( processor * this ) { pthread_kill( this->kernel_thread, SIGUSR1 ); @@ -236,5 +232,5 @@ this->proc = proc; this->proc->preemption_alarm = &this->alarm; - update_preemption( this->proc, this->proc->preemption ); + update_preemption( this->proc, this->proc->cltr->preemption ); } @@ -283,7 +279,7 @@ case SI_KERNEL: LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread tick\n"); - lock( &systemProcessor->alarm_lock DEBUG_CTX2 ); + lock( &event_kernel->lock DEBUG_CTX2 ); tick_preemption(); - unlock( &systemProcessor->alarm_lock ); + unlock( &event_kernel->lock ); break; case SI_QUEUE: