Ignore:
Timestamp:
Mar 2, 2021, 1:58:12 PM (8 months ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
Children:
2cd784a
Parents:
6047b00
Message:

Changed io to use ring per kernel threads.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/concurrency/kernel.cfa

    r6047b00 rdddb3dd0  
    2222#include <signal.h>
    2323#include <unistd.h>
     24extern "C" {
     25        #include <sys/eventfd.h>
     26}
    2427
    2528//CFA Includes
     
    109112static void __run_thread(processor * this, $thread * dst);
    110113static void __wake_one(cluster * cltr);
    111 static void wait(__bin_sem_t & this);
    112114
    113115static void push  (__cluster_idles & idles, processor & proc);
     
    115117static [unsigned idle, unsigned total, * processor] query( & __cluster_idles idles );
    116118
     119extern void __cfa_io_start( processor * );
     120extern void __cfa_io_drain( processor * );
     121extern void __cfa_io_flush( processor * );
     122extern void __cfa_io_stop ( processor * );
     123static inline void __maybe_io_drain( processor * );
     124
     125extern void __disable_interrupts_hard();
     126extern void __enable_interrupts_hard();
    117127
    118128//=============================================================================================
     
    130140        verify(this);
    131141
     142        __cfa_io_start( this );
     143
    132144        __cfadbg_print_safe(runtime_core, "Kernel : core %p starting\n", this);
    133145        #if !defined(__CFA_NO_STATISTICS__)
     
    151163                MAIN_LOOP:
    152164                for() {
     165                        // Check if there is pending io
     166                        __maybe_io_drain( this );
     167
    153168                        // Try to get the next thread
    154169                        readyThread = __next_thread( this->cltr );
    155170
    156171                        if( !readyThread ) {
     172                                __cfa_io_flush( this );
    157173                                readyThread = __next_thread_slow( this->cltr );
    158174                        }
     
    190206                                #endif
    191207
    192                                 wait( this->idle );
     208                                __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle);
     209
     210                                __disable_interrupts_hard();
     211                                eventfd_t val;
     212                                eventfd_read( this->idle, &val );
     213                                __enable_interrupts_hard();
    193214
    194215                                #if !defined(__CFA_NO_STATISTICS__)
     
    206227
    207228                        /* paranoid */ verify( readyThread );
     229
     230                        // Reset io dirty bit
     231                        this->io.dirty = false;
    208232
    209233                        // We found a thread run it
     
    220244                                }
    221245                        #endif
     246
     247                        if(this->io.pending && !this->io.dirty) {
     248                                __cfa_io_flush( this );
     249                        }
    222250                }
    223251
     
    225253        }
    226254
     255        __cfa_io_stop( this );
     256
    227257        post( this->terminated );
     258
    228259
    229260        if(this == mainProcessor) {
     
    248279        /* paranoid */ verifyf( thrd_dst->link.next == 0p, "Expected null got %p", thrd_dst->link.next );
    249280        __builtin_prefetch( thrd_dst->context.SP );
     281
     282        __cfadbg_print_safe(runtime_core, "Kernel : core %p running thread %p (%s)\n", this, thrd_dst, thrd_dst->self_cor.name);
    250283
    251284        $coroutine * proc_cor = get_coroutine(this->runner);
     
    330363        // Just before returning to the processor, set the processor coroutine to active
    331364        proc_cor->state = Active;
     365
     366        __cfadbg_print_safe(runtime_core, "Kernel : core %p finished running thread %p\n", this, thrd_dst);
    332367
    333368        /* paranoid */ verify( ! __preemption_enabled() );
     
    549584// Kernel Idle Sleep
    550585//=============================================================================================
    551 extern "C" {
    552         char * strerror(int);
    553 }
    554 #define CHECKED(x) { int err = x; if( err != 0 ) abort("KERNEL ERROR: Operation \"" #x "\" return error %d - %s\n", err, strerror(err)); }
    555 
    556 static void wait(__bin_sem_t & this) with( this ) {
    557         verify(__cfaabi_dbg_in_kernel());
    558         CHECKED( pthread_mutex_lock(&lock) );
    559                 while(val < 1) {
    560                         pthread_cond_wait(&cond, &lock);
    561                 }
    562                 val -= 1;
    563         CHECKED( pthread_mutex_unlock(&lock) );
    564 }
    565 
    566 static bool post(__bin_sem_t & this) with( this ) {
    567         bool needs_signal = false;
    568 
    569         CHECKED( pthread_mutex_lock(&lock) );
    570                 if(val < 1) {
    571                         val += 1;
    572                         pthread_cond_signal(&cond);
    573                         needs_signal = true;
    574                 }
    575         CHECKED( pthread_mutex_unlock(&lock) );
    576 
    577         return needs_signal;
    578 }
    579 
    580 #undef CHECKED
    581 
    582586// Wake a thread from the front if there are any
    583587static void __wake_one(cluster * this) {
     
    595599
    596600        // We found a processor, wake it up
    597         post( p->idle );
     601        eventfd_t val;
     602        val = 1;
     603        eventfd_write( p->idle, val );
    598604
    599605        #if !defined(__CFA_NO_STATISTICS__)
     
    613619        disable_interrupts();
    614620                /* paranoid */ verify( ! __preemption_enabled() );
    615                 post( this->idle );
     621                eventfd_t val;
     622                val = 1;
     623                eventfd_read( this->idle, &val );
    616624        enable_interrupts( __cfaabi_dbg_ctx );
    617625}
     
    696704// Kernel Utilities
    697705//=============================================================================================
     706#if defined(CFA_HAVE_LINUX_IO_URING_H)
     707#include "io/types.hfa"
     708#endif
     709
     710static inline void __maybe_io_drain( processor * proc ) {
     711        #if defined(CFA_HAVE_LINUX_IO_URING_H)
     712                __cfadbg_print_safe(runtime_core, "Kernel : core %p checking io for ring %d\n", proc, proc->io.ctx->fd);
     713
     714                // Check if we should drain the queue
     715                $io_context * ctx = proc->io.ctx;
     716                unsigned head = *ctx->cq.head;
     717                unsigned tail = *ctx->cq.tail;
     718                if(head != tail) __cfa_io_drain( proc );
     719        #endif
     720}
     721
    698722//-----------------------------------------------------------------------------
    699723// Debug
Note: See TracChangeset for help on using the changeset viewer.