pm_distUnif::xoshiro256ss_type Type Reference

This is the abstract base derived type for defining variants of Xoshiro256** Uniform Random Number Generator derived types.
More...

Inheritance diagram for pm_distUnif::xoshiro256ss_type:

Collaboration diagram for pm_distUnif::xoshiro256ss_type:

Public Attributes
integer(IK64), dimension(xoshiro256ssStateSize)	state = [ -5952639272145821898_IK64 , -2790978430781836137_IK64 , -4872796757339724681_IK64 , -6638731986642513151_IK64 ]
	The vector of size xoshiro256ssStateSize of type integer of kind IK64, containing the most recent RNG state. More...
integer(IK64)	stream
	The scalar of type integer of kind IK64, containing the most recently generated random 64-bit stream. More...

Detailed Description

This is the abstract base derived type for defining variants of Xoshiro256** Uniform Random Number Generator derived types.

See also

rngu_type
splitmix64_type
xoshiro256ssg_type
xoshiro256ssw_type
getUnifRandStateSize

Benchmarks:

Benchmark :: The runtime performance of intrinsic random_number() vs. xoshiro256ssg_type vs. xoshiro256ssw_type. ⛓

program benchmark
 
    use pm_kind, only: SK, IK, LK, RKG => RK, IKG => IK, LKG => LK
    use pm_distUnif, only: xoshiro256ssg_type
    use pm_distUnif, only: xoshiro256ssw_type
    use pm_distUnif, only: setUnifRand
    use pm_bench, only: bench_type
 
    implicit none
 
    integer(IK)                         :: i, j, fileUnit
    integer(IK)         , parameter     :: NSIM = 100000_IK
    logical(LKG)                        :: dumm_LK = .false._LKG
    logical(LKG)                        :: rand_LK(NSIM)
    integer(IKG)                        :: rand_IK(NSIM)
    real(RKG)                           :: rand_RK(NSIM)
    type(bench_type)    , allocatable   :: bench(:)
    type(xoshiro256ssg_type)            :: xoshiro256ssg
    type(xoshiro256ssw_type)            :: xoshiro256ssw
    xoshiro256ssg = xoshiro256ssg_type()
    xoshiro256ssw = xoshiro256ssw_type()
 
    bench = [ bench_type(name = SK_"random_number_LK", exec = random_number_LK, overhead = setOverhead_LK) &
            , bench_type(name = SK_"xoshiro256ssg_type_LK", exec = xoshiro256ssg_type_LK, overhead = setOverhead_LK) &
            , bench_type(name = SK_"xoshiro256ssw_type_LK", exec = xoshiro256ssw_type_LK, overhead = setOverhead_LK) &
            , bench_type(name = SK_"random_number_IK", exec = random_number_IK, overhead = setOverhead_LK) &
            , bench_type(name = SK_"xoshiro256ssg_type_IK", exec = xoshiro256ssg_type_IK, overhead = setOverhead_IK) &
            , bench_type(name = SK_"xoshiro256ssw_type_IK", exec = xoshiro256ssw_type_IK, overhead = setOverhead_IK) &
            , bench_type(name = SK_"random_number_RK", exec = random_number_RK, overhead = setOverhead_RK) &
            , bench_type(name = SK_"xoshiro256ssg_type_RK", exec = xoshiro256ssg_type_RK, overhead = setOverhead_RK) &
            , bench_type(name = SK_"xoshiro256ssw_type_RK", exec = xoshiro256ssw_type_RK, overhead = setOverhead_RK) &
            ]
 
    write(*,"(*(g0,:,' '))")
    write(*,"(*(g0,:,' '))") "xoshiro256ssg_type() vs. xoshiro256ssw_type()."
    write(*,"(*(g0,:,' '))")
 
    open(newunit = fileUnit, file = "main.out", status = "replace")
 
        write(fileUnit, "(*(g0,:,','))") (bench(i)%name, i = 1, size(bench))
        do i = 1, size(bench)
            bench(i)%timing = bench(i)%getTiming()
        end do
        do j = 1, minval([(size(bench(i)%timing%values), i = 1, size(bench))])
            write(fileUnit,"(*(g0,:,','))") (bench(i)%timing%values(j) / NSIM, i = 1, size(bench))
        end do
        write(*,"(*(g0,:,' '))")
 
    close(fileUnit)
 
contains
 
    !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    ! procedure wrappers.
    !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
    subroutine setOverhead_LK()
        call getDummy_LK()
    end subroutine
 
    subroutine setOverhead_IK()
        call getDummy_IK()
    end subroutine
 
    subroutine setOverhead_RK()
        call getDummy_RK()
    end subroutine
 
    subroutine getDummy_LK()
        dumm_LK = dumm_LK .or. count(rand_LK) == 0
    end subroutine
 
    subroutine getDummy_IK()
        dumm_LK = dumm_LK .or. any(rand_IK == 0_IKG)
    end subroutine
 
    subroutine getDummy_RK()
        dumm_LK = dumm_LK .or. any(rand_RK == 0._RKG)
    end subroutine
 
    subroutine random_number_LK()
        call setUnifRand(rand_LK)
        !block
        !    real :: rand
        !    call random_number(rand)
        !    rand_LK = logical(rand < 0.5, LKG)
        !    call getDummy_LK()
        !end block
    end subroutine
 
    subroutine xoshiro256ssg_type_LK()
        call setUnifRand(xoshiro256ssg, rand_LK)
        call getDummy_LK()
    end subroutine
 
    subroutine xoshiro256ssw_type_LK()
        call setUnifRand(xoshiro256ssw, rand_LK)
        call getDummy_LK()
    end subroutine
 
 
    subroutine random_number_IK()
        call setUnifRand(rand_IK)
        call getDummy_IK()
    end subroutine
 
    subroutine xoshiro256ssg_type_IK()
        call setUnifRand(xoshiro256ssg, rand_IK)
        call getDummy_IK()
    end subroutine
 
    subroutine xoshiro256ssw_type_IK()
        call setUnifRand(xoshiro256ssw, rand_IK)
        call getDummy_IK()
    end subroutine
 
 
    subroutine random_number_RK()
        call setUnifRand(rand_RK)
        call getDummy_RK()
    end subroutine
 
    subroutine xoshiro256ssg_type_RK()
        call setUnifRand(xoshiro256ssg, rand_RK)
        call getDummy_RK()
    end subroutine
 
    subroutine xoshiro256ssw_type_RK()
        call setUnifRand(xoshiro256ssw, rand_RK)
        call getDummy_RK()
    end subroutine
 
end program benchmark

Example Unix compile command via Intel ifort compiler ⛓

#!/usr/bin/env sh
rm main.exe
ifort -fpp -standard-semantics -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe
./main.exe

Example Windows Batch compile command via Intel ifort compiler ⛓

del main.exe
set PATH=..\..\..\lib;%PATH%
ifort /fpp /standard-semantics /O3 /I:..\..\..\include main.F90 ..\..\..\lib\libparamonte*.lib /exe:main.exe
main.exe

Example Unix / MinGW compile command via GNU gfortran compiler ⛓

#!/usr/bin/env sh
rm main.exe
gfortran -cpp -ffree-line-length-none -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe
./main.exe

Postprocessing of the benchmark output ⛓

#!/usr/bin/env python
 
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
 
import os
dirname = os.path.basename(os.getcwd()) 
 
fontsize = 14
 
df = pd.read_csv("main.out", delimiter = ",")
colnames = list(df.columns.values)
 
df = pd.read_csv("main.out")
 
 
 
ax = plt.figure(figsize = 1.25 * np.array([6.4,4.6]), dpi = 200)
ax = plt.subplot()
 
for colname in colnames:
    plt.hist( np.log10(df[colname].values)
            , histtype = "stepfilled"
           #, density = True
            , alpha = 0.7
           #, bins = 30
            )
 
plt.xticks(fontsize = fontsize)
plt.yticks(fontsize = fontsize)
ax.set_xlabel("$\log_{10}$ ( Runtime [ seconds ] )", fontsize = fontsize)
ax.set_ylabel("Count", fontsize = fontsize)
#ax.set_title(" vs. ".join(colnames[1:])+"\nLower is better.", fontsize = fontsize)
#ax.set_xscale("log")
#ax.set_yscale("log")
plt.minorticks_on()
plt.grid(visible = True, which = "both", axis = "both", color = "0.85", linestyle = "-")
ax.tick_params(axis = "y", which = "minor")
ax.tick_params(axis = "x", which = "minor")
ax.legend   ( colnames
           #, loc='center left'
           #, bbox_to_anchor=(1, 0.5)
            , fontsize = fontsize
            )
 
plt.tight_layout()
plt.savefig("benchmark." + dirname + ".runtime.png")
 
 
 
ax = plt.figure(figsize = 1.25 * np.array([6.4,4.6]), dpi = 200)
ax = plt.subplot()
 
for colname in colnames[0:]:
    plt.hist( np.log10(df[colname].values / df[colnames[0]].values)
            , histtype = "stepfilled"
           #, density = True
            , alpha = 0.7
           #, bins = 30
            )
ax.legend   ( colnames[1:]
           #, loc='center left'
           #, bbox_to_anchor=(1, 0.5)
            , fontsize = fontsize
            )
 
plt.xticks(fontsize = fontsize)
plt.yticks(fontsize = fontsize)
ax.set_title("Runtime Ratio Comparison. Lower means faster.\nLower than 1 means faster than {}().".format(colnames[0]), fontsize = fontsize)
ax.set_xlabel(r"$\log_{{10}}$ ( Runtime Ratio ) w.r.t. {}".format(colnames[0]), fontsize = fontsize)
ax.set_ylabel("Count", fontsize = fontsize)
plt.minorticks_on()
plt.grid(visible = True, which = "both", axis = "both", color = "0.85", linestyle = "-")
ax.tick_params(axis = "y", which = "minor")
ax.tick_params(axis = "x", which = "minor")
 
plt.tight_layout()
plt.savefig("benchmark." + dirname + ".runtime.ratio.png")

Visualization of the benchmark output ⛓

Benchmark moral ⛓

1. The xoshiro256ssg_type RNG greedily attempts to use as many randomly generated bits as possible in the output random values.
   
2. The xoshiro256ssw_type RNG takes a wasteful approach of using at least one or more chunks of 64 randomly generated bits in the output random values.
   
3. This fundamental difference between the two RNG types generally leads to faster random logical value generations with the greedy approach, because 64bits chunks translate to 64 logical values without updating the RNG state.
   
4. However, the greedy approach leads to generally slower runtimes for real random value generation.
   
5. Both greedy and wasteful RNGs appear to be much faster than the ParaMonte library wrappers for the implementations offered by GNU Fortran Compiler gfortran and Intel Classic Fortran Compiler ifort.
   
6. Moral: If your application requires many logical random number generations, use the greedy xoshiro256ssg_type RNG. Conversely, if your application requires a mixture of random number generations of various types and kinds, use the wasteful xoshiro256ssw_type RNG.

Test:

test_pm_distUnif

Final Remarks ⛓

---

If you believe this algorithm or its documentation can be improved, we appreciate your contribution and help to edit this page's documentation and source file on GitHub.
For details on the naming abbreviations, see this page.
For details on the naming conventions, see this page.
This software is distributed under the MIT license with additional terms outlined below.

1. If you use any parts or concepts from this library to any extent, please acknowledge the usage by citing the relevant publications of the ParaMonte library.
   
2. If you regenerate any parts/ideas from this library in a programming environment other than those currently supported by this ParaMonte library (i.e., other than C, C++, Fortran, MATLAB, Python, R), please also ask the end users to cite this original ParaMonte library.
   

This software is available to the public under a highly permissive license.
Help us justify its continued development and maintenance by acknowledging its benefit to society, distributing it, and contributing to it.

Copyright

Computational Data Science Lab

Author:

Fatemeh Bagheri, Wednesday 12:20 AM, October 13, 2021, Dallas, TX

Definition at line 2984 of file pm_distUnif.F90.

Member Data Documentation

state

integer(IK64), dimension(xoshiro256ssStateSize) pm_distUnif::xoshiro256ss_type::state = [ -5952639272145821898_IK64 , -2790978430781836137_IK64 , -4872796757339724681_IK64 , -6638731986642513151_IK64 ]

The vector of size xoshiro256ssStateSize of type integer of kind IK64, containing the most recent RNG state.

Definition at line 2988 of file pm_distUnif.F90.

stream

integer(IK64) pm_distUnif::xoshiro256ss_type::stream

The scalar of type integer of kind IK64, containing the most recently generated random 64-bit stream.

Definition at line 2994 of file pm_distUnif.F90.

---

The documentation for this type was generated from the following file:

• src/fortran/main/pm_distUnif.F90