Deployment of `sitmo` within C++ Code
2023-11-14
Source:vignettes/sitmo_internals.Rmd
sitmo_internals.Rmd
Within this vignette, details on how to use sitmo’s header will be
detailed. First, the background on sitmo
will be provided.
Secondly, function calls will be shown alongside of a description.
Thirdly, examples will be provided of how one can use the
sitmo
header.
What is sitmo
and can I eat it?
sitmo
is the consultancy agency founded by Thijs van den
Berg. They first released a Parallel Psuedo Random Number Generator
(PPRNG) under the same name using work in Salmon, K., et al.’s “Parallel
Random Numbers: As Easy as 1, 2, 3” in the conference proceedings of the
2011 International Conference for High Performance Computing,
Networking, Storage and Analysis. Support for sitmo
exists
for both C++ standards: C++98 and C++11. Furthermore, there are many
different PPRNGs that are available: trng, SPRNG, RngStreams,
OMPRNG. However, none are as appealing in my eyes than sitmo, which provides a
straight forward interface to generating psuedo-random numbers (RNG),
the least restrictive license (MIT), and speed.
Over the span of the last few years, the sitmo
agency
has released two other engines of interest for C++11:
threefry
and vandercorput
. The
threefry
engine is a rewritten PPRNG version of
sitmo
for C++11 whereas the vandercorput
engine provides one dimensional low-discrepancy sequencing. The latter
engines are also available under the MIT license.
Accessing and using engines in sitmo
The header files for sitmo
, threefry
, and
vandercorput
engines are contained within this package. To
use one of these engine header files within your own package, you can
link to the sitmo
package within your description file.
e.g.
LinkingTo: Rcpp, sitmo
Imports:
Rcpp (>= 0.12.11)
To use C++11’s statistical distributions, you may
want to add the following to your src/Makevars
and
src/Makevars.win
file:
CXX_STD = CXX11
Within a C++
file in src/
, then add:
#include <Rcpp.h>
#include <sitmo.h> // SITMO for C++98 & C++11 PPRNG
#include <threefry.h> // THREEFRY C++11-only PPRNG
#include <vandercorput> // VANDERCORPUT C++11-only Low-discrepancy sequence
You do not need to add each header file. Pick and choose the appropriate engine for your needs.
Or you can do a direct embed in your application. I would advise for the prior though and, hence, the reason for this package.
Below is a breakdown of functions that are available for the engines.
Please note, that the engine predominantly highlight is the original:
sitmo::prng
.
Construct an engine
Expression | Description |
---|---|
prng() | Creates an engine with a default initial state. |
prng(prng& x) | Creates an engine with the same initial state as the engine x. |
prng(uint32_t s) | Creates an engine with initial state determined by s. Engines created with different initial states have the guarantee to generate independent non-overlapping random sequences of length \(2^128\). |
prng(SeedSeq q) | Creates an engine with an initial state that depends on a sequence produced by one call to q.generate. |
Seed modifiers
To use the seed modifiers, one must first construct an engine using a method detailed in the previous table.
// Generate engine called eng_org.
::prng eng_org;
sitmo
// Generate engine called eng_org.
::threefry eng_tf;
sitmo
// Generate engine called eng_vc.
::vandercorput eng_vc; sitmo
From there, the engine state can be modified using:
Expression | Description |
---|---|
e.seed() | Returns the random engine to the default state. The same prng(). |
e.seed(uint32_t s) | Set the engine to a state determined by s. Same as prng(uint32_t s) |
e.seed(SeedSeq q) | Set the engine to a state that depends on a sequence produced by one call to q.generate. Same as prng(SeedSeq q) |
e() | Advances the internal state and returns a 32 bit random number. |
e.discard(uint64_t n) | Advances the internal state with n steps in constant time. |
Misc Seed
Using the same engine created above, one can access additional state information using the following:
Expression | Description |
---|---|
e1 == e2 | Test for equivalence of two prng’s. Two engines are the same if they generate the exact same random sequence. |
e1 != e2 | Test for non-equivalence of two prng’s. Two engines are different if they generate different random sequences. |
e.version() | The current version of the engine, returns the value 2 |
Examples
The examples displayed in the vignette are taken directly from the
project’s src
directory that is found here https://github.com/coatless/sitmo.
Additional commentary is added.
Hello World Example
Below is the most rudimentary example using sitmo
. It
describes the process of creating a sitmo
engine and
obtaining a draw.
#include <Rcpp.h>
#include <sitmo.h> // SITMO PPRNG
// [[Rcpp::depends(sitmo)]]
//' Example RNG Draws with sitmo
//'
//' Shows a basic setup and use case for sitmo.
//'
//' @param n A \code{unsigned int} is a .
//' @return A \code{vec} with random sequences.
//' @examples
//' n = 10
//' sitmo_draws(n)
// [[Rcpp::export]]
::NumericVector sitmo_draws(unsigned int n) {
Rcpp
::NumericVector o(n);
Rcpp
// Create a prng engine
::prng eng;
sitmo
// Draw from base engine
for (unsigned int i=0; i< n ; ++i){
(i) = eng();
o}
return o;
}
Setting a Seed
Here the ability for a seed to be set is used.
#include <Rcpp.h>
#include <sitmo.h> // SITMO PPRNG
// [[Rcpp::depends(sitmo)]]
//' Example Seed Set and RNG Draws with sitmo
//'
//' Shows how to set a seed in sitmo.
//'
//' @param n An \code{unsigned int} that dictates how many realizations occur.
//' @param seed An \code{unsigned int} that controls the rng seed.
//' @return A \code{vector} with random sequences.
//' @examples
//' n = 10
//' a = sitmo_engine_seed(n, 1337)
//' b = sitmo_engine_seed(n, 1337)
//' c = sitmo_engine_seed(n, 1338)
//'
//' isTRUE(all.equal(a,b))
//' isTRUE(all.equal(a,c))
// [[Rcpp::export]]
::NumericVector sitmo_engine_seed(unsigned int n, unsigned int seed) {
Rcpp
// Create Rcpp Matrix
::NumericVector o(n);
Rcpp
// Create a prng engine with a specific seed
::prng eng(static_cast<uint32_t>(seed));
sitmo
// Draw from base engine
for (unsigned int i=0; i < n; ++i){
(i) = eng();
o}
return o;
}
Reset RNG engine
The code used here can be found to work when the initial state of the engine needs to be reverted.
#include <Rcpp.h>
#include <sitmo.h> // SITMO PPRNG
// [[Rcpp::depends(sitmo)]]
//' Example Seed Set and RNG Draws with sitmo
//'
//' Shows how to set a seed in sitmo.
//'
//' @param n An \code{unsigned int} that dictates how many realizations occur.
//' @param seed An \code{unsigned int} that controls the rng seed.
//' @return A \code{matrix} with random sequences.
//' @examples
//' n = 10
//' a = sitmo_engine_seed(n, 1337)
//'
//' isTRUE(all.equal(a[,1],a[,2]))
// [[Rcpp::export]]
::NumericMatrix sitmo_engine_reset(unsigned int n, unsigned int seed) {
Rcpp
// Create Rcpp Vector
::NumericMatrix o(n,2);
Rcpp
// Create a prng engine with a specific seed
::prng eng(static_cast<uint32_t>(seed));
sitmo
// Draw from base engine
for (unsigned int i=0; i < n ; ++i){
(i,0) = eng();
o}
// Reset seed
.seed();
eng
// Draw from base engine
for (unsigned int i=0; i< n ; ++i){
(i,1) = eng();
o}
return o;
}
Two RNG Streams
This example displays the ability of sitmo
to handle
parallel streams of rng when a predefined number of streams is
known.
#include <Rcpp.h>
#include <sitmo.h> // SITMO PPRNG
// [[Rcpp::depends(sitmo)]]
//' Two RNG engines running side-by-side
//'
//' Shows how to create two separate RNGs and increase them together.
//'
//' @param n An \code{unsigned int} that dictates how many realizations occur.
//' @param seeds A \code{vec} containing two integers greater than 0.
//' @return A \code{matrix} with random sequences.
//' @examples
//' n = 10
//' a = sitmo_two_seeds(n, c(1337,1338))
//'
//' b = sitmo_two_seeds(n, c(1337,1337))
//'
//' isTRUE(all.equal(a[,1],a[,2]))
//'
//' isTRUE(all.equal(b[,1],b[,2]))
//'
//' isTRUE(all.equal(a[,1],b[,1]))
// [[Rcpp::export]]
::NumericMatrix sitmo_two_seeds(unsigned int n, Rcpp::NumericVector seeds) {
Rcpp
if(seeds.size() != 2) Rcpp::stop("Need exactly two seeds for this example.");
// Create Rcpp Matrix
::NumericMatrix o(n,2);
Rcpp
// Create a prng engine with a specific seed
::prng eng1;
sitmo.seed(seeds(0));
eng1
::prng eng2;
sitmo.seed(seeds(1));
eng2
// Draw from base engine
for (unsigned int i=0; i< n ; ++i){
(i,0) = eng1();
o(i,1) = eng2();
o}
return o;
}
Uniform Random Number Generator
Under C++98, one does not have access to the C++11 implementation of the Uniform distribution. This is particularly problematic as a lot of the distribution RNG rely upon being able to sample from \(\left[0,1\right]\) ala the Probability Integral Transformation Theorem. Additional details are discussed in a separate vignette (“Making a Uniform PRNG with sitmo”).
#include <Rcpp.h>
#include <sitmo.h> // SITMO PPRNG
// [[Rcpp::depends(sitmo)]]
//' Random Uniform Number Generator with sitmo
//'
//' The function provides an implementation of sampling from a random uniform distribution
//'
//' @param n An \code{unsigned integer} denoting the number of realizations to generate.
//' @param min A \code{double} indicating the minimum \eqn{a} value
//' in the uniform's interval \eqn{\left[a,b\right]}
//' @param max A \code{double} indicating the maximum \eqn{b} value
//' in the uniform's interval \eqn{\left[a,b\right]}
//' @param seed A special \code{unsigned integer} containing a single seed.
//' @return A \code{vec} containing the realizations.
//' @export
//' @examples
//' a = runif_sitmo(10)
// [[Rcpp::export]]
::NumericVector runif_sitmo(unsigned int n, double min = 0.0, double max = 1.0, uint32_t seed = 1) {
Rcpp::NumericVector o(n);
Rcpp
// Create a prng engine
::prng eng(seed);
sitmo// Obtain the range between max and min
double dis = max - min;
for(int i = 0; i < n; ++i) {
// Sample from the RNG and divide it by the maximum value possible (can also use SITMO_RAND_MAX, which is 4294967295)
// Apply appropriate scale (MAX-MIN)
[i] = min + ((double) eng() / (sitmo::prng::max())) * (dis);
o}
return o;
}
OpenMP Example
One of the primary reasons why sitmo
is desirable is
because it can be used under parallelization via OpenMP and MPI. Below
is an example where it is used in a parallel setting to generate
numbers. Note, to ensure that code works cross-platform, please protect
against OpenMP includes as the package will otherwise fail on OS X.
To protect against a lack of OpenMP headers use:
#ifdef _OPENMP
#include <omp.h>
#endif
When writing sections of parallelized code, also protect that code using:
#ifdef _OPENMP
// multithreaded OpenMP version of code
#else
// single-threaded version of code
#endif
Furthermore, add the following to your Makevars
and
Makevars.win
:
PKG_LIBS = $(LAPACK_LIBS) $(BLAS_LIBS) $(FLIBS) $(SHLIB_OPENMP_CFLAGS) PKG_CFLAGS = $(SHLIB_OPENMP_CFLAGS)
With this being said, let’s take a look at an example parallelization
using sitmo
:
#include <Rcpp.h>
#include <sitmo.h> // SITMO PPRNG
// [[Rcpp::depends(sitmo)]]
#ifdef _OPENMP
#include <omp.h>
#endif
// [[Rcpp::plugins(openmp)]]
//' Test Generation using sitmo and C++11
//'
//' The function provides an implementation of creating realizations from the default engine.
//'
//' @param n An \code{unsigned integer} denoting the number of realizations to generate.
//' @param seeds A \code{vec} containing a list of seeds. Each seed is run on its own core.
//' @return A \code{vec} containing the realizations.
//' @details
//' The following function's true power is only accessible on platforms that support OpenMP (e.g. Windows and Linux).
//' However, it does provide a very good example as to how to make ones code applicable across multiple platforms.
//'
//' With this being said, how we determine how many cores to split the generation to is governed by the number of seeds supplied.
//' In the event that one is using OS X, only the first seed supplied is used.
//'
//' @export
//' @examples
//' a = sitmo_parallel(10, 5.0, c(1))
//'
//' b = sitmo_parallel(10, 5.0, c(1))
//'
//' c = sitmo_parallel(10, 5.0, c(2))
//'
//' isTRUE(all.equal(a,b))
//'
//' isTRUE(all.equal(a,c))
// [[Rcpp::export]]
::NumericVector sitmo_parallel(unsigned int n, Rcpp::NumericVector& seeds){
Rcpp
unsigned int ncores = seeds.size();
::NumericVector q(n);
Rcpp
#ifdef _OPENMP
#pragma omp parallel num_threads(ncores) if(ncores > 1)
{
#endif
// Engine requires uint32_t inplace of unsigned int
uint32_t active_seed;
// Write the active seed per core or just write one of the seeds.
#ifdef _OPENMP
= static_cast<uint32_t>(seeds[omp_get_thread_num()]);
active_seed #else
= static_cast<uint32_t>(seeds[0]);
active_seed #endif
::prng eng( active_seed );
sitmo
// Parallelize the Loop
#ifdef _OPENMP
#pragma omp for schedule(static)
#endif
for (unsigned int i = 0; i < n; i++){
[i] = eng().
q}
#ifdef _OPENMP
}
#endif
return q;
}