Rng.h

Go to the documentation of this file.

#pragma once 

#include <thread>
#include <mutex>

#include <sys/syscall.h>
#include <sys/random.h>

thread_local class Rng : public std::mt19937 {
public:

    // The first of these that is made is called the "base" and is used to seed any others.
    // Because this variable rng is thread_local, each thread will get its own and its seed
    // will be determined (deterministically) from base. 
    static std::mutex mymut; 
    static Rng* base; 

    Rng() : std::mt19937() {
        
        // allow only one constructor at a time since we need to set the base seed
        std::lock_guard guard(mymut);
        
        if(base == nullptr) {
            // on construction we initialize from /dev/urandom
            std::array<unsigned long, std::mt19937::state_size> state;
            sysrandom(state.begin(), state.size()*sizeof(unsigned long));
            std::seed_seq seedseq(state.begin(), state.end());
            this->std::mt19937::seed(seedseq);
            
            base = this;
        }
        else {
            randomize();
        }
    }
    
    void randomize() {
        // seed from base with random numbers.
        // This will get us replicable numbers assuming the 
        // order of construction is fixed
        std::array<unsigned long, std::mt19937::state_size> state;
        for(size_t i=0;i<state.size();i++){
            state[i] = base->operator()();
        }
        std::seed_seq seedseq(state.begin(), state.end());
        this->std::mt19937::seed(seedseq);
    }
    
     void seed(unsigned long s) {
         if(s != 0) {
             this->std::mt19937::seed(s);
         }
     }
     
    static size_t sysrandom(void* dst, size_t dstlen) {
        // from https://stackoverflow.com/questions/45069219/how-to-succinctly-portably-and-thoroughly-seed-the-mt19937-prng
        char* buffer = reinterpret_cast<char*>(dst);
        std::ifstream stream("/dev/urandom", std::ios_base::binary | std::ios_base::in);
        stream.read(buffer, dstlen);
        return dstlen;
    }

    
} DefaultRNG;

std::mutex Rng::mymut;
Rng* Rng::base = nullptr;