Changes in / [f4ec4a90:42cd451]


Ignore:
Location:
doc/theses/thierry_delisle_PhD/code
Files:
1 deleted
3 edited

Legend:

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

    rf4ec4a90 r42cd451  
    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;
  • doc/theses/thierry_delisle_PhD/code/snzi.hpp

    rf4ec4a90 r42cd451  
    1414
    1515        void arrive(int idx) {
    16                 idx >>= 2;
    1716                idx %= mask;
    1817                nodes[idx].arrive();
     
    2019
    2120        void depart(int idx) {
    22                 idx >>= 2;
    2321                idx %= mask;
    2422                nodes[idx].depart();
     
    8482                                if( x.cnt == val_t::Half ) {
    8583                                        /* paranoid */ assert(parent);
    86                                         if(undoArr == 2) {
    87                                                 undoArr--;
    88                                         } else {
    89                                                 parent->arrive();
    90                                         }
     84                                        parent->arrive();
    9185                                        if( !value.cas(x, 1, x.ver) ) {
    9286                                                undoArr = undoArr + 1;
     
    157151{
    158152        int width = std::pow(base, depth);
    159         std::cout << "SNZI: " << depth << "x" << width << "(" << mask - 1 << ") " << (sizeof(snzi_t::node) * (root + 1)) << " bytes" << std::endl;
     153        std::cout << "SNZI: " << depth << "x" << width << "(" << mask - 1 << ")" << std::endl;
    160154        for(int i = 0; i < root; i++) {
    161                 std::cout << i << " -> " << (i / base) + width << std::endl;
    162                 nodes[i].parent = &nodes[(i / base) + width];
     155                nodes[i].parent = &nodes[(i / base) + width ];
    163156        }
    164157}
  • doc/theses/thierry_delisle_PhD/code/utils.hpp

    rf4ec4a90 r42cd451  
    3535};
    3636
    37 // class Random {
    38 // private:
    39 //      unsigned int seed;
    40 // public:
    41 //      Random(int seed) {
    42 //              this->seed = seed;
    43 //      }
    44 
    45 //      /** returns pseudorandom x satisfying 0 <= x < n. **/
    46 //      unsigned int next() {
    47 //              seed ^= seed << 6;
    48 //              seed ^= seed >> 21;
    49 //              seed ^= seed << 7;
    50 //              return seed;
    51 //      }
    52 // };
    53 
    54 constexpr uint64_t extendedEuclidY(uint64_t a, uint64_t b);
    55 constexpr uint64_t extendedEuclidX(uint64_t a, uint64_t b){
    56     return (b==0) ? 1 : extendedEuclidY(b, a - b * (a / b));
    57 }
    58 constexpr uint64_t extendedEuclidY(uint64_t a, uint64_t b){
    59     return (b==0) ? 0 : extendedEuclidX(b, a - b * (a / b)) - (a / b) * extendedEuclidY(b, a - b * (a / b));
    60 }
    61 
    6237class Random {
    6338private:
    64         uint64_t x;
    65 
    66         static constexpr const uint64_t M  = 1ul << 48ul;
    67         static constexpr const uint64_t A  = 25214903917;
    68         static constexpr const uint64_t C  = 11;
    69         static constexpr const uint64_t D  = 16;
    70 
     39        unsigned int seed;
    7140public:
    72         static constexpr const uint64_t m  = M;
    73         static constexpr const uint64_t a  = A;
    74         static constexpr const uint64_t c  = C;
    75         static constexpr const uint64_t d  = D;
    76         static constexpr const uint64_t ai = extendedEuclidX(A, M);
    77 public:
    78         Random(unsigned int seed) {
    79                 this->x = seed * a;
     41        Random(int seed) {
     42                this->seed = seed;
    8043        }
    8144
    8245        /** returns pseudorandom x satisfying 0 <= x < n. **/
    8346        unsigned int next() {
    84                 //nextx = (a * x + c) % m;
    85                 x = (A * x + C) & (M - 1);
    86                 return x >> D;
    87         }
    88         unsigned int prev() {
    89                 //prevx = (ainverse * (x - c)) mod m
    90                 unsigned int r = x >> D;
    91                 x = ai * (x - C) & (M - 1);
    92                 return r;
    93         }
    94 
    95         void set_raw_state(uint64_t _x) {
    96                 this->x = _x;
    97         }
    98 
    99         uint64_t get_raw_state() {
    100                 return this->x;
    101         }
     47                seed ^= seed << 6;
     48                seed ^= seed >> 21;
     49                seed ^= seed << 7;
     50                return seed;
     51        }
    10252};
    10353
Note: See TracChangeset for help on using the changeset viewer.