Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/libcfa/concurrency/kernel.c

    r135b431 r39fea2f  
    7373};
    7474
    75 void ?{}( current_stack_info_t * this ) {
    76         CtxGet( this->ctx );
    77         this->base = this->ctx.FP;
    78         this->storage = this->ctx.SP;
     75void ?{}( current_stack_info_t & this ) {
     76        CtxGet( this.ctx );
     77        this.base = this.ctx.FP;
     78        this.storage = this.ctx.SP;
    7979
    8080        rlimit r;
    8181        getrlimit( RLIMIT_STACK, &r);
    82         this->size = r.rlim_cur;
    83 
    84         this->limit = (void *)(((intptr_t)this->base) - this->size);
    85         this->context = &storage_mainThreadCtx;
    86         this->top = this->base;
    87 }
    88 
    89 void ?{}( coStack_t * this, current_stack_info_t * info) {
    90         this->size = info->size;
    91         this->storage = info->storage;
    92         this->limit = info->limit;
    93         this->base = info->base;
    94         this->context = info->context;
    95         this->top = info->top;
    96         this->userStack = true;
    97 }
    98 
    99 void ?{}( coroutine_desc * this, current_stack_info_t * info) {
    100         (&this->stack){ info };
    101         this->name = "Main Thread";
    102         this->errno_ = 0;
    103         this->state = Start;
    104 }
    105 
    106 void ?{}( thread_desc * this, current_stack_info_t * info) {
    107         (&this->cor){ info };
     82        this.size = r.rlim_cur;
     83
     84        this.limit = (void *)(((intptr_t)this.base) - this.size);
     85        this.context = &storage_mainThreadCtx;
     86        this.top = this.base;
     87}
     88
     89void ?{}( coStack_t & this, current_stack_info_t * info) {
     90        this.size = info->size;
     91        this.storage = info->storage;
     92        this.limit = info->limit;
     93        this.base = info->base;
     94        this.context = info->context;
     95        this.top = info->top;
     96        this.userStack = true;
     97}
     98
     99void ?{}( coroutine_desc & this, current_stack_info_t * info) {
     100        (this.stack){ info };
     101        this.name = "Main Thread";
     102        this.errno_ = 0;
     103        this.state = Start;
     104        this.starter = NULL;
     105}
     106
     107void ?{}( thread_desc & this, current_stack_info_t * info) {
     108        (this.cor){ info };
    108109}
    109110
    110111//-----------------------------------------------------------------------------
    111112// Processor coroutine
    112 void ?{}(processorCtx_t * this, processor * proc) {
    113         (&this->__cor){ "Processor" };
    114         this->proc = proc;
    115         proc->runner = this;
    116 }
    117 
    118 void ?{}(processorCtx_t * this, processor * proc, current_stack_info_t * info) {
    119         (&this->__cor){ info };
    120         this->proc = proc;
    121         proc->runner = this;
    122 }
    123 
    124 void ?{}(processor * this) {
     113
     114// Construct the processor context of the main processor
     115void ?{}(processorCtx_t & this, processor * proc) {
     116        (this.__cor){ "Processor" };
     117        this.__cor.starter = &mainThread->cor;
     118        this.proc = proc;
     119        proc->runner = &this;
     120}
     121
     122// Construct the processor context of non-main processors
     123void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info) {
     124        (this.__cor){ info };
     125        this.proc = proc;
     126        proc->runner = &this;
     127}
     128
     129void ?{}(processor & this) {
    125130        this{ mainCluster };
    126131}
    127132
    128 void ?{}(processor * this, cluster * cltr) {
    129         this->cltr = cltr;
    130         (&this->terminated){ 0 };
    131         this->do_terminate = false;
    132         this->preemption_alarm = NULL;
    133         this->pending_preemption = false;
    134 
    135         start( this );
    136 }
    137 
    138 void ?{}(processor * this, cluster * cltr, processorCtx_t * runner) {
    139         this->cltr = cltr;
    140         (&this->terminated){ 0 };
    141         this->do_terminate = false;
    142         this->preemption_alarm = NULL;
    143         this->pending_preemption = false;
    144         this->kernel_thread = pthread_self();
    145 
    146         this->runner = runner;
    147         LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", runner);
    148         runner{ this };
    149 }
    150 
    151 void ^?{}(processor * this) {
    152         if( ! this->do_terminate ) {
    153                 LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", this);
    154                 this->do_terminate = true;
    155                 P( &this->terminated );
    156                 pthread_join( this->kernel_thread, NULL );
    157         }
    158 }
    159 
    160 void ?{}(cluster * this) {
    161         ( &this->ready_queue ){};
    162         ( &this->ready_queue_lock ){};
    163 
    164         this->preemption = default_preemption();
    165 }
    166 
    167 void ^?{}(cluster * this) {
     133void ?{}(processor & this, cluster * cltr) {
     134        this.cltr = cltr;
     135        (this.terminated){ 0 };
     136        this.do_terminate = false;
     137        this.preemption_alarm = NULL;
     138        this.pending_preemption = false;
     139
     140        start( &this );
     141}
     142
     143void ?{}(processor & this, cluster * cltr, processorCtx_t & runner) {
     144        this.cltr = cltr;
     145        (this.terminated){ 0 };
     146        this.do_terminate = false;
     147        this.preemption_alarm = NULL;
     148        this.pending_preemption = false;
     149        this.kernel_thread = pthread_self();
     150
     151        this.runner = &runner;
     152        LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", &runner);
     153        runner{ &this };
     154}
     155
     156void ^?{}(processor & this) {
     157        if( ! this.do_terminate ) {
     158                LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", &this);
     159                this.do_terminate = true;
     160                P( &this.terminated );
     161                pthread_join( this.kernel_thread, NULL );
     162        }
     163}
     164
     165void ?{}(cluster & this) {
     166        ( this.ready_queue ){};
     167        ( this.ready_queue_lock ){};
     168
     169        this.preemption = default_preemption();
     170}
     171
     172void ^?{}(cluster & this) {
    168173
    169174}
    … …  
    173178//=============================================================================================
    174179//Main of the processor contexts
    175 void main(processorCtx_t * runner) {
    176         processor * this = runner->proc;
     180void main(processorCtx_t & runner) {
     181        processor * this = runner.proc;
    177182
    178183        LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this);
    … …  
    219224// from the processor coroutine to the target thread
    220225void runThread(processor * this, thread_desc * dst) {
    221         coroutine_desc * proc_cor = get_coroutine(this->runner);
     226        coroutine_desc * proc_cor = get_coroutine(*this->runner);
    222227        coroutine_desc * thrd_cor = get_coroutine(dst);
    223228
    … …  
    301306        // appropriate stack.
    302307        proc_cor_storage.__cor.state = Active;
    303         main( &proc_cor_storage );
     308        main( proc_cor_storage );
    304309        proc_cor_storage.__cor.state = Halted;
    305310
    … …  
    443448        mainThread = (thread_desc *)&storage_mainThread;
    444449        current_stack_info_t info;
    445         mainThread{ &info };
     450        (*mainThread){ &info };
    446451
    447452        LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
    … …  
    449454        // Initialize the main cluster
    450455        mainCluster = (cluster *)&storage_mainCluster;
    451         mainCluster{};
     456        (*mainCluster){};
    452457
    453458        LIB_DEBUG_PRINT_SAFE("Kernel : main cluster ready\n");
    … …  
    456461        // (the coroutine that contains the processing control flow)
    457462        mainProcessor = (processor *)&storage_mainProcessor;
    458         mainProcessor{ mainCluster, (processorCtx_t *)&storage_mainProcessorCtx };
     463        (*mainProcessor){ mainCluster, *(processorCtx_t *)&storage_mainProcessorCtx };
    459464
    460465        //initialize the global state variables
    … …  
    473478        // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
    474479        // mainThread is on the ready queue when this call is made.
    475         resume( mainProcessor->runner );
     480        resume( *mainProcessor->runner );
    476481
    477482
    … …  
    501506        // Destroy the main processor and its context in reverse order of construction
    502507        // These were manually constructed so we need manually destroy them
    503         ^(mainProcessor->runner){};
     508        ^(*mainProcessor->runner){};
    504509        ^(mainProcessor){};
    505510
    … …  
    569574//-----------------------------------------------------------------------------
    570575// Locks
    571 void ?{}( spinlock * this ) {
    572         this->lock = 0;
    573 }
    574 void ^?{}( spinlock * this ) {
     576void ?{}( spinlock & this ) {
     577        this.lock = 0;
     578}
     579void ^?{}( spinlock & this ) {
    575580
    576581}
    … …  
    606611}
    607612
    608 void  ?{}( semaphore * this, int count = 1 ) {
    609         (&this->lock){};
    610         this->count = count;
    611         (&this->waiting){};
    612 }
    613 void ^?{}(semaphore * this) {}
     613void  ?{}( semaphore & this, int count = 1 ) {
     614        (this.lock){};
     615        this.count = count;
     616        (this.waiting){};
     617}
     618void ^?{}(semaphore & this) {}
    614619
    615620void P(semaphore * this) {
    … …  
    645650//-----------------------------------------------------------------------------
    646651// Queues
    647 void ?{}( __thread_queue_t * this ) {
    648         this->head = NULL;
    649         this->tail = &this->head;
     652void ?{}( __thread_queue_t & this ) {
     653        this.head = NULL;
     654        this.tail = &this.head;
    650655}
    651656
    … …  
    685690}
    686691
    687 
    688 
    689 void ?{}( __condition_stack_t * this ) {
    690         this->top = NULL;
     692void ?{}( __condition_stack_t & this ) {
     693        this.top = NULL;
    691694}
    692695
Note: See TracChangeset for help on using the changeset viewer.