source: src/libcfa/concurrency/preemption.c @ 9181f1d

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumwith_gc
Last change on this file since 9181f1d was 8ad6533, checked in by Peter A. Buhr <pabuhr@…>, 7 years ago

remove cfatime.h, move itimerval constructor to "time", update concurrent examples to use Duration

  • Property mode set to 100644
File size: 13.3 KB
RevLine 
[c81ebf9]1//
2// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// signal.c --
8//
9// Author           : Thierry Delisle
10// Created On       : Mon Jun 5 14:20:42 2017
[6b0b624]11// Last Modified By : Peter A. Buhr
[8ad6533]12// Last Modified On : Mon Apr  9 13:52:39 2018
13// Update Count     : 36
[c81ebf9]14//
15
16#include "preemption.h"
17
18extern "C" {
[82ff5845]19#include <errno.h>
20#include <stdio.h>
21#include <string.h>
22#include <unistd.h>
[c81ebf9]23}
24
[dbe9b08]25#include "bits/signal.h"
[82ff5845]26
[d8548e2]27#if !defined(__CFA_DEFAULT_PREEMPTION__)
[2a84d06d]28#define __CFA_DEFAULT_PREEMPTION__ 10`ms
[d8548e2]29#endif
[c81ebf9]30
[2a84d06d]31Duration default_preemption() __attribute__((weak)) {
[c81ebf9]32        return __CFA_DEFAULT_PREEMPTION__;
33}
34
[969b3fe]35// FwdDeclarations : timeout handlers
[c81ebf9]36static void preempt( processor   * this );
37static void timeout( thread_desc * this );
38
[969b3fe]39// FwdDeclarations : Signal handlers
[82ff5845]40void sigHandler_ctxSwitch( __CFA_SIGPARMS__ );
[1c273d0]41void sigHandler_segv     ( __CFA_SIGPARMS__ );
[2b8bc41]42void sigHandler_ill      ( __CFA_SIGPARMS__ );
43void sigHandler_fpe      ( __CFA_SIGPARMS__ );
[1c273d0]44void sigHandler_abort    ( __CFA_SIGPARMS__ );
[82ff5845]45
[969b3fe]46// FwdDeclarations : alarm thread main
47void * alarm_loop( __attribute__((unused)) void * args );
48
49// Machine specific register name
[381fdee]50#if   defined( __i386 )
[b2b44d8]51#define CFA_REG_IP gregs[REG_EIP]
[381fdee]52#elif defined( __x86_64 )
53#define CFA_REG_IP gregs[REG_RIP]
54#elif defined( __ARM_ARCH )
[b2b44d8]55#define CFA_REG_IP arm_pc
[381fdee]56#else
57#error unknown hardware architecture
[cd17862]58#endif
59
[969b3fe]60KERNEL_STORAGE(event_kernel_t, event_kernel);         // private storage for event kernel
61event_kernel_t * event_kernel;                        // kernel public handle to even kernel
62static pthread_t alarm_thread;                        // pthread handle to alarm thread
63
[65deb18]64void ?{}(event_kernel_t & this) with( this ) {
65        alarms{};
66        lock{};
[969b3fe]67}
[82ff5845]68
[4dad189]69enum {
70        PREEMPT_NORMAL    = 0,
71        PREEMPT_TERMINATE = 1,
72};
73
[c81ebf9]74//=============================================================================================
75// Kernel Preemption logic
76//=============================================================================================
77
[969b3fe]78// Get next expired node
[2a84d06d]79static inline alarm_node_t * get_expired( alarm_list_t * alarms, Time currtime ) {
[969b3fe]80        if( !alarms->head ) return NULL;                          // If no alarms return null
81        if( alarms->head->alarm >= currtime ) return NULL;        // If alarms head not expired return null
82        return pop(alarms);                                       // Otherwise just pop head
83}
84
85// Tick one frame of the Discrete Event Simulation for alarms
[c81ebf9]86void tick_preemption() {
[969b3fe]87        alarm_node_t * node = NULL;                     // Used in the while loop but cannot be declared in the while condition
88        alarm_list_t * alarms = &event_kernel->alarms;  // Local copy for ease of reading
[2a84d06d]89        Time currtime = __kernel_get_time();                    // Check current time once so we everything "happens at once"
[8cb529e]90
[969b3fe]91        //Loop throught every thing expired
92        while( node = get_expired( alarms, currtime ) ) {
[1c273d0]93
[969b3fe]94                // Check if this is a kernel
[c81ebf9]95                if( node->kernel_alarm ) {
96                        preempt( node->proc );
97                }
98                else {
99                        timeout( node->thrd );
100                }
101
[969b3fe]102                // Check if this is a periodic alarm
[2a84d06d]103                Duration period = node->period;
[8cb529e]104                if( period > 0 ) {
[969b3fe]105                        node->alarm = currtime + period;    // Alarm is periodic, add currtime to it (used cached current time)
106                        insert( alarms, node );             // Reinsert the node for the next time it triggers
[c81ebf9]107                }
108                else {
[969b3fe]109                        node->set = false;                  // Node is one-shot, just mark it as not pending
[c81ebf9]110                }
111        }
112
[969b3fe]113        // If there are still alarms pending, reset the timer
114        if( alarms->head ) { __kernel_set_timer( alarms->head->alarm - currtime ); }
[c81ebf9]115}
116
[969b3fe]117// Update the preemption of a processor and notify interested parties
[2a84d06d]118void update_preemption( processor * this, Duration duration ) {
[c81ebf9]119        alarm_node_t * alarm = this->preemption_alarm;
120
121        // Alarms need to be enabled
[2a84d06d]122        if ( duration > 0 && ! alarm->set ) {
[c81ebf9]123                alarm->alarm = __kernel_get_time() + duration;
124                alarm->period = duration;
125                register_self( alarm );
126        }
[8ad6533]127        // Zero duration but alarm is set
[c81ebf9]128        else if ( duration == 0 && alarm->set ) {
129                unregister_self( alarm );
130                alarm->alarm = 0;
131                alarm->period = 0;
132        }
133        // If alarm is different from previous, change it
134        else if ( duration > 0 && alarm->period != duration ) {
135                unregister_self( alarm );
136                alarm->alarm = __kernel_get_time() + duration;
137                alarm->period = duration;
138                register_self( alarm );
139        }
140}
141
142//=============================================================================================
[cd17862]143// Kernel Signal Tools
[c81ebf9]144//=============================================================================================
145
[36982fc]146__cfaabi_dbg_debug_do( static thread_local void * last_interrupt = 0; )
[b227f68]147
[82ff5845]148extern "C" {
[969b3fe]149        // Disable interrupts by incrementing the counter
[82ff5845]150        void disable_interrupts() {
[b10affd]151                TL_GET( preemption_state ).enabled = false;
152                __attribute__((unused)) unsigned short new_val = TL_GET( preemption_state ).disable_count + 1;
153                TL_GET( preemption_state ).disable_count = new_val;
[969b3fe]154                verify( new_val < 65_000u );              // If this triggers someone is disabling interrupts without enabling them
[82ff5845]155        }
156
[969b3fe]157        // Enable interrupts by decrementing the counter
158        // If counter reaches 0, execute any pending CtxSwitch
[36982fc]159        void enable_interrupts( __cfaabi_dbg_ctx_param ) {
[b10affd]160                processor   * proc = TL_GET( this_processor ); // Cache the processor now since interrupts can start happening after the atomic add
161                thread_desc * thrd = TL_GET( this_thread );       // Cache the thread now since interrupts can start happening after the atomic add
[969b3fe]162
[b10affd]163                unsigned short prev = TL_GET( preemption_state ).disable_count;
164                TL_GET( preemption_state ).disable_count -= 1;
[969b3fe]165                verify( prev != 0u );                     // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
166
167                // Check if we need to prempt the thread because an interrupt was missed
[d0a045c7]168                if( prev == 1 ) {
[b10affd]169                        TL_GET( preemption_state ).enabled = true;
[d0a045c7]170                        if( proc->pending_preemption ) {
171                                proc->pending_preemption = false;
172                                BlockInternal( thrd );
173                        }
[82ff5845]174                }
[4e6fb8e]175
[969b3fe]176                // For debugging purposes : keep track of the last person to enable the interrupts
[36982fc]177                __cfaabi_dbg_debug_do( proc->last_enable = caller; )
[82ff5845]178        }
[969b3fe]179
180        // Disable interrupts by incrementint the counter
181        // Don't execute any pending CtxSwitch even if counter reaches 0
182        void enable_interrupts_noPoll() {
[b10affd]183                unsigned short prev = TL_GET( preemption_state ).disable_count;
184                TL_GET( preemption_state ).disable_count -= 1;
[2e9aed4]185                verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
[d0a045c7]186                if( prev == 1 ) {
[b10affd]187                        TL_GET( preemption_state ).enabled = true;
[d0a045c7]188                }
[969b3fe]189        }
[82ff5845]190}
191
[969b3fe]192// sigprocmask wrapper : unblock a single signal
[1c273d0]193static inline void signal_unblock( int sig ) {
[82ff5845]194        sigset_t mask;
195        sigemptyset( &mask );
[1c273d0]196        sigaddset( &mask, sig );
[82ff5845]197
[47ecf2b]198        if ( pthread_sigmask( SIG_UNBLOCK, &mask, NULL ) == -1 ) {
[169d944]199            abort( "internal error, pthread_sigmask" );
[cd17862]200        }
[82ff5845]201}
202
[969b3fe]203// sigprocmask wrapper : block a single signal
[cd17862]204static inline void signal_block( int sig ) {
205        sigset_t mask;
206        sigemptyset( &mask );
207        sigaddset( &mask, sig );
[47ecf2b]208
[cd17862]209        if ( pthread_sigmask( SIG_BLOCK, &mask, NULL ) == -1 ) {
[169d944]210            abort( "internal error, pthread_sigmask" );
[cd17862]211        }
212}
[47ecf2b]213
[969b3fe]214// kill wrapper : signal a processor
[cd17862]215static void preempt( processor * this ) {
[4dad189]216        sigval_t value = { PREEMPT_NORMAL };
217        pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
218}
219
220// kill wrapper : signal a processor
221void terminate(processor * this) {
222        this->do_terminate = true;
223        sigval_t value = { PREEMPT_TERMINATE };
224        pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
[1c273d0]225}
[82ff5845]226
[969b3fe]227// reserved for future use
[cd17862]228static void timeout( thread_desc * this ) {
229        //TODO : implement waking threads
230}
231
[969b3fe]232
233// Check if a CtxSwitch signal handler shoud defer
234// If true  : preemption is safe
235// If false : preemption is unsafe and marked as pending
236static inline bool preemption_ready() {
[b10affd]237        bool ready = TL_GET( preemption_state ).enabled && !TL_GET( preemption_state ).in_progress; // Check if preemption is safe
238        TL_GET( this_processor )->pending_preemption = !ready;                  // Adjust the pending flag accordingly
[969b3fe]239        return ready;
240}
241
[cd17862]242//=============================================================================================
243// Kernel Signal Startup/Shutdown logic
244//=============================================================================================
245
[969b3fe]246// Startup routine to activate preemption
247// Called from kernel_startup
[cd17862]248void kernel_start_preemption() {
[169d944]249        __cfaabi_dbg_print_safe( "Kernel : Starting preemption\n" );
[969b3fe]250
251        // Start with preemption disabled until ready
[b10affd]252        TL_GET( preemption_state ).enabled = false;
253        TL_GET( preemption_state ).disable_count = 1;
[969b3fe]254
255        // Initialize the event kernel
256        event_kernel = (event_kernel_t *)&storage_event_kernel;
[9236060]257        (*event_kernel){};
[969b3fe]258
259        // Setup proper signal handlers
[2b8bc41]260        __cfaabi_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO | SA_RESTART );         // CtxSwitch handler
[cd17862]261
262        signal_block( SIGALRM );
263
264        pthread_create( &alarm_thread, NULL, alarm_loop, NULL );
265}
266
[969b3fe]267// Shutdown routine to deactivate preemption
268// Called from kernel_shutdown
[cd17862]269void kernel_stop_preemption() {
[169d944]270        __cfaabi_dbg_print_safe( "Kernel : Preemption stopping\n" );
[d6ff3ff]271
[969b3fe]272        // Block all signals since we are already shutting down
[cd17862]273        sigset_t mask;
274        sigfillset( &mask );
275        sigprocmask( SIG_BLOCK, &mask, NULL );
276
[969b3fe]277        // Notify the alarm thread of the shutdown
[a0b3e32]278        sigval val = { 1 };
279        pthread_sigqueue( alarm_thread, SIGALRM, val );
[969b3fe]280
281        // Wait for the preemption thread to finish
[cd17862]282        pthread_join( alarm_thread, NULL );
[969b3fe]283
284        // Preemption is now fully stopped
285
[169d944]286        __cfaabi_dbg_print_safe( "Kernel : Preemption stopped\n" );
[cd17862]287}
288
[969b3fe]289// Raii ctor/dtor for the preemption_scope
290// Used by thread to control when they want to receive preemption signals
[242a902]291void ?{}( preemption_scope & this, processor * proc ) {
[2a84d06d]292        (this.alarm){ proc, (Time){ 0 }, 0`s };
[242a902]293        this.proc = proc;
294        this.proc->preemption_alarm = &this.alarm;
[969b3fe]295
[d8548e2]296        update_preemption( this.proc, this.proc->cltr->preemption_rate );
[cd17862]297}
298
[242a902]299void ^?{}( preemption_scope & this ) {
[cd17862]300        disable_interrupts();
301
[2a84d06d]302        update_preemption( this.proc, 0`s );
[cd17862]303}
304
305//=============================================================================================
306// Kernel Signal Handlers
307//=============================================================================================
[47ecf2b]308
[969b3fe]309// Context switch signal handler
310// Receives SIGUSR1 signal and causes the current thread to yield
[1c273d0]311void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ) {
[b2b44d8]312        __cfaabi_dbg_debug_do( last_interrupt = (void *)(cxt->uc_mcontext.CFA_REG_IP); )
[969b3fe]313
[4dad189]314        // SKULLDUGGERY: if a thread creates a processor and the immediately deletes it,
315        // the interrupt that is supposed to force the kernel thread to preempt might arrive
316        // before the kernel thread has even started running. When that happens an iterrupt
317        // we a null 'this_processor' will be caught, just ignore it.
[b10affd]318        if(!TL_GET( this_processor )) return;
[4dad189]319
320        choose(sfp->si_value.sival_int) {
321                case PREEMPT_NORMAL   : ;// Normal case, nothing to do here
[b10affd]322                case PREEMPT_TERMINATE: verify(TL_GET( this_processor )->do_terminate);
[4dad189]323                default:
[ff878b7]324                        abort( "internal error, signal value is %d", sfp->si_value.sival_int );
[4dad189]325        }
326
[b2b44d8]327        // Check if it is safe to preempt here
[969b3fe]328        if( !preemption_ready() ) { return; }
329
[169d944]330        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
[05615ba]331
[b10affd]332        TL_GET( preemption_state ).in_progress = true;  // Sync flag : prevent recursive calls to the signal handler
[969b3fe]333        signal_unblock( SIGUSR1 );                          // We are about to CtxSwitch out of the signal handler, let other handlers in
[b10affd]334        TL_GET( preemption_state ).in_progress = false; // Clear the in progress flag
[969b3fe]335
336        // Preemption can occur here
337
[b10affd]338        BlockInternal( (thread_desc*)TL_GET( this_thread ) ); // Do the actual CtxSwitch
[c81ebf9]339}
340
[969b3fe]341// Main of the alarm thread
342// Waits on SIGALRM and send SIGUSR1 to whom ever needs it
[cd17862]343void * alarm_loop( __attribute__((unused)) void * args ) {
[969b3fe]344        // Block sigalrms to control when they arrive
[cd17862]345        sigset_t mask;
346        sigemptyset( &mask );
347        sigaddset( &mask, SIGALRM );
348
349        if ( pthread_sigmask( SIG_BLOCK, &mask, NULL ) == -1 ) {
[169d944]350            abort( "internal error, pthread_sigmask" );
[82ff5845]351        }
[c81ebf9]352
[969b3fe]353        // Main loop
[cd17862]354        while( true ) {
[969b3fe]355                // Wait for a sigalrm
[a0b3e32]356                siginfo_t info;
357                int sig = sigwaitinfo( &mask, &info );
[969b3fe]358
[e2f7bc3]359                if( sig < 0 ) {
360                        //Error!
361                        int err = errno;
362                        switch( err ) {
363                                case EAGAIN :
364                                case EINTR :
365                                        continue;
366                        case EINVAL :
[169d944]367                                        abort( "Timeout was invalid." );
[e2f7bc3]368                                default:
[169d944]369                                        abort( "Unhandled error %d", err);
[e2f7bc3]370                        }
371                }
372
[969b3fe]373                // If another signal arrived something went wrong
[8cb529e]374                assertf(sig == SIGALRM, "Kernel Internal Error, sigwait: Unexpected signal %d (%d : %d)\n", sig, info.si_code, info.si_value.sival_int);
375
[169d944]376                // __cfaabi_dbg_print_safe( "Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int );
[969b3fe]377                // Switch on the code (a.k.a. the sender) to
[8cb529e]378                switch( info.si_code )
[a0b3e32]379                {
[969b3fe]380                // Timers can apparently be marked as sent for the kernel
381                // In either case, tick preemption
[8cb529e]382                case SI_TIMER:
383                case SI_KERNEL:
[169d944]384                        // __cfaabi_dbg_print_safe( "Kernel : Preemption thread tick\n" );
[36982fc]385                        lock( event_kernel->lock __cfaabi_dbg_ctx2 );
[8cb529e]386                        tick_preemption();
[ea7d2b0]387                        unlock( event_kernel->lock );
[8cb529e]388                        break;
[969b3fe]389                // Signal was not sent by the kernel but by an other thread
[8cb529e]390                case SI_QUEUE:
[969b3fe]391                        // For now, other thread only signal the alarm thread to shut it down
392                        // If this needs to change use info.si_value and handle the case here
[8cb529e]393                        goto EXIT;
[cd17862]394                }
395        }
[a0b3e32]396
[8cb529e]397EXIT:
[169d944]398        __cfaabi_dbg_print_safe( "Kernel : Preemption thread stopping\n" );
[a0b3e32]399        return NULL;
[82ff5845]400}
401
[6b0b624]402// Local Variables: //
403// mode: c //
404// tab-width: 4 //
405// End: //
Note: See TracBrowser for help on using the repository browser.