pm_bench::benchBase_type Type Reference

This is the base class for creating low-level benchmark objects. More...

Inheritance diagram for pm_bench::benchBase_type:

Public Attributes
real(RKD)	minsec = 0.05_RKD
	The minimum time in units of seconds that the benchmark should last. It could take longer, but not less than minsec. More...
integer(IK)	miniter = 1_IK
	The minimum number of timing of the user-specified wrapper procedure. It could run more, but not fewer than miniter. More...
type(timing_type)	timing
	The object of type timing_type containing the timing information and statistics of the benchmark. More...
character(:, SK), allocatable	name
	The name of the procedure to be timed. More...
class(timer_type), allocatable	timer
	The allocatable component of abstract class timer_type used for internal timing. Public access to this component provided is provided solely for the convenience of the user when access to a timer is needed. Otherwise, it not meant to be directly accessed or manipulated. The concrete type of this class component is set by the user at runtime depending on their choice of timer. More...

Detailed Description

This is the base class for creating low-level benchmark objects.

See also the constructor of this type.

Possible calling interfaces ⛓

use pm_kind, only: SK, IK, RKD
use pm_bench, only: benchBase_type
use pm_timer, only: timerCPU_type
use pm_timer, only: timerDAT_type
use pm_timer, only: timerMPI_type
use pm_timer, only: timerOMP_type
use pm_timer, only: timerSYS_type
type(benchBase_type) :: benchBase
character(:, SK) :: name
integer(IK) :: miniter
real(RKD) :: minsec
 
benchBase = benchBase_type(name, minsec = minsec, miniter = miniter, timer = timerCPU_type())
benchBase = benchBase_type(name, minsec = minsec, miniter = miniter, timer = timerDAT_type())
benchBase = benchBase_type(name, minsec = minsec, miniter = miniter, timer = timerMPI_type())
benchBase = benchBase_type(name, minsec = minsec, miniter = miniter, timer = timerOMP_type())
benchBase = benchBase_type(name, minsec = minsec, miniter = miniter, timer = timerSYS_type())

Remarks

See benchBase_typer for the non-default constructor of this type.

Note

Although it is possible, this type is not meant to be directly used for benchmarking.
Instead, use the child class bench_type which greatly simplifies benchmarking.

See also

bench_type
benchBase_typer (constructor of the type)
timer_type
timerDAT_type
timerMPI_type
timerOMP_type
timerSYS_type

Example usage ⛓

program example
 
    use pm_kind, only: IK, LK, SK, RKD
    use pm_io, only: display_type
    use pm_bench, only: benchBase_type
    use pm_timer, only: timerCPU_type
    use pm_timer, only: timerDAT_type
    use pm_timer, only: timerSYS_type
 
    implicit none
 
    type(benchBase_type) :: benchBase
    real(RKD)           :: unifrnd
    real(RKD)           :: sumTime = 0._RKD
    real(RKD)           :: sumUnif = 0._RKD
    integer             :: i
 
    type(display_type) :: disp
    disp = display_type(file = "main.out.F90")
 
    call disp%skip()
    call disp%show("benchBase = benchBase_type(name = SK_'random_number')")
                    benchBase = benchBase_type(name = SK_'random_number')
    call showTimerComponents()
    call disp%skip()
 
    call disp%skip()
    call disp%show("allocate(benchBase%timing%values(1000))")
    call disp%show("do i = 1, 1000")
    call disp%show("    benchBase%timer%start = benchBase%timer%time()")
    call disp%show("    call random_number(unifrnd)")
    call disp%show("    benchBase%timing%values(i) = benchBase%timer%time(since = benchBase%timer%start)")
    call disp%show("    sumTime = sumTime + benchBase%timing%values(i)")
    call disp%show("    if (sumTime > benchBase%minsec) exit")
    call disp%show("    sumUnif = sumUnif + unifrnd")
    call disp%show("end do")
                    allocate(benchBase%timing%values(1000))
                    do i = 1, 1000
                        benchBase%timer%start = benchBase%timer%time()
                        call random_number(unifrnd)
                        benchBase%timing%values(i) = benchBase%timer%time(since = benchBase%timer%start)
                        sumTime = sumTime + benchBase%timing%values(i)
                        if (sumTime > benchBase%minsec) exit
                        sumUnif = sumUnif + unifrnd
                    end do
    call disp%show("sum(benchBase%timing%values) / size(benchBase%timing%values)")
    call disp%show( sum(benchBase%timing%values) / size(benchBase%timing%values) )
    call disp%skip()
 
contains
 
    impure subroutine showTimerComponents()
        call disp%show("benchBase%name")
        call disp%show( benchBase%name , deliml = SK_"""" )
        call disp%show("benchBase%minsec")
        call disp%show( benchBase%minsec )
        call disp%show("benchBase%miniter")
        call disp%show( benchBase%miniter )
    end subroutine
 
end program example

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

Example output ⛓

 
benchBase = benchBase_type(name = SK_'random_number')
benchBase%name
"random_number"
benchBase%minsec
+0.50000000000000003E-1
benchBase%miniter
+1
 
 
allocate(benchBase%timing%values(1000))
do i = 1, 1000
    benchBase%timer%start = benchBase%timer%time()
    call random_number(unifrnd)
    benchBase%timing%values(i) = benchBase%timer%time(since = benchBase%timer%start)
    sumTime = sumTime + benchBase%timing%values(i)
    if (sumTime > benchBase%minsec) exit
    sumUnif = sumUnif + unifrnd
end do
sum(benchBase%timing%values) / size(benchBase%timing%values)
+0.29597023967653514E-7
 
 

Test:

test_pm_bench

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:

Amir Shahmoradi, Wednesday 4:13 AM, August 13, 2016, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 200 of file pm_bench.F90.

Member Data Documentation

miniter

integer(IK) pm_bench::benchBase_type::miniter = 1_IK

The minimum number of timing of the user-specified wrapper procedure. It could run more, but not fewer than miniter.

Definition at line 202 of file pm_bench.F90.

minsec

real(RKD) pm_bench::benchBase_type::minsec = 0.05_RKD

The minimum time in units of seconds that the benchmark should last. It could take longer, but not less than minsec.

Definition at line 201 of file pm_bench.F90.

name

character(:, SK), allocatable pm_bench::benchBase_type::name

The name of the procedure to be timed.

Definition at line 204 of file pm_bench.F90.

timer

class(timer_type), allocatable pm_bench::benchBase_type::timer

The allocatable component of abstract class timer_type used for internal timing.
Public access to this component provided is provided solely for the convenience of the user when access to a timer is needed.
Otherwise, it not meant to be directly accessed or manipulated.
The concrete type of this class component is set by the user at runtime depending on their choice of timer.

Definition at line 205 of file pm_bench.F90.

timing

type(timing_type) pm_bench::benchBase_type::timing

The object of type timing_type containing the timing information and statistics of the benchmark.

Definition at line 203 of file pm_bench.F90.

---

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

• src/fortran/main/pm_bench.F90