source: src/libcfa/concurrency/preemption.c @ b68fc85

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerwith_gc
Last change on this file since b68fc85 was b68fc85, checked in by Thierry Delisle <tdelisle@…>, 4 years ago

Added more checks to preempt test to make sure preemption stays enabled

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