Changeset b035046


Ignore:
Timestamp:
May 25, 2022, 3:18:21 PM (3 months ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
master, pthread-emulation
Children:
5024df4
Parents:
6dc7011a
Message:

changed some MAX to ULLONG_MAX to avoid the memory access where possible and removed some -1u I missed last time

Location:
libcfa/src/concurrency
Files:
8 edited

Legend:

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

    r6dc7011a rb035046  
    221221                        const unsigned long long ctsc = rdtscl();
    222222
    223                         if(proc->io.target == MAX) {
     223                        if(proc->io.target == UINT_MAX) {
    224224                                uint64_t chaos = __tls_rand();
    225225                                unsigned ext = chaos & 0xff;
     
    232232                        else {
    233233                                const unsigned target = proc->io.target;
    234                                 /* paranoid */ verify( io.tscs[target].tv != MAX );
     234                                /* paranoid */ verify( io.tscs[target].tv != ULLONG_MAX );
    235235                                HELP: if(target < ctxs_count) {
    236236                                        const unsigned long long cutoff = calc_cutoff(ctsc, ctx->cq.id, ctxs_count, io.data, io.tscs, __shard_factor.io);
     
    246246                                        __STATS__( true, io.calls.helped++; )
    247247                                }
    248                                 proc->io.target = MAX;
     248                                proc->io.target = UINT_MAX;
    249249                        }
    250250                }
  • libcfa/src/concurrency/io/types.hfa

    r6dc7011a rb035046  
    1717#pragma once
    1818
     19#include <limits.h>
     20
    1921extern "C" {
    2022        #include <linux/types.h>
     
    2527#include "iofwd.hfa"
    2628#include "kernel/fwd.hfa"
    27 #include "limits.hfa"
    2829
    2930#if defined(CFA_HAVE_LINUX_IO_URING_H)
     
    140141                const __u32 tail = *this->cq.tail;
    141142
    142                 if(head == tail) return MAX;
     143                if(head == tail) return ULLONG_MAX;
    143144
    144145                return this->cq.ts;
  • libcfa/src/concurrency/kernel/cluster.cfa

    r6dc7011a rb035046  
    233233                                        if(is_empty(sl)) {
    234234                                                assert( sl.anchor.next == 0p );
    235                                                 assert( sl.anchor.ts   == -1llu );
     235                                                assert( sl.anchor.ts   == MAX );
    236236                                                assert( mock_head(sl)  == sl.prev );
    237237                                        } else {
    238238                                                assert( sl.anchor.next != 0p );
    239                                                 assert( sl.anchor.ts   != -1llu );
     239                                                assert( sl.anchor.ts   != MAX );
    240240                                                assert( mock_head(sl)  != sl.prev );
    241241                                        }
     
    259259                /* paranoid */ verifyf( it, "Unexpected null iterator, at index %u of %u\n", i, count);
    260260                it->rdq.id = valrq;
    261                 it->rdq.target = MAX;
     261                it->rdq.target = UINT_MAX;
    262262                valrq += __shard_factor.readyq;
    263263                #if defined(CFA_HAVE_LINUX_IO_URING_H)
    264264                        it->io.ctx->cq.id = valio;
    265                         it->io.target = MAX;
     265                        it->io.target = UINT_MAX;
    266266                        valio += __shard_factor.io;
    267267                #endif
     
    472472        this.prev = mock_head(this);
    473473        this.anchor.next = 0p;
    474         this.anchor.ts   = -1llu;
     474        this.anchor.ts   = MAX;
    475475        #if !defined(__CFA_NO_STATISTICS__)
    476476                this.cnt  = 0;
     
    484484        /* paranoid */ verify( &mock_head(this)->link.ts   == &this.anchor.ts   );
    485485        /* paranoid */ verify( mock_head(this)->link.next == 0p );
    486         /* paranoid */ verify( mock_head(this)->link.ts   == -1llu  );
     486        /* paranoid */ verify( mock_head(this)->link.ts   == MAX  );
    487487        /* paranoid */ verify( mock_head(this) == this.prev );
    488488        /* paranoid */ verify( __alignof__(__intrusive_lane_t) == 128 );
     
    495495        // Make sure the list is empty
    496496        /* paranoid */ verify( this.anchor.next == 0p );
    497         /* paranoid */ verify( this.anchor.ts   == -1llu );
     497        /* paranoid */ verify( this.anchor.ts   == MAX );
    498498        /* paranoid */ verify( mock_head(this)  == this.prev );
    499499}
  • libcfa/src/concurrency/kernel/cluster.hfa

    r6dc7011a rb035046  
    1919#include "kernel/private.hfa"
    2020
    21 #include "limits.hfa"
     21#include <limits.h>
    2222
    2323//-----------------------------------------------------------------------
     
    3737
    3838static inline void touch_tsc(__timestamp_t * tscs, size_t idx, unsigned long long ts_prev, unsigned long long ts_next) {
    39         if (ts_next == MAX) return;
     39        if (ts_next == ULLONG_MAX) return;
    4040        unsigned long long now = rdtscl();
    4141        unsigned long long pma = __atomic_load_n(&tscs[ idx ].ma, __ATOMIC_RELAXED);
     
    5959        for(i; shard_factor) {
    6060                unsigned long long ptsc = ts(data[start + i]);
    61                 if(ptsc != -1ull) {
     61                if(ptsc != ULLONG_MAX) {
    6262                        /* paranoid */ verify( start + i < count );
    6363                        unsigned long long tsc = moving_average(ctsc, ptsc, tscs[start + i].ma);
  • libcfa/src/concurrency/kernel/startup.cfa

    r6dc7011a rb035046  
    507507        self_mon_p = &self_mon;
    508508        link.next = 0p;
    509         link.ts   = -1llu;
     509        link.ts   = MAX;
    510510        preferred = ready_queue_new_preferred();
    511511        last_proc = 0p;
  • libcfa/src/concurrency/ready_queue.cfa

    r6dc7011a rb035046  
    125125        const unsigned long long ctsc = rdtscl();
    126126
    127         if(proc->rdq.target == MAX) {
     127        if(proc->rdq.target == UINT_MAX) {
    128128                uint64_t chaos = __tls_rand();
    129129                unsigned ext = chaos & 0xff;
     
    137137                const unsigned target = proc->rdq.target;
    138138                __cfadbg_print_safe(ready_queue, "Kernel : %u considering helping %u, tcsc %llu\n", this, target, readyQ.tscs[target].tv);
    139                 /* paranoid */ verify( readyQ.tscs[target].tv != MAX );
     139                /* paranoid */ verify( readyQ.tscs[target].tv != ULLONG_MAX );
    140140                if(target < lanes_count) {
    141141                        const unsigned long long cutoff = calc_cutoff(ctsc, proc->rdq.id, lanes_count, cltr->sched.readyQ.data, cltr->sched.readyQ.tscs, __shard_factor.readyq);
     
    147147                        }
    148148                }
    149                 proc->rdq.target = MAX;
     149                proc->rdq.target = UINT_MAX;
    150150        }
    151151
     
    245245// get preferred ready for new thread
    246246unsigned ready_queue_new_preferred() {
    247         unsigned pref = MAX;
     247        unsigned pref = UINT_MAX;
    248248        if(struct thread$ * thrd = publicTLS_get( this_thread )) {
    249249                pref = thrd->preferred;
  • libcfa/src/concurrency/ready_subqueue.hfa

    r6dc7011a rb035046  
    7171        bool is_empty = this.anchor.next == 0p;
    7272        node->link.next = 0p;
    73         node->link.ts   = MAX;
     73        node->link.ts   = ULLONG_MAX;
    7474        #if !defined(__CFA_NO_STATISTICS__)
    7575                this.cnt--;
  • libcfa/src/concurrency/thread.cfa

    r6dc7011a rb035046  
    1919#include "thread.hfa"
    2020
     21#include "exception.hfa"
    2122#include "kernel/private.hfa"
    22 #include "exception.hfa"
     23#include "limits.hfa"
    2324
    2425#define __CFA_INVOKE_PRIVATE__
     
    4445        curr_cluster = &cl;
    4546        link.next = 0p;
    46         link.ts   = -1llu;
     47        link.ts   = MAX;
    4748        preferred = ready_queue_new_preferred();
    4849        last_proc = 0p;
Note: See TracChangeset for help on using the changeset viewer.