source: src/libcfa/concurrency/kernel.c @ c40e7c5

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

Finished adding with statements to kernel

  • Property mode set to 100644
File size: 19.1 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// kernel.c --
8//
9// Author           : Thierry Delisle
10// Created On       : Tue Jan 17 12:27:26 2017
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Tue Feb  6 21:51:26 2018
13// Update Count     : 4
14//
15
16//C Includes
17#include <stddef.h>
18#define ftype `ftype`
19extern "C" {
20#include <stdio.h>
21#include <fenv.h>
22#include <sys/resource.h>
23#include <signal.h>
24#include <unistd.h>
25}
26#undef ftype
27
28//CFA Includes
29#include "kernel_private.h"
30#include "preemption.h"
31#include "startup.h"
32
33//Private includes
34#define __CFA_INVOKE_PRIVATE__
35#include "invoke.h"
36
37//Start and stop routine for the kernel, declared first to make sure they run first
38void kernel_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_KERNEL ) ));
39void kernel_shutdown(void) __attribute__(( destructor ( STARTUP_PRIORITY_KERNEL ) ));
40
41//-----------------------------------------------------------------------------
42// Kernel storage
43KERNEL_STORAGE(cluster,           mainCluster);
44KERNEL_STORAGE(processor,         mainProcessor);
45KERNEL_STORAGE(processorCtx_t,    mainProcessorCtx);
46KERNEL_STORAGE(thread_desc,       mainThread);
47KERNEL_STORAGE(machine_context_t, mainThreadCtx);
48
49cluster *     mainCluster;
50processor *   mainProcessor;
51thread_desc * mainThread;
52
53//-----------------------------------------------------------------------------
54// Global state
55
56thread_local coroutine_desc * volatile this_coroutine;
57thread_local thread_desc *    volatile this_thread;
58thread_local processor *      volatile this_processor;
59
60volatile thread_local bool preemption_in_progress = 0;
61volatile thread_local bool preemption_enabled = false;
62volatile thread_local unsigned short disable_preempt_count = 1;
63
64//-----------------------------------------------------------------------------
65// Main thread construction
66struct current_stack_info_t {
67        machine_context_t ctx;
68        unsigned int size;              // size of stack
69        void *base;                             // base of stack
70        void *storage;                  // pointer to stack
71        void *limit;                    // stack grows towards stack limit
72        void *context;                  // address of cfa_context_t
73        void *top;                              // address of top of storage
74};
75
76void ?{}( current_stack_info_t & this ) {
77        CtxGet( this.ctx );
78        this.base = this.ctx.FP;
79        this.storage = this.ctx.SP;
80
81        rlimit r;
82        getrlimit( RLIMIT_STACK, &r);
83        this.size = r.rlim_cur;
84
85        this.limit = (void *)(((intptr_t)this.base) - this.size);
86        this.context = &storage_mainThreadCtx;
87        this.top = this.base;
88}
89
90void ?{}( coStack_t & this, current_stack_info_t * info) with( this ) {
91        size      = info->size;
92        storage   = info->storage;
93        limit     = info->limit;
94        base      = info->base;
95        context   = info->context;
96        top       = info->top;
97        userStack = true;
98}
99
100void ?{}( coroutine_desc & this, current_stack_info_t * info) with( this ) {
101        stack{ info };
102        name = "Main Thread";
103        errno_ = 0;
104        state = Start;
105        starter = NULL;
106}
107
108void ?{}( thread_desc & this, current_stack_info_t * info) with( this ) {
109        self_cor{ info };
110        curr_cor = &self_cor;
111        self_mon.owner = &this;
112        self_mon.recursion = 1;
113        self_mon_p = &self_mon;
114        next = NULL;
115        __cfaabi_dbg_debug_do(
116                dbg_next = NULL;
117                dbg_prev = NULL;
118                __cfaabi_dbg_thread_register(&this);
119        )
120
121        monitors{ &self_mon_p, 1, (fptr_t)0 };
122}
123
124//-----------------------------------------------------------------------------
125// Processor coroutine
126
127// Construct the processor context of the main processor
128void ?{}(processorCtx_t & this, processor * proc) {
129        (this.__cor){ "Processor" };
130        this.__cor.starter = NULL;
131        this.proc = proc;
132        proc->runner = &this;
133}
134
135// Construct the processor context of non-main processors
136void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info) {
137        (this.__cor){ info };
138        this.proc = proc;
139        proc->runner = &this;
140}
141
142void ?{}(processor & this) {
143        this{ mainCluster };
144}
145
146void ?{}(processor & this, cluster * cltr) with( this ) {
147        this.cltr = cltr;
148        terminated{ 0 };
149        do_terminate = false;
150        preemption_alarm = NULL;
151        pending_preemption = false;
152
153        start( &this );
154}
155
156void ?{}(processor & this, cluster * cltr, processorCtx_t & runner) with( this ) {
157        this.cltr = cltr;
158        terminated{ 0 };
159        do_terminate = false;
160        preemption_alarm = NULL;
161        pending_preemption = false;
162        kernel_thread = pthread_self();
163
164        this.runner = &runner;
165        __cfaabi_dbg_print_safe("Kernel : constructing main processor context %p\n", &runner);
166        runner{ &this };
167}
168
169void ^?{}(processor & this) with( this ){
170        if( ! do_terminate ) {
171                __cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
172                terminate(&this);
173                P( terminated );
174                pthread_join( kernel_thread, NULL );
175        }
176}
177
178void ?{}(cluster & this) with( this ) {
179        ready_queue{};
180        ready_queue_lock{};
181
182        preemption = default_preemption();
183}
184
185void ^?{}(cluster & this) {
186
187}
188
189//=============================================================================================
190// Kernel Scheduling logic
191//=============================================================================================
192//Main of the processor contexts
193void main(processorCtx_t & runner) {
194        processor * this = runner.proc;
195
196        __cfaabi_dbg_print_safe("Kernel : core %p starting\n", this);
197
198        {
199                // Setup preemption data
200                preemption_scope scope = { this };
201
202                __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
203
204                thread_desc * readyThread = NULL;
205                for( unsigned int spin_count = 0; ! this->do_terminate; spin_count++ )
206                {
207                        readyThread = nextThread( this->cltr );
208
209                        if(readyThread)
210                        {
211                                verify( !preemption_enabled );
212
213                                runThread(this, readyThread);
214
215                                verify( !preemption_enabled );
216
217                                //Some actions need to be taken from the kernel
218                                finishRunning(this);
219
220                                spin_count = 0;
221                        }
222                        else
223                        {
224                                spin(this, &spin_count);
225                        }
226                }
227
228                __cfaabi_dbg_print_safe("Kernel : core %p stopping\n", this);
229        }
230
231        V( this->terminated );
232
233        __cfaabi_dbg_print_safe("Kernel : core %p terminated\n", this);
234}
235
236// runThread runs a thread by context switching
237// from the processor coroutine to the target thread
238void runThread(processor * this, thread_desc * dst) {
239        assert(dst->curr_cor);
240        coroutine_desc * proc_cor = get_coroutine(*this->runner);
241        coroutine_desc * thrd_cor = dst->curr_cor;
242
243        //Reset the terminating actions here
244        this->finish.action_code = No_Action;
245
246        //Update global state
247        this_thread = dst;
248
249        // Context Switch to the thread
250        ThreadCtxSwitch(proc_cor, thrd_cor);
251        // when ThreadCtxSwitch returns we are back in the processor coroutine
252}
253
254void returnToKernel() {
255        coroutine_desc * proc_cor = get_coroutine(*this_processor->runner);
256        coroutine_desc * thrd_cor = this_thread->curr_cor = this_coroutine;
257        ThreadCtxSwitch(thrd_cor, proc_cor);
258}
259
260// Once a thread has finished running, some of
261// its final actions must be executed from the kernel
262void finishRunning(processor * this) with( this->finish ) {
263        if( action_code == Release ) {
264                verify( !preemption_enabled );
265                unlock( *lock );
266        }
267        else if( action_code == Schedule ) {
268                ScheduleThread( thrd );
269        }
270        else if( action_code == Release_Schedule ) {
271                verify( !preemption_enabled );
272                unlock( *lock );
273                ScheduleThread( thrd );
274        }
275        else if( action_code == Release_Multi ) {
276                verify( !preemption_enabled );
277                for(int i = 0; i < lock_count; i++) {
278                        unlock( *locks[i] );
279                }
280        }
281        else if( action_code == Release_Multi_Schedule ) {
282                for(int i = 0; i < lock_count; i++) {
283                        unlock( *locks[i] );
284                }
285                for(int i = 0; i < thrd_count; i++) {
286                        ScheduleThread( thrds[i] );
287                }
288        }
289        else {
290                assert(action_code == No_Action);
291        }
292}
293
294// Handles spinning logic
295// TODO : find some strategy to put cores to sleep after some time
296void spin(processor * this, unsigned int * spin_count) {
297        (*spin_count)++;
298}
299
300// Context invoker for processors
301// This is the entry point for processors (kernel threads)
302// It effectively constructs a coroutine by stealing the pthread stack
303void * CtxInvokeProcessor(void * arg) {
304        processor * proc = (processor *) arg;
305        this_processor = proc;
306        this_coroutine = NULL;
307        this_thread = NULL;
308        preemption_enabled = false;
309        disable_preempt_count = 1;
310        // SKULLDUGGERY: We want to create a context for the processor coroutine
311        // which is needed for the 2-step context switch. However, there is no reason
312        // to waste the perfectly valid stack create by pthread.
313        current_stack_info_t info;
314        machine_context_t ctx;
315        info.context = &ctx;
316        processorCtx_t proc_cor_storage = { proc, &info };
317
318        __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
319
320        //Set global state
321        this_coroutine = &proc->runner->__cor;
322        this_thread = NULL;
323
324        //We now have a proper context from which to schedule threads
325        __cfaabi_dbg_print_safe("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx);
326
327        // SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't
328        // resume it to start it like it normally would, it will just context switch
329        // back to here. Instead directly call the main since we already are on the
330        // appropriate stack.
331        proc_cor_storage.__cor.state = Active;
332        main( proc_cor_storage );
333        proc_cor_storage.__cor.state = Halted;
334
335        // Main routine of the core returned, the core is now fully terminated
336        __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, proc->runner);
337
338        return NULL;
339}
340
341void start(processor * this) {
342        __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", this);
343
344        pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
345
346        __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
347}
348
349//-----------------------------------------------------------------------------
350// Scheduler routines
351void ScheduleThread( thread_desc * thrd ) {
352        // if( !thrd ) return;
353        verify( thrd );
354        verify( thrd->self_cor.state != Halted );
355
356        verify( !preemption_enabled );
357
358        verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
359
360        with( *this_processor->cltr ) {
361                lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
362                append( ready_queue, thrd );
363                unlock( ready_queue_lock );
364        }
365
366        verify( !preemption_enabled );
367}
368
369thread_desc * nextThread(cluster * this) with( *this ) {
370        verify( !preemption_enabled );
371        lock( ready_queue_lock __cfaabi_dbg_ctx2 );
372        thread_desc * head = pop_head( ready_queue );
373        unlock( ready_queue_lock );
374        verify( !preemption_enabled );
375        return head;
376}
377
378void BlockInternal() {
379        disable_interrupts();
380        verify( !preemption_enabled );
381        returnToKernel();
382        verify( !preemption_enabled );
383        enable_interrupts( __cfaabi_dbg_ctx );
384}
385
386void BlockInternal( __spinlock_t * lock ) {
387        disable_interrupts();
388        this_processor->finish.action_code = Release;
389        this_processor->finish.lock        = lock;
390
391        verify( !preemption_enabled );
392        returnToKernel();
393        verify( !preemption_enabled );
394
395        enable_interrupts( __cfaabi_dbg_ctx );
396}
397
398void BlockInternal( thread_desc * thrd ) {
399        disable_interrupts();
400        this_processor->finish.action_code = Schedule;
401        this_processor->finish.thrd        = thrd;
402
403        verify( !preemption_enabled );
404        returnToKernel();
405        verify( !preemption_enabled );
406
407        enable_interrupts( __cfaabi_dbg_ctx );
408}
409
410void BlockInternal( __spinlock_t * lock, thread_desc * thrd ) {
411        assert(thrd);
412        disable_interrupts();
413        this_processor->finish.action_code = Release_Schedule;
414        this_processor->finish.lock        = lock;
415        this_processor->finish.thrd        = thrd;
416
417        verify( !preemption_enabled );
418        returnToKernel();
419        verify( !preemption_enabled );
420
421        enable_interrupts( __cfaabi_dbg_ctx );
422}
423
424void BlockInternal(__spinlock_t * locks [], unsigned short count) {
425        disable_interrupts();
426        this_processor->finish.action_code = Release_Multi;
427        this_processor->finish.locks       = locks;
428        this_processor->finish.lock_count  = count;
429
430        verify( !preemption_enabled );
431        returnToKernel();
432        verify( !preemption_enabled );
433
434        enable_interrupts( __cfaabi_dbg_ctx );
435}
436
437void BlockInternal(__spinlock_t * locks [], unsigned short lock_count, thread_desc * thrds [], unsigned short thrd_count) {
438        disable_interrupts();
439        this_processor->finish.action_code = Release_Multi_Schedule;
440        this_processor->finish.locks       = locks;
441        this_processor->finish.lock_count  = lock_count;
442        this_processor->finish.thrds       = thrds;
443        this_processor->finish.thrd_count  = thrd_count;
444
445        verify( !preemption_enabled );
446        returnToKernel();
447        verify( !preemption_enabled );
448
449        enable_interrupts( __cfaabi_dbg_ctx );
450}
451
452void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
453        verify( !preemption_enabled );
454        this_processor->finish.action_code = thrd ? Release_Schedule : Release;
455        this_processor->finish.lock        = lock;
456        this_processor->finish.thrd        = thrd;
457
458        returnToKernel();
459}
460
461//=============================================================================================
462// Kernel Setup logic
463//=============================================================================================
464//-----------------------------------------------------------------------------
465// Kernel boot procedures
466void kernel_startup(void) {
467        __cfaabi_dbg_print_safe("Kernel : Starting\n");
468
469        // Start by initializing the main thread
470        // SKULLDUGGERY: the mainThread steals the process main thread
471        // which will then be scheduled by the mainProcessor normally
472        mainThread = (thread_desc *)&storage_mainThread;
473        current_stack_info_t info;
474        (*mainThread){ &info };
475
476        __cfaabi_dbg_print_safe("Kernel : Main thread ready\n");
477
478        // Initialize the main cluster
479        mainCluster = (cluster *)&storage_mainCluster;
480        (*mainCluster){};
481
482        __cfaabi_dbg_print_safe("Kernel : main cluster ready\n");
483
484        // Initialize the main processor and the main processor ctx
485        // (the coroutine that contains the processing control flow)
486        mainProcessor = (processor *)&storage_mainProcessor;
487        (*mainProcessor){ mainCluster, *(processorCtx_t *)&storage_mainProcessorCtx };
488
489        //initialize the global state variables
490        this_processor = mainProcessor;
491        this_thread = mainThread;
492        this_coroutine = &mainThread->self_cor;
493
494        // Enable preemption
495        kernel_start_preemption();
496
497        // Add the main thread to the ready queue
498        // once resume is called on mainProcessor->runner the mainThread needs to be scheduled like any normal thread
499        ScheduleThread(mainThread);
500
501        // SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
502        // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
503        // mainThread is on the ready queue when this call is made.
504        resume( *mainProcessor->runner );
505
506
507
508        // THE SYSTEM IS NOW COMPLETELY RUNNING
509        __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n");
510
511        enable_interrupts( __cfaabi_dbg_ctx );
512}
513
514void kernel_shutdown(void) {
515        __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
516
517        disable_interrupts();
518
519        // SKULLDUGGERY: Notify the mainProcessor it needs to terminates.
520        // When its coroutine terminates, it return control to the mainThread
521        // which is currently here
522        mainProcessor->do_terminate = true;
523        returnToKernel();
524
525        // THE SYSTEM IS NOW COMPLETELY STOPPED
526
527        // Disable preemption
528        kernel_stop_preemption();
529
530        // Destroy the main processor and its context in reverse order of construction
531        // These were manually constructed so we need manually destroy them
532        ^(*mainProcessor->runner){};
533        ^(mainProcessor){};
534
535        // Final step, destroy the main thread since it is no longer needed
536        // Since we provided a stack to this taxk it will not destroy anything
537        ^(mainThread){};
538
539        __cfaabi_dbg_print_safe("Kernel : Shutdown complete\n");
540}
541
542//=============================================================================================
543// Unexpected Terminating logic
544//=============================================================================================
545
546
547static __spinlock_t kernel_abort_lock;
548static __spinlock_t kernel_debug_lock;
549static bool kernel_abort_called = false;
550
551void * kernel_abort    (void) __attribute__ ((__nothrow__)) {
552        // abort cannot be recursively entered by the same or different processors because all signal handlers return when
553        // the globalAbort flag is true.
554        lock( kernel_abort_lock __cfaabi_dbg_ctx2 );
555
556        // first task to abort ?
557        if ( !kernel_abort_called ) {                   // not first task to abort ?
558                kernel_abort_called = true;
559                unlock( kernel_abort_lock );
560        }
561        else {
562                unlock( kernel_abort_lock );
563
564                sigset_t mask;
565                sigemptyset( &mask );
566                sigaddset( &mask, SIGALRM );                    // block SIGALRM signals
567                sigaddset( &mask, SIGUSR1 );                    // block SIGUSR1 signals
568                sigsuspend( &mask );                            // block the processor to prevent further damage during abort
569                _exit( EXIT_FAILURE );                          // if processor unblocks before it is killed, terminate it
570        }
571
572        return this_thread;
573}
574
575void kernel_abort_msg( void * kernel_data, char * abort_text, int abort_text_size ) {
576        thread_desc * thrd = kernel_data;
577
578        int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->self_cor.name, thrd );
579        __cfaabi_dbg_bits_write( abort_text, len );
580
581        if ( thrd != this_coroutine ) {
582                len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", this_coroutine->name, this_coroutine );
583                __cfaabi_dbg_bits_write( abort_text, len );
584        }
585        else {
586                __cfaabi_dbg_bits_write( ".\n", 2 );
587        }
588}
589
590int kernel_abort_lastframe( void ) __attribute__ ((__nothrow__)) {
591        return get_coroutine(this_thread) == get_coroutine(mainThread) ? 4 : 2;
592}
593
594extern "C" {
595        void __cfaabi_dbg_bits_acquire() {
596                lock( kernel_debug_lock __cfaabi_dbg_ctx2 );
597        }
598
599        void __cfaabi_dbg_bits_release() {
600                unlock( kernel_debug_lock );
601        }
602}
603
604//=============================================================================================
605// Kernel Utilities
606//=============================================================================================
607//-----------------------------------------------------------------------------
608// Locks
609void  ?{}( semaphore & this, int count = 1 ) {
610        (this.lock){};
611        this.count = count;
612        (this.waiting){};
613}
614void ^?{}(semaphore & this) {}
615
616void P(semaphore & this) with( this ){
617        lock( lock __cfaabi_dbg_ctx2 );
618        count -= 1;
619        if ( count < 0 ) {
620                // queue current task
621                append( waiting, (thread_desc *)this_thread );
622
623                // atomically release spin lock and block
624                BlockInternal( &lock );
625        }
626        else {
627            unlock( lock );
628        }
629}
630
631void V(semaphore & this) with( this ) {
632        thread_desc * thrd = NULL;
633        lock( lock __cfaabi_dbg_ctx2 );
634        count += 1;
635        if ( count <= 0 ) {
636                // remove task at head of waiting list
637                thrd = pop_head( waiting );
638        }
639
640        unlock( lock );
641
642        // make new owner
643        WakeThread( thrd );
644}
645
646//-----------------------------------------------------------------------------
647// Debug
648__cfaabi_dbg_debug_do(
649        struct {
650                thread_desc * tail;
651        } __cfaabi_dbg_thread_list = { NULL };
652
653        void __cfaabi_dbg_thread_register( thread_desc * thrd ) {
654                if( !__cfaabi_dbg_thread_list.tail ) {
655                        __cfaabi_dbg_thread_list.tail = thrd;
656                        return;
657                }
658                __cfaabi_dbg_thread_list.tail->dbg_next = thrd;
659                thrd->dbg_prev = __cfaabi_dbg_thread_list.tail;
660                __cfaabi_dbg_thread_list.tail = thrd;
661        }
662
663        void __cfaabi_dbg_thread_unregister( thread_desc * thrd ) {
664                thread_desc * prev = thrd->dbg_prev;
665                thread_desc * next = thrd->dbg_next;
666
667                if( next ) { next->dbg_prev = prev; }
668                else       {
669                        assert( __cfaabi_dbg_thread_list.tail == thrd );
670                        __cfaabi_dbg_thread_list.tail = prev;
671                }
672
673                if( prev ) { prev->dbg_next = next; }
674
675                thrd->dbg_prev = NULL;
676                thrd->dbg_next = NULL;
677        }
678)
679// Local Variables: //
680// mode: c //
681// tab-width: 4 //
682// End: //
Note: See TracBrowser for help on using the repository browser.