GlobalPRNG.h

// (c) Copyright 2022 CERN for the benefit of the LHCb Collaboration.
//
// This software is distributed under the terms of the GNU General Public
// Licence version 3 (GPL Version 3), copied verbatim in the file "LICENCE".
//
// In applying this licence, CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#pragma once
 
#include <unordered_map>
#include <algorithm>
#include <random>
#include <memory>
#include <iostream>
#include <mutex>
 
#include "sqlite3.h"
 
namespace SQLamarr
{
  template <class PRNG>
  class T_GlobalPRNG
  {
    public: // static methods
      static constexpr uint64_t no_seed = 0xBAD0000000000000L;
 
 
      static T_GlobalPRNG& handle()
      {
        static T_GlobalPRNG instance;
        return instance;
      }
 
 
      static PRNG* get_or_create (
          const sqlite3_context* db, 
          uint64_t seed = no_seed
          )
      {
        sqlite3_context* db_ = const_cast<sqlite3_context*> (db);
        return get_or_create(sqlite3_context_db_handle(db_), seed);
      }
 
 
      static PRNG* get_or_create (
          const sqlite3* db, 
          uint64_t seed = no_seed
          )
      {
        // Gets the singleton handle
        T_GlobalPRNG& h {T_GlobalPRNG::handle()};
        std::lock_guard<std::mutex>(h.m_mutex); // Forbids multithreading
 
        // Looks for the DB in the hash table
        auto gen_it = h.m_generators.find(db);
 
        // If initialized return it, possibly after re-seeding.
        if (gen_it != h.m_generators.end()) 
        {
          if (seed == no_seed)
            return gen_it->second.get();
 
          // Reseeding
          gen_it->second->seed(static_cast<uint32_t>(0xFFFFFFFFL & seed));
          return gen_it->second.get();
        }
 
        // If it is a new instance:
        //  - if no seed is passed, use random_device for seeding or throw
        if (seed == no_seed)
        {
#ifndef ALLOW_RANDOM_DEVICE_FOR_SEEDING
          std::cerr << "Trying to use unseeded generator. "
            << "Compile with -DALLOW_RANDOM_DEVICE_FOR_SEEDING to ignore."
            << std::endl;
          throw std::logic_error("Random seeding disabled.");
#endif
          std::random_device seeder;
          h.m_generators[db] = std::unique_ptr<PRNG>(new PRNG(seeder()));
          return h.m_generators[db].get();
        }
 
        //  - if a seed is provided, create a new generator
        h.m_generators[db] = std::unique_ptr<PRNG>(new PRNG(
            static_cast<uint32_t>(0xFFFFFFFFL & seed)
            ));
 
        return h.m_generators[db].get();
      }
 
      static bool release (const sqlite3* db)
      {
        T_GlobalPRNG& h {T_GlobalPRNG::handle()};
        std::lock_guard<std::mutex>(h.m_mutex); // Forbids multithreading
 
        auto it = h.m_generators.find(db);
        bool releasing_unexisting = (it == h.m_generators.end());
        h.m_generators.erase(db);
        return releasing_unexisting;
      }
 
 
    private:
      T_GlobalPRNG() {}
 
      std::unordered_map<const sqlite3*, std::unique_ptr<PRNG> > m_generators;
 
      std::mutex m_mutex;
 
    public:
      T_GlobalPRNG(T_GlobalPRNG const&)    = delete;
 
      void operator=(T_GlobalPRNG const&)  = delete;
  };
 
  typedef T_GlobalPRNG<std::ranlux48> GlobalPRNG;
 
  typedef T_GlobalPRNG<std::mt19937> GlobalPRNG_MT;
}