source: src/libcfa/concurrency/kernel.c @ 9d944b2

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

Implemented interposing for abort and exit, implemented safer debug output

  • Property mode set to 100644
File size: 14.7 KB
Line 
1//                              -*- Mode: CFA -*-
2//
3// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
4//
5// The contents of this file are covered under the licence agreement in the
6// file "LICENCE" distributed with Cforall.
7//
8// kernel.c --
9//
10// Author           : Thierry Delisle
11// Created On       : Tue Jan 17 12:27:26 2017
12// Last Modified By : Thierry Delisle
13// Last Modified On : --
14// Update Count     : 0
15//
16
17#include "startup.h"
18
19//Start and stop routine for the kernel, declared first to make sure they run first
20void kernel_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_KERNEL ) ));
21void kernel_shutdown(void) __attribute__(( destructor ( STARTUP_PRIORITY_KERNEL ) ));
22
23//Header
24#include "kernel_private.h"
25
26//C Includes
27#include <stddef.h>
28extern "C" {
29#include <stdio.h>
30#include <fenv.h>
31#include <sys/resource.h>
32#include <signal.h>
33#include <unistd.h>
34}
35
36//CFA Includes
37#include "libhdr.h"
38
39//Private includes
40#define __CFA_INVOKE_PRIVATE__
41#include "invoke.h"
42
43//-----------------------------------------------------------------------------
44// Kernel storage
45#define KERNEL_STORAGE(T,X) static char X##_storage[sizeof(T)]
46
47KERNEL_STORAGE(processorCtx_t, systemProcessorCtx);
48KERNEL_STORAGE(cluster, systemCluster);
49KERNEL_STORAGE(processor, systemProcessor);
50KERNEL_STORAGE(thread_desc, mainThread);
51KERNEL_STORAGE(machine_context_t, mainThread_context);
52
53cluster * systemCluster;
54processor * systemProcessor;
55thread_desc * mainThread;
56
57//-----------------------------------------------------------------------------
58// Global state
59
60thread_local processor * this_processor;
61
62coroutine_desc * this_coroutine(void) {
63        return this_processor->current_coroutine;
64}
65
66thread_desc * this_thread(void) {
67        return this_processor->current_thread;
68}
69
70//-----------------------------------------------------------------------------
71// Main thread construction
72struct current_stack_info_t {
73        machine_context_t ctx; 
74        unsigned int size;              // size of stack
75        void *base;                             // base of stack
76        void *storage;                  // pointer to stack
77        void *limit;                    // stack grows towards stack limit
78        void *context;                  // address of cfa_context_t
79        void *top;                              // address of top of storage
80};
81
82void ?{}( current_stack_info_t * this ) {
83        CtxGet( &this->ctx );
84        this->base = this->ctx.FP;
85        this->storage = this->ctx.SP;
86
87        rlimit r;
88        getrlimit( RLIMIT_STACK, &r);
89        this->size = r.rlim_cur;
90
91        this->limit = (void *)(((intptr_t)this->base) - this->size);
92        this->context = &mainThread_context_storage;
93        this->top = this->base;
94}
95
96void ?{}( coStack_t * this, current_stack_info_t * info) {
97        this->size = info->size;
98        this->storage = info->storage;
99        this->limit = info->limit;
100        this->base = info->base;
101        this->context = info->context;
102        this->top = info->top;
103        this->userStack = true;
104}
105
106void ?{}( coroutine_desc * this, current_stack_info_t * info) {
107        (&this->stack){ info }; 
108        this->name = "Main Thread";
109        this->errno_ = 0;
110        this->state = Start;
111}
112
113void ?{}( thread_desc * this, current_stack_info_t * info) {
114        (&this->cor){ info };
115}
116
117//-----------------------------------------------------------------------------
118// Processor coroutine
119void ?{}(processorCtx_t * this, processor * proc) {
120        (&this->__cor){};
121        this->proc = proc;
122        proc->runner = this;
123}
124
125void ?{}(processorCtx_t * this, processor * proc, current_stack_info_t * info) {
126        (&this->__cor){ info };
127        this->proc = proc;
128        proc->runner = this;
129}
130
131void ?{}(processor * this) {
132        this{ systemCluster };
133}
134
135void ?{}(processor * this, cluster * cltr) {
136        this->cltr = cltr;
137        this->current_coroutine = NULL;
138        this->current_thread = NULL;
139        (&this->terminated){};
140        this->is_terminated = false;
141
142        start( this );
143}
144
145void ?{}(processor * this, cluster * cltr, processorCtx_t * runner) {
146        this->cltr = cltr;
147        this->current_coroutine = NULL;
148        this->current_thread = NULL;
149        (&this->terminated){};
150        this->is_terminated = false;
151
152        this->runner = runner;
153        LIB_DEBUG_PRINT_SAFE("Kernel : constructing processor context %p\n", runner);
154        runner{ this };
155}
156
157void ^?{}(processor * this) {
158        if( ! this->is_terminated ) {
159                LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", this);
160                this->is_terminated = true;
161                wait( &this->terminated );
162        }
163}
164
165void ?{}(cluster * this) {
166        ( &this->ready_queue ){};
167        ( &this->lock ){};
168}
169
170void ^?{}(cluster * this) {
171       
172}
173
174//=============================================================================================
175// Kernel Scheduling logic
176//=============================================================================================
177//Main of the processor contexts
178void main(processorCtx_t * runner) {
179        processor * this = runner->proc;
180        LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this);
181
182        thread_desc * readyThread = NULL;
183        for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ ) 
184        {
185                readyThread = nextThread( this->cltr );
186
187                if(readyThread) 
188                {
189                        runThread(this, readyThread);
190
191                        //Some actions need to be taken from the kernel
192                        finishRunning(this);
193
194                        spin_count = 0;
195                } 
196                else 
197                {
198                        spin(this, &spin_count);
199                }               
200        }
201
202        LIB_DEBUG_PRINT_SAFE("Kernel : core %p unlocking thread\n", this);
203        signal( &this->terminated );
204        LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this);
205}
206
207// runThread runs a thread by context switching
208// from the processor coroutine to the target thread
209void runThread(processor * this, thread_desc * dst) {
210        coroutine_desc * proc_cor = get_coroutine(this->runner);
211        coroutine_desc * thrd_cor = get_coroutine(dst);
212       
213        //Reset the terminating actions here
214        this->finish.action_code = No_Action;
215
216        //Update global state
217        this->current_thread = dst;
218
219        // Context Switch to the thread
220        ThreadCtxSwitch(proc_cor, thrd_cor);
221        // when ThreadCtxSwitch returns we are back in the processor coroutine
222}
223
224// Once a thread has finished running, some of
225// its final actions must be executed from the kernel
226void finishRunning(processor * this) {
227        if( this->finish.action_code == Release ) {
228                unlock( this->finish.lock );
229        }
230        else if( this->finish.action_code == Schedule ) {
231                ScheduleThread( this->finish.thrd );
232        }
233        else if( this->finish.action_code == Release_Schedule ) {
234                unlock( this->finish.lock );           
235                ScheduleThread( this->finish.thrd );
236        }
237        else {
238                assert(this->finish.action_code == No_Action);
239        }
240}
241
242// Handles spinning logic
243// TODO : find some strategy to put cores to sleep after some time
244void spin(processor * this, unsigned int * spin_count) {
245        (*spin_count)++;
246}
247
248// Context invoker for processors
249// This is the entry point for processors (kernel threads)
250// It effectively constructs a coroutine by stealing the pthread stack
251void * CtxInvokeProcessor(void * arg) {
252        processor * proc = (processor *) arg;
253        this_processor = proc;
254        // SKULLDUGGERY: We want to create a context for the processor coroutine
255        // which is needed for the 2-step context switch. However, there is no reason
256        // to waste the perfectly valid stack create by pthread.
257        current_stack_info_t info;
258        machine_context_t ctx;
259        info.context = &ctx;
260        processorCtx_t proc_cor_storage = { proc, &info };
261
262        LIB_DEBUG_PRINT_SAFE("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
263
264        //Set global state
265        proc->current_coroutine = &proc->runner->__cor;
266        proc->current_thread = NULL;
267
268        //We now have a proper context from which to schedule threads
269        LIB_DEBUG_PRINT_SAFE("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx);
270
271        // SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't
272        // resume it to start it like it normally would, it will just context switch
273        // back to here. Instead directly call the main since we already are on the
274        // appropriate stack.
275        proc_cor_storage.__cor.state = Active;
276      main( &proc_cor_storage );
277      proc_cor_storage.__cor.state = Halted;
278
279        // Main routine of the core returned, the core is now fully terminated
280        LIB_DEBUG_PRINT_SAFE("Kernel : core %p main ended (%p)\n", proc, proc->runner); 
281
282        return NULL;
283}
284
285void start(processor * this) {
286        LIB_DEBUG_PRINT_SAFE("Kernel : Starting core %p\n", this);
287       
288        // pthread_attr_t attributes;
289        // pthread_attr_init( &attributes );
290
291        pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
292
293        // pthread_attr_destroy( &attributes );
294
295        LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);       
296}
297
298//-----------------------------------------------------------------------------
299// Scheduler routines
300void ScheduleThread( thread_desc * thrd ) {
301        assertf( thrd->next == NULL, "Expected null got %p", thrd->next );
302       
303        lock( &systemProcessor->cltr->lock );
304        append( &systemProcessor->cltr->ready_queue, thrd );
305        unlock( &systemProcessor->cltr->lock );
306}
307
308thread_desc * nextThread(cluster * this) {
309        lock( &this->lock );
310        thread_desc * head = pop_head( &this->ready_queue );
311        unlock( &this->lock );
312        return head;
313}
314
315void ScheduleInternal() {
316        suspend();
317}
318
319void ScheduleInternal( spinlock * lock ) {
320        this_processor->finish.action_code = Release;
321        this_processor->finish.lock = lock;
322        suspend();
323}
324
325void ScheduleInternal( thread_desc * thrd ) {
326        this_processor->finish.action_code = Schedule;
327        this_processor->finish.thrd = thrd;
328        suspend();
329}
330
331void ScheduleInternal( spinlock * lock, thread_desc * thrd ) {
332        this_processor->finish.action_code = Release_Schedule;
333        this_processor->finish.lock = lock;
334        this_processor->finish.thrd = thrd;
335        suspend();
336}
337
338//-----------------------------------------------------------------------------
339// Kernel boot procedures
340void kernel_startup(void) {
341        LIB_DEBUG_PRINT_SAFE("Kernel : Starting\n");   
342
343        // Start by initializing the main thread
344        // SKULLDUGGERY: the mainThread steals the process main thread
345        // which will then be scheduled by the systemProcessor normally
346        mainThread = (thread_desc *)&mainThread_storage;
347        current_stack_info_t info;
348        mainThread{ &info };
349
350        // Initialize the system cluster
351        systemCluster = (cluster *)&systemCluster_storage;
352        systemCluster{};
353
354        // Initialize the system processor and the system processor ctx
355        // (the coroutine that contains the processing control flow)
356        systemProcessor = (processor *)&systemProcessor_storage;
357        systemProcessor{ systemCluster, (processorCtx_t *)&systemProcessorCtx_storage };
358
359        // Add the main thread to the ready queue
360        // once resume is called on systemProcessor->ctx the mainThread needs to be scheduled like any normal thread
361        ScheduleThread(mainThread);
362
363        //initialize the global state variables
364        this_processor = systemProcessor;
365        this_processor->current_thread = mainThread;
366        this_processor->current_coroutine = &mainThread->cor;
367
368        // SKULLDUGGERY: Force a context switch to the system processor to set the main thread's context to the current UNIX
369        // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
370        // mainThread is on the ready queue when this call is made.
371        resume(systemProcessor->runner);
372
373
374
375        // THE SYSTEM IS NOW COMPLETELY RUNNING
376        LIB_DEBUG_PRINT_SAFE("Kernel : Started\n--------------------------------------------------\n\n");
377}
378
379void kernel_shutdown(void) {
380        LIB_DEBUG_PRINT_SAFE("\n--------------------------------------------------\nKernel : Shutting down\n");
381
382        // SKULLDUGGERY: Notify the systemProcessor it needs to terminates.
383        // When its coroutine terminates, it return control to the mainThread
384        // which is currently here
385        systemProcessor->is_terminated = true;
386        suspend();
387
388        // THE SYSTEM IS NOW COMPLETELY STOPPED
389
390        // Destroy the system processor and its context in reverse order of construction
391        // These were manually constructed so we need manually destroy them
392        ^(systemProcessor->runner){};
393        ^(systemProcessor){};
394
395        // Final step, destroy the main thread since it is no longer needed
396        // Since we provided a stack to this taxk it will not destroy anything
397        ^(mainThread){};
398
399        LIB_DEBUG_PRINT_SAFE("Kernel : Shutdown complete\n");   
400}
401
402static spinlock kernel_abort_lock;
403static spinlock kernel_debug_lock;
404static bool kernel_abort_called = false;
405
406void * kernel_abort    (void) __attribute__ ((__nothrow__)) {
407        // abort cannot be recursively entered by the same or different processors because all signal handlers return when
408        // the globalAbort flag is true.
409        lock( &kernel_abort_lock );
410
411        // first task to abort ?
412        if ( !kernel_abort_called ) {                   // not first task to abort ?
413                kernel_abort_called = true;
414                unlock( &kernel_abort_lock );
415        } 
416        else {
417                unlock( &kernel_abort_lock );
418               
419                sigset_t mask;
420                sigemptyset( &mask );
421                sigaddset( &mask, SIGALRM );                    // block SIGALRM signals
422                sigaddset( &mask, SIGUSR1 );                    // block SIGUSR1 signals
423                sigsuspend( &mask );                            // block the processor to prevent further damage during abort
424                _exit( EXIT_FAILURE );                          // if processor unblocks before it is killed, terminate it             
425        }
426
427        return this_thread();
428}
429
430void kernel_abort_msg( void * kernel_data, char * abort_text, int abort_text_size ) {
431        thread_desc * thrd = kernel_data;
432
433        int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->cor.name, thrd );
434        __lib_debug_write( STDERR_FILENO, abort_text, len );
435
436        if ( thrd != this_coroutine() ) {
437                len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", this_coroutine()->name, this_coroutine() );
438                __lib_debug_write( STDERR_FILENO, abort_text, len );
439        } 
440        else {
441                __lib_debug_write( STDERR_FILENO, ".\n", 2 );
442        }
443}
444
445extern "C" {
446        void __lib_debug_acquire() {
447                lock(&kernel_debug_lock);
448        }
449
450        void __lib_debug_release() {
451                unlock(&kernel_debug_lock);
452        }
453}
454
455//-----------------------------------------------------------------------------
456// Locks
457void ?{}( spinlock * this ) {
458        this->lock = 0;
459}
460void ^?{}( spinlock * this ) {
461
462}
463
464void lock( spinlock * this ) {
465        for ( unsigned int i = 1;; i += 1 ) {
466                if ( this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0 ) break;
467        }
468}
469
470void unlock( spinlock * this ) {
471        __sync_lock_release_4( &this->lock );
472}
473
474void ?{}( signal_once * this ) {
475        this->condition = false;
476}
477void ^?{}( signal_once * this ) {
478
479}
480
481void wait( signal_once * this ) {
482        lock( &this->lock );
483        if( !this->condition ) {
484                append( &this->blocked, this_thread() );
485                ScheduleInternal( &this->lock );
486                lock( &this->lock );
487        }
488        unlock( &this->lock );
489}
490
491void signal( signal_once * this ) {
492        lock( &this->lock );
493        {
494                this->condition = true;
495
496                thread_desc * it;
497                while( it = pop_head( &this->blocked) ) {
498                        ScheduleThread( it );
499                }
500        }
501        unlock( &this->lock );
502}
503
504//-----------------------------------------------------------------------------
505// Queues
506void ?{}( simple_thread_list * this ) {
507        this->head = NULL;
508        this->tail = &this->head;
509}
510
511void append( simple_thread_list * this, thread_desc * t ) {
512        assert(this->tail != NULL);
513        *this->tail = t;
514        this->tail = &t->next;
515}
516
517thread_desc * pop_head( simple_thread_list * this ) {
518        thread_desc * head = this->head;
519        if( head ) {
520                this->head = head->next;
521                if( !head->next ) {
522                        this->tail = &this->head;
523                }
524                head->next = NULL;
525        }       
526        return head;
527}
528// Local Variables: //
529// mode: c //
530// tab-width: 4 //
531// End: //
Note: See TracBrowser for help on using the repository browser.