Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • doc/theses/thierry_delisle_PhD/code/relaxed_list.hpp

    rf0c3120 rb232745  
    88#define SNZM 4
    99#define BIAS 5
    10 #define BACK 6
    11 #define BACKBIAS 7
    1210
    1311#ifndef VARIANT
     
    2018
    2119#include <cmath>
    22 #include <functional>
    2320#include <memory>
    2421#include <mutex>
    25 #include <thread>
    2622#include <type_traits>
    2723
     
    3026#include "links.hpp"
    3127#include "snzi.hpp"
    32 #include "snzi-packed.hpp"
    3328#include "snzm.hpp"
    3429
     
    7368                        "RELAXED: SNZI + DISCOVERED MASK",
    7469                        "RELAXED: SNZI + MASK",
    75                         "RELAXED: SNZI + LOCAL BIAS",
    76                         "RELAXED: SNZI + REVERSE RNG",
    77                         "RELAXED: SNZI + LOCAL BIAS + REVERSE RNG"
     70                        "RELAXED: SNZI + LOCAL BIAS"
    7871                };
    7972                return names[VARIANT];
     
    8376                : numLists(numThreads * numQueues)
    8477                , lists(new intrusive_queue_t<node_t>[numLists])
    85                 #if VARIANT == SNZI || VARIANT == BACK
     78                #if VARIANT == SNZI || VARIANT == BIAS
    8679                        , snzi( std::log2( numLists / (2 * numQueues) ), 2 )
    87                 #elif VARIANT == BIAS || VARIANT == BACKBIAS
    88                         #ifdef SNZI_PACKED
    89                                 , snzi( std::ceil( std::log2(numLists) ) )
    90                         #else
    91                                 , snzi( std::log2( numLists / (2 * numQueues) ), 2 )
    92                         #endif
    9380                #elif VARIANT == SNZM || VARIANT == DISCOVER
    9481                        , snzm( numLists )
     
    10996                while(true) {
    11097                        // Pick a random list
    111                         unsigned i = idx_from_r(tls.rng1.next(), VARIANT == BIAS || VARIANT == BACKBIAS);
     98                        #if VARIANT == BIAS
     99                        unsigned r = tls.rng.next();
     100                        unsigned i;
     101                        if(0 == (r & 0xF)) {
     102                                i = r >> 4;
     103                        } else {
     104                                i = tls.my_queue + ((r >> 4) % 4);
     105                                tls.pick.push.local++;
     106                        }
     107                        i %= numLists;
     108                        #else
     109                        unsigned i = tls.rng.next() % numLists;
     110                        #endif
    112111
    113112                        #ifndef NO_STATS
     
    118117                        if( !lists[i].lock.try_lock() ) continue;
    119118
    120                         #if VARIANT == VANILLA || VARIANT == BITMASK
     119                        #if VARIANT != SNZM && VARIANT != SNZI && VARIANT != DISCOVER && VARIANT != BIAS
    121120                                __attribute__((unused)) int num = numNonEmpty;
    122121                        #endif
     
    132131                                #elif VARIANT == SNZI || VARIANT == BIAS
    133132                                        snzi.arrive(i);
    134                                 #elif VARIANT == BACK || VARIANT == BACKBIAS
    135                                         snzi.arrive(i);
    136                                         tls.rng2.set_raw_state( tls.rng1.get_raw_state());
    137133                                #elif VARIANT == SNZM
    138134                                        snzm.arrive(i);
     
    149145                                #endif
    150146                        }
    151                         #if VARIANT == VANILLA || VARIANT == BITMASK
     147                        #if VARIANT != SNZM && VARIANT != SNZI && VARIANT != DISCOVER && VARIANT != BIAS
    152148                                assert(numNonEmpty <= (int)numLists);
    153149                        #endif
     
    158154                        #ifndef NO_STATS
    159155                                tls.pick.push.success++;
    160                                 #if VARIANT == VANILLA || VARIANT == BITMASK
     156                                #if VARIANT != SNZM && VARIANT != SNZI && VARIANT != DISCOVER && VARIANT != BIAS
    161157                                        tls.empty.push.value += num;
    162158                                        tls.empty.push.count += 1;
     
    175171                                {
    176172                                        // Pick first list totally randomly
    177                                         i = tls.rng1.next() % numLists;
     173                                        i = tls.rng.next() % numLists;
    178174
    179175                                        // Pick the other according to the bitmask
    180                                         unsigned r = tls.rng1.next();
     176                                        unsigned r = tls.rng.next();
    181177
    182178                                        size_t mask = tls.mask.load(std::memory_order_relaxed);
     
    201197                        while(snzi.query()) {
    202198                                // Pick two lists at random
    203                                 int i = tls.rng1.next() % numLists;
    204                                 int j = tls.rng1.next() % numLists;
    205 
    206                                 if(auto node = try_pop(i, j)) return node;
    207                         }
    208 
    209                 #elif VARIANT == BACK
    210                         while(snzi.query()) {
    211                                 // Pick two lists at random
    212                                 int i = tls.rng2.prev() % numLists;
    213                                 int j = tls.rng2.prev() % numLists;
    214 
    215                                 if(auto node = try_pop(i, j)) return node;
    216                         }
    217 
    218                 #elif VARIANT == BACKBIAS
    219                         while(snzi.query()) {
    220                                 // Pick two lists at random
    221                                 int i = idx_from_r(tls.rng2.prev(), true);
    222                                 int j = idx_from_r(tls.rng2.prev(), true);
     199                                int i = tls.rng.next() % numLists;
     200                                // int j = tls.rng.next() % numLists;
    223201
    224202                                if(auto node = try_pop(i, j)) return node;
     
    228206                        while(snzi.query()) {
    229207                                // Pick two lists at random
    230                                 unsigned ri = tls.rng1.next();
     208                                unsigned ri = tls.rng.next();
    231209                                unsigned i;
    232                                 unsigned j = tls.rng1.next();
     210                                unsigned j = tls.rng.next();
    233211                                if(0 == (ri & 0xF)) {
    234212                                        i = (ri >> 4) % numLists;
     
    250228                                {
    251229                                        // Pick two random number
    252                                         unsigned ri = tls.rng1.next();
    253                                         unsigned rj = tls.rng1.next();
     230                                        unsigned ri = tls.rng.next();
     231                                        unsigned rj = tls.rng.next();
    254232
    255233                                        // Pick two nodes from it
     
    292270                        while(snzm.query()) {
    293271                                // Pick two lists at random
    294                                 int i = tls.rng1.next() % numLists;
    295                                 int j = tls.rng1.next() % numLists;
     272                                int i = tls.rng.next() % numLists;
     273                                int j = tls.rng.next() % numLists;
    296274
    297275                                if(auto node = try_pop(i, j)) return node;
     
    307285                                        unsigned num = ((numLists - 1) >> 6) + 1;
    308286
    309                                         unsigned ri = tls.rng1.next();
    310                                         unsigned rj = tls.rng1.next();
     287                                        unsigned ri = tls.rng.next();
     288                                        unsigned rj = tls.rng.next();
    311289
    312290                                        unsigned wdxi = (ri >> 6u) % num;
     
    336314                        while(numNonEmpty != 0) {
    337315                                // Pick two lists at random
    338                                 int i = tls.rng1.next() % numLists;
    339                                 int j = tls.rng1.next() % numLists;
     316                                int i = tls.rng.next() % numLists;
     317                                int j = tls.rng.next() % numLists;
    340318
    341319                                if(auto node = try_pop(i, j)) return node;
     
    370348                if( !list.lock.try_lock() ) return nullptr;
    371349
    372                 #if VARIANT == VANILLA || VARIANT == BITMASK
     350                #if VARIANT != SNZM && VARIANT != SNZI && VARIANT != DISCOVER  && VARIANT != BIAS
    373351                        __attribute__((unused)) int num = numNonEmpty;
    374352                #endif
     
    393371                                __attribute__((unused)) bool ret = btr(tls.mask, bit);
    394372                                snzm.depart(w);
    395                         #elif VARIANT == SNZI || VARIANT == BIAS || VARIANT == BACK || VARIANT == BACKBIAS
     373                        #elif VARIANT == SNZI || VARIANT == BIAS
    396374                                snzi.depart(w);
    397375                        #elif VARIANT == SNZM
     
    412390                // Unlock and return
    413391                list.lock.unlock();
    414                 #if VARIANT == VANILLA || VARIANT == BITMASK
     392                #if VARIANT != SNZM && VARIANT != SNZI && VARIANT != DISCOVER && VARIANT != BIAS
    415393                        assert(numNonEmpty >= 0);
    416394                #endif
    417395                #ifndef NO_STATS
    418396                        tls.pick.pop.success++;
    419                         #if VARIANT == VANILLA || VARIANT == BITMASK
     397                        #if VARIANT != SNZM && VARIANT != SNZI && VARIANT != DISCOVER && VARIANT != BIAS
    420398                                tls.empty.pop.value += num;
    421399                                tls.empty.pop.count += 1;
     
    425403        }
    426404
    427         inline unsigned idx_from_r(unsigned r, bool bias) {
    428                 unsigned i;
    429                 if(bias) {
    430                         if(0 == (r & 0x3F)) {
    431                                 i = r >> 6;
    432                         } else {
    433                                 i = tls.my_queue + ((r >> 6) % 4);
    434                                 tls.pick.push.local++;
    435                         }
    436                 } else {
    437                         i = r;
    438                 }
    439                 return i % numLists;
    440         }
    441405
    442406public:
    443407
    444408        static __attribute__((aligned(128))) thread_local struct TLS {
    445                 Random     rng1 = { unsigned(std::hash<std::thread::id>{}(std::this_thread::get_id()) ^ rdtscl()) };
    446                 Random     rng2 = { unsigned(std::hash<std::thread::id>{}(std::this_thread::get_id()) ^ rdtscl()) };
     409                Random     rng = { int(rdtscl()) };
    447410                unsigned   my_queue = (ticket++) * 4;
    448411                pick_stat  pick;
     
    455418        __attribute__((aligned(64))) std::unique_ptr<intrusive_queue_t<node_t> []> lists;
    456419private:
    457         #if VARIANT == SNZI || VARIANT == BACK
     420        #if VARIANT == SNZI || VARIANT == BIAS
    458421                snzi_t snzi;
    459         #elif VARIANT == BIAS || VARIANT == BACKBIAS
    460                 #ifdef SNZI_PACKED
    461                         snzip_t snzi;
    462                 #else
    463                         snzi_t snzi;
    464                 #endif
    465422        #elif VARIANT == SNZM || VARIANT == DISCOVER
    466423                snzm_t snzm;
Note: See TracChangeset for help on using the changeset viewer.