Changeset dbe2533 for libcfa/src


Ignore:
Timestamp:
Mar 21, 2022, 1:40:35 PM (4 years ago)
Author:
caparsons <caparson@…>
Branches:
ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum
Children:
d672350
Parents:
b39e961b (diff), 4ecc35a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:
libcfa/src/concurrency
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/concurrency/io.cfa

    rb39e961b rdbe2533  
    9393        extern void __kernel_unpark( thread$ * thrd, unpark_hint );
    9494
    95         bool __cfa_io_drain( processor * proc ) {
     95        bool __cfa_io_drain( $io_context * ctx ) {
    9696                /* paranoid */ verify( ! __preemption_enabled() );
    9797                /* paranoid */ verify( ready_schedule_islocked() );
    98                 /* paranoid */ verify( proc );
    99                 /* paranoid */ verify( proc->io.ctx );
     98                /* paranoid */ verify( ctx );
    10099
    101100                // Drain the queue
    102                 $io_context * ctx = proc->io.ctx;
    103101                unsigned head = *ctx->cq.head;
    104102                unsigned tail = *ctx->cq.tail;
    … …  
    110108                if(count == 0) return false;
    111109
     110                if(!__atomic_try_acquire(&ctx->cq.lock)) {
     111                        return false;
     112                }
     113
    112114                for(i; count) {
    113115                        unsigned idx = (head + i) & mask;
    … …  
    130132                /* paranoid */ verify( ready_schedule_islocked() );
    131133                /* paranoid */ verify( ! __preemption_enabled() );
     134
     135                __atomic_unlock(&ctx->cq.lock);
    132136
    133137                return true;
    … …  
    179183
    180184                ready_schedule_lock();
    181                 bool ret = __cfa_io_drain( proc );
     185                bool ret = __cfa_io_drain( &ctx );
    182186                ready_schedule_unlock();
    183187                return ret;

  • libcfa/src/concurrency/io/setup.cfa

    rb39e961b rdbe2533  
    214214
    215215                // completion queue
     216                cq.lock      = 0;
    216217                cq.head      = (volatile __u32 *)(((intptr_t)cq.ring_ptr) + params.cq_off.head);
    217218                cq.tail      = (volatile __u32 *)(((intptr_t)cq.ring_ptr) + params.cq_off.tail);

  • libcfa/src/concurrency/io/types.hfa

    rb39e961b rdbe2533  
    7878
    7979        struct __cmp_ring_t {
     80                volatile bool lock;
     81
    8082                // Head and tail of the ring
    8183                volatile __u32 * head;

  • libcfa/src/concurrency/kernel.cfa

    rb39e961b rdbe2533  
    136136static void mark_awake(__cluster_proc_list & idles, processor & proc);
    137137
    138 extern bool __cfa_io_drain( processor * );
     138extern bool __cfa_io_drain( $io_context * );
    139139extern bool __cfa_io_flush( processor *, int min_comp );
    140140static inline bool __maybe_io_drain( processor * );
    … …  
    839839                if(head == tail) return false;
    840840                ready_schedule_lock();
    841                 ret = __cfa_io_drain( proc );
     841                ret = __cfa_io_drain( ctx );
    842842                ready_schedule_unlock();
    843843        #endif

  • libcfa/src/concurrency/kernel.hfa

    rb39e961b rdbe2533  
    108108        struct {
    109109                $io_context * ctx;
     110                unsigned id;
     111                unsigned target;
    110112                volatile bool pending;
    111113                volatile bool dirty;
    … …  
    209211                struct {
    210212                        // Arary of subqueues
    211                         __intrusive_lane_t * volatile data;
     213                        __intrusive_lane_t * data;
    212214
    213215                        // Time since subqueues were processed
    214                         __timestamp_t * volatile tscs;
     216                        __timestamp_t * tscs;
    215217
    216218                        // Number of subqueue / timestamps
    … …  
    219221
    220222                struct {
     223                        // Array of $io_
     224                        $io_context ** data;
     225
    221226                        // Time since subqueues were processed
    222                         __timestamp_t * volatile tscs;
     227                        __timestamp_t * tscs;
    223228
    224229                        // Number of I/O subqueues
    … …  
    227232
    228233                // Cache each kernel thread belongs to
    229                 __cache_id_t * volatile caches;
     234                __cache_id_t * caches;
    230235        } sched;
    231236

  • libcfa/src/concurrency/kernel/cluster.cfa

    rb39e961b rdbe2533  
    253253}
    254254
    255 static void assign_list(unsigned & value, dlist(processor) & list, unsigned count) {
     255static void assign_list(unsigned & valrq, unsigned & valio, dlist(processor) & list, unsigned count) {
    256256        processor * it = &list`first;
    257257        for(unsigned i = 0; i < count; i++) {
    258258                /* paranoid */ verifyf( it, "Unexpected null iterator, at index %u of %u\n", i, count);
    259                 it->rdq.id = value;
     259                it->rdq.id = valrq;
    260260                it->rdq.target = MAX;
    261                 value += __shard_factor.readyq;
     261                it->io.id = valio;
     262                it->io.target = MAX;
     263                valrq += __shard_factor.readyq;
     264                valio += __shard_factor.io;
    262265                it = &(*it)`next;
    263266        }
    … …  
    265268
    266269static void reassign_cltr_id(struct cluster * cltr) {
    267         unsigned preferred = 0;
    268         assign_list(preferred, cltr->procs.actives, cltr->procs.total - cltr->procs.idle);
    269         assign_list(preferred, cltr->procs.idles  , cltr->procs.idle );
     270        unsigned prefrq = 0;
     271        unsigned prefio = 0;
     272        assign_list(prefrq, prefio, cltr->procs.actives, cltr->procs.total - cltr->procs.idle);
     273        assign_list(prefrq, prefio, cltr->procs.idles  , cltr->procs.idle );
     274}
     275
     276static void assign_io($io_context ** data, size_t count, dlist(processor) & list) {
     277        processor * it = &list`first;
     278        while(it) {
     279                /* paranoid */ verifyf( it, "Unexpected null iterator\n");
     280                /* paranoid */ verifyf( it->io.id < count, "Processor %p has id %u above count %zu\n", it, it->rdq.id, count);
     281                data[it->io.id] = it->io.ctx;
     282                it = &(*it)`next;
     283        }
     284}
     285
     286static void reassign_cltr_io(struct cluster * cltr) {
     287        assign_io(cltr->sched.io.data, cltr->sched.io.count, cltr->procs.actives);
     288        assign_io(cltr->sched.io.data, cltr->sched.io.count, cltr->procs.idles  );
    270289}
    271290
    … …  
    322341
    323342        // Fix the io times
    324         cltr->sched.io.count = target;
     343        cltr->sched.io.count = target * __shard_factor.io;
    325344        fix_times(cltr->sched.io.tscs, cltr->sched.io.count);
    326345
    … …  
    330349        // reassign the clusters.
    331350        reassign_cltr_id(cltr);
     351
     352        cltr->sched.io.data = alloc( cltr->sched.io.count, cltr->sched.io.data`realloc );
     353        reassign_cltr_io(cltr);
    332354
    333355        // Make sure that everything is consistent
    … …  
    411433
    412434        // Fix the io times
    413         cltr->sched.io.count = target;
     435        cltr->sched.io.count = target * __shard_factor.io;
    414436        fix_times(cltr->sched.io.tscs, cltr->sched.io.count);
    415437
    416438        reassign_cltr_id(cltr);
     439
     440        cltr->sched.io.data = alloc( cltr->sched.io.count, cltr->sched.io.data`realloc );
     441        reassign_cltr_io(cltr);
    417442
    418443        // Make sure that everything is consistent

  • libcfa/src/concurrency/kernel/cluster.hfa

    rb39e961b rdbe2533  
    7272static struct {
    7373        const unsigned readyq;
    74 } __shard_factor = { 2 };
     74        const unsigned io;
     75} __shard_factor = { 2, 1 };
    7576
    7677// Local Variables: //
Note: See TracChangeset for help on using the changeset viewer.