A thread-safe global random number generator using C++ <random> and <mutex>

In a previous post, Sandro showed how to use the C++ <random> header to define a global random number generator (RNG). If at some point the user decides to parallelize their program, they would have to make the global RNG thread-safe. This requires only a small modification.

I have copied Sandro's code and added thread-safety using the C++ (with standard at least c++11) headers <thread> and <mutex>. In the header file thread_safe_random.hpp, the functions RANDOM and Seed are declared.

	#ifndef _RND_HH_
	#define _RND_HH_
	void Seed(int seed);
	double RANDOM();
	#endif

view raw thread_safe_random.hpp hosted with ❤ by GitHub

The C++ file thread_safe_random.cpp defines the functions RANDOM and Seed, and the RNG and uniform distribution as before. Additionally, a mutex my_rng_mutex is defined to guard my_rng. I am using a lock_guard to lock and release the mutex. When one thread of execution calls the function RANDOM, it acquires the mutex. Any other thread that calls RANDOM, has to wait until the mutex is released.

	#include <iostream>
	#include <chrono>
	#include <random> // requires flag --std=c++11 (or higher)
	#include <mutex> // requires flag -pthread
	#include "thread_safe_random.hpp"
	std::mt19937_64 my_rng; // Defines an engine
	std::uniform_real_distribution<double> my_unif_real_dist(0.0, 1.0); // Define distribution
	std::mutex my_rng_mutex; // a mutex to guard my_rng
	// This is the function to call if you want a random number in the interval [0,1)
	double RANDOM() {
	std::lock_guard<std::mutex> lock(my_rng_mutex);
	return my_unif_real_dist(my_rng);
	// mutex is released when lock goes out of scope
	}
	/* Function to seed the random number generator from main file
	* This function again locks the mutex for when a thread decides
	* to re-seed the RNG.
	*/
	void Seed(int seed) {
	std::lock_guard<std::mutex> lock(my_rng_mutex);
	my_rng.seed(seed);
	// mutex is released when lock goes out of scope
	}

view raw thread_safe_random.cpp hosted with ❤ by GitHub

In order to demonstrate thread_safe_random, I created max threads in the main function that use the auxiliary function fetch_random_number to call RANDOM.

	#include <iostream>
	#include <vector>
	#include <thread>
	#include "thread_safe_random.hpp"
	// auxiliary function for the construction of std::thread
	void fetch_random_number(double & x) {
	x = RANDOM();
	}
	int main() {
	int max = 10;
	int my_seed = 235;
	Seed(my_seed);
	// a vector that will contain the threads
	std::vector<std::thread> threads(max);
	// a vector to store the results
	std::vector<double> xs(max);
	// create threads of execution that fetch a random number
	for ( int i = 0; i < max; ++i ) {
	// NB: xs[i] has to be wrapped in std::ref to pass a reference
	threads[i] = std::thread(fetch_random_number, std::ref(xs[i]));
	}
	// synchonize and print the results
	for ( int i = 0; i < max; ++i ) {
	threads[i].join();
	// when join() returns, xs[i] contains a fresh random number
	std::cout << xs[i] << std::endl;
	}
	return 0;
	}

view raw main.cpp hosted with ❤ by GitHub

The result should look like

$ g++ --std=c++11 -pthread main.cpp thread_safe_random.cpp -o test_safe_random
$ ./test_safe_random
0.284779
0.243487
0.161906
0.338338
0.235765
0.502853
0.389262
0.165401
0.244871
0.194046

However, the order of these numbers can change each time you execute the program. This means that the program is no longer deterministic (although we can argue about what it means to be deterministic or not), because the OS determines the order in which the threads call RANDOM. Another problem with this implementation is that it will be slow when each thread needs many random numbers.

Copying polymorphic C++ objects using an inherited dup() method

In order to copy polymorphic objects in C++, it can be convenient to equip the base and derived classes with a .dup() method (or .clone() method) that returns a pointer to a copy of the (derived) object. When you have a large amount of different derived classes, overriding the base class's .dup() method for each of them can be a bit of a nuisance. In order to solve this, I sometimes use an "intermediate" class template that can be inherited instead of the base class to provide the .dup() method. This solution is not perfect, because it does not provide the possibility of covariant return types.

The class template Cloneable is defined as follows:

	#ifndef CLONEABLE_HPP_
	#define CLONEABLE_HPP_
	/* a class template that can be inherited by a Derived class
	* in stead of the Base class, such that the Derived class
	* automatically implements the correct dup() method
	*/
	template<class Base, class Derived>
	class Cloneable : public Base {
	public:
	virtual ~Cloneable() { /* empty */ }
	virtual Base* dup() const override {
	return new Derived(*static_cast<const Derived*>(this));
	}
	};
	#endif

view raw cloneable.hpp hosted with ❤ by GitHub

In the following code snippet, the use of the Cloneable is demonstrated:

	/* Example demonstrating the Cloneable class template,
	* which is defined in cloneable.hpp
	* compile this file with e.g.:
	* g++ --std=c++11 example.cpp -o example
	*/
	#include <iostream>
	#include <list>
	#include <cmath>
	#include "cloneable.hpp"
	// an abstract base class for a binary operation
	class BinaryOp {
	public:
	virtual ~BinaryOp() { /* empty */ }
	// a binary operation implements operator() taking 2 arguments
	virtual double operator()(double x, double y) const = 0;
	// the base class MUST declare the dup() method
	virtual BinaryOp* dup() const = 0;
	};
	// some binary operations that (indirectly) inherit BinaryOp
	class Sum : public Cloneable<BinaryOp, Sum> {
	public:
	double operator()(double x, double y) const override {
	return x + y;
	}
	};
	class Product : public Cloneable<BinaryOp, Product> {
	public:
	double operator()(double x, double y) const override {
	return x * y;
	}
	};
	class Hypotenuse : public Cloneable<BinaryOp, Hypotenuse> {
	public:
	double operator()(double x, double y) const override {
	return sqrt(x*x + y*y); // or use the hypot function from <cmath>
	}
	};
	int main() {
	// make a list with 3 binary operations
	std::list<BinaryOp*> ops = {new Sum, new Product, new Hypotenuse};
	// define some arbitrary x and y
	double x = 3; double y = 4;
	// evaluate the binary operations
	for ( auto op : ops ) {
	std::cout << (*op)(x, y) << std::endl;
	}
	// make a copy of the obs list using the dup method
	std::list<BinaryOp*> ops_copy;
	for ( auto op : ops ) {
	ops_copy.push_back(op->dup());
	}
	// evaluate the copied operations
	for ( auto op : ops_copy ) {
	std::cout << (*op)(x, y) << std::endl;
	}
	// clean up memory
	for ( auto op : ops ) delete op;
	for ( auto op : ops_copy ) delete op;
	return 0;
	}

view raw example.cpp hosted with ❤ by GitHub

If someone has a better way to do this, let me know.