generator.h

Go to the documentation of this file.

#ifndef FPMAS_RANDOM_GENERATOR_H
#define FPMAS_RANDOM_GENERATOR_H
 
#include <cstdint>
#include <random>
#include <sstream>
#include "fpmas/api/random/generator.h"
#include "fpmas/communication/communication.h"
 
namespace fpmas { namespace random {
 
 
#ifndef DOXYGEN_BUILD
    template<typename> class DistributedGenerator;
#endif
 
    template<typename Generator_t>
        class UniformRandomBitGenerator: public api::random::Generator<typename Generator_t::result_type> {
            protected:
            Generator_t gen;
            
            public:
            using typename api::random::Generator<typename Generator_t::result_type>::result_type;
 
            static constexpr result_type min() {
                return Generator_t::min();
            }
 
            static constexpr result_type max() {
                return Generator_t::max();
            }
 
            result_type operator()() override {
                return gen();
            }
        };
 
    template<typename Generator_t>
        class Generator;
 
    template<typename Gen, class CharT, class Traits>
        std::basic_ostream<CharT, Traits>& operator<<(
                std::basic_ostream<CharT,Traits>& ost, const Generator<Gen>& g ) {
            return ost << g.gen;
        }
 
    template<typename Gen, class CharT, class Traits>
        std::basic_istream<CharT,Traits>&
        operator>>(std::basic_istream<CharT,Traits>& ost, Generator<Gen>& g ) {
            return ost >> g.gen;
        }
 
    template<typename Generator_t>
        class Generator : public UniformRandomBitGenerator<Generator_t> {
 
            public:
                typedef typename UniformRandomBitGenerator<Generator_t>::result_type
                    result_type;
 
                Generator() {}
                Generator(result_type seed) {
                    this->seed(seed);
                }
 
 
                void seed(result_type seed) override {
                    this->gen.seed(seed);
                }
 
                void discard(unsigned long long z) override {
                    this->gen.discard(z);
                }
 
                bool operator==(const Generator<Generator_t>& g) const {
                    return this->gen == g.gen;
                };
 
                bool operator!=(const Generator<Generator_t>& g) const {
                    return this->gen != g.gen;
                };
 
                template<typename Gen, class CharT, class Traits>
                    friend std::basic_ostream<CharT,Traits>&
                    operator<<(std::basic_ostream<CharT,Traits>& ost, const Generator<Gen>& g );
 
                template<typename Gen, class CharT, class Traits>
                    friend std::basic_istream<CharT,Traits>&
                    operator>>(std::basic_istream<CharT,Traits>& ost, Generator<Gen>& g );
        };
 
    template<class CharT, class Traits>
        std::basic_ostream<CharT, Traits>& operator<<(
                std::basic_ostream<CharT,Traits>& ost, const Generator<std::random_device>&) {
            return ost;
        }
 
    template<class CharT, class Traits>
        std::basic_istream<CharT,Traits>&
        operator>>(std::basic_istream<CharT,Traits>& ost, Generator<std::random_device>& ) {
            return ost;
        }
 
    template<>
        class Generator<std::random_device> : public UniformRandomBitGenerator<std::random_device> {
            public:
                Generator() {
                }
                Generator(std::random_device::result_type) {
                }
 
                Generator(const Generator<std::random_device>&) {
                }
 
                Generator(Generator<std::random_device>&&) {
                }
 
                Generator<std::random_device>& operator=(const Generator<std::random_device>&) {
                    return *this;
                }
 
                Generator<std::random_device>& operator=(Generator<std::random_device>&&) {
                    return *this;
                }
 
                void seed(std::random_device::result_type) override {
                }
 
                void discard(unsigned long long) override {
                }
 
                template<typename Gen, class CharT, class Traits>
                    friend std::basic_ostream<CharT,Traits>&
                    operator<<(std::basic_ostream<CharT,Traits>& ost, const Generator<Gen>& g );
 
                template<typename Gen, class CharT, class Traits>
                    friend std::basic_istream<CharT,Traits>&
                    operator>>(std::basic_istream<CharT,Traits>& ost, Generator<Gen>& g );
 
        };
 
    typedef Generator<std::mt19937> mt19937;
    typedef Generator<std::mt19937_64> mt19937_64;
    typedef Generator<std::minstd_rand> minstd_rand;
    typedef Generator<std::random_device> random_device;
 
    template<typename Generator_t = mt19937_64>
        class DistributedGenerator : public api::random::Generator<typename Generator_t::result_type> {
            private:
                api::communication::MpiCommunicator* comm;
                Generator_t local_generator;
                std::mt19937 seeder;
 
                bool _init = false;
                void init() {
                    int rank = comm->getRank();
                    int size = comm->getSize();
                    std::vector<std::mt19937::result_type> seed_sequence(size);
                    // Generate a different seed for each process, but poorly
                    // distributed
                    seed_sequence[0] = seeder();
                    for(int i = 1; i < size; i++)
                        seed_sequence[i]=seed_sequence[i-1]+1;
                    std::seed_seq gen(seed_sequence.begin(), seed_sequence.end());
                    // Generates an unbiased seed sequence
                    gen.generate(seed_sequence.begin(), seed_sequence.end());
 
                    // Seed for the current process
                    result_type local_seed = seed_sequence[rank];
 
                    // Seeds the local generator with the generated seed
                    local_generator.seed(local_seed);
                    _init = true;
                }
 
            public:
 
                typedef typename Generator_t::result_type result_type;
 
                DistributedGenerator()
                    : comm(&communication::WORLD) {}
 
                DistributedGenerator(api::communication::MpiCommunicator& comm)
                    : comm(&comm) {
                    }
 
                DistributedGenerator(result_type seed)
                    : comm(&communication::WORLD), seeder(seed) {}
 
                DistributedGenerator(
                        api::communication::MpiCommunicator& comm, result_type seed)
                    : comm(&comm), seeder(seed) {}
 
                result_type operator()() override {
                    if(!_init)
                        init();
                    return local_generator();
                }
 
                void seed(result_type seed) override {
                    seeder.seed(seed);
                    _init = false;
                }
 
                void discard(unsigned long long z) override {
                    if(!_init)
                        init();
                    local_generator.discard(z);
                }
 
 
                static constexpr result_type min() {
                    return Generator_t::min();
                }
 
                static constexpr result_type max() {
                    return Generator_t::max();
                }
        };
 
    template<>
        class DistributedGenerator<random_device> : public random_device {
        };
}}
 
namespace nlohmann {
    template<typename Generator_t>
        struct adl_serializer<fpmas::random::Generator<Generator_t>> {
 
            template<typename JsonType>
                static void to_json(JsonType& j, const fpmas::random::Generator<Generator_t>& gen) {
                    std::stringstream str_buf;
                    str_buf << gen;
                    j = str_buf.str();
                }
 
            template<typename JsonType>
                static void from_json(const JsonType& j, fpmas::random::Generator<Generator_t>& gen) {
                    std::stringstream str_buf(j.template get<std::string>());
                    str_buf >> gen;
                }
        };
}
 
namespace fpmas { namespace io { namespace datapack {
    template<typename Generator_t>
        struct Serializer<fpmas::random::Generator<Generator_t>> {
            template<typename PackType>
                static std::size_t size(
                        const PackType& pack,
                        const fpmas::random::Generator<Generator_t>& gen) {
                    std::ostringstream str;
                    str << gen;
                    return pack.size(str.str());
                }
 
            template<typename PackType>
                static void to_datapack(PackType& pack, const fpmas::random::Generator<Generator_t>& gen) {
                    std::ostringstream str;
                    str<<gen;
                    pack.template put(str.str());
                }
 
            template<typename PackType>
                static fpmas::random::Generator<Generator_t> from_datapack(
                        const PackType& pack) {
                    std::istringstream str(pack.template get<std::string>());
                    fpmas::random::Generator<Generator_t> gen;
                    str>>gen;
                    return gen;
                }
        };
}}}
#endif