benchmark Derived Type

type, public :: benchmark

Derived type for benchmarking and performance evaluation.


Inherits

type~~benchmark~~InheritsGraph type~benchmark benchmark type~mark mark type~benchmark->type~mark marks type~mark_co mark_co type~benchmark->type~mark_co marks_co timer timer type~mark_co->timer time

Components

Type Visibility Attributes Name Initial
type(mark_co), public, dimension(:), allocatable :: marks_co[:]

Array of mark_co type for each method being benchmarked in each image
type(mark), public, dimension(:), allocatable :: marks

Array of mark type for each method being benchmarked in all images
character(len=:), public, allocatable :: filename

Filename for storing the benchmark data in all images
character(len=:), public, allocatable :: filename_image

Filename for storing the benchmark data in each image
integer, public :: nloops

Number of loops for each benchmark
integer(kind=ik), public, dimension(:), allocatable :: argi

Integer arguments for benchmarks
real(kind=rk), public, dimension(:), allocatable :: argr

Real arguments for benchmarks
character(len=:), public, allocatable :: timer

Timer object for measuring time
integer, public :: imark

Index of the current benchmark

Type-Bound Procedures

procedure, public :: init

Initialization the benchmark object

  • private impure elemental subroutine init(this, nmarks, title, filename, nloops, timer)

    Author
    Seyed Ali Ghasemi
    License
    BSD 3-Clause License

    Initialize the benchmark object.

    Arguments

    Type IntentOptional Attributes Name
    class(benchmark), intent(inout) :: this

    Benchmark object
    integer, intent(in) :: nmarks

    Number of methods being benchmarked
    character(len=*), intent(in), optional :: title

    Title of the benchmark
    character(len=*), intent(in), optional :: filename

    Filename for storing the benchmark data
    integer, intent(in), optional :: nloops

    Number of loops for each benchmark (default: 10)
    character(len=*), intent(in), optional :: timer

    Timer object for measuring time (default: wall)

procedure, public :: start_benchmark

Start a benchmark

  • private impure subroutine start_benchmark(this, imark, method, description, argi, argr)

    Author
    Seyed Ali Ghasemi
    License
    BSD 3-Clause License

    Start a specific benchmark.

    Arguments

    Type IntentOptional Attributes Name
    class(benchmark), intent(inout) :: this

    Benchmark object
    integer, intent(in) :: imark

    Index of the current method
    character(len=*), intent(in) :: method

    Name of the method being benchmarked
    character(len=*), intent(in), optional :: description

    Description of the method being benchmarked (optional)
    integer(kind=ik), intent(in), optional, dimension(:) :: argi

    Integer arguments for benchmarks (optional)
    real(kind=rk), intent(in), optional, dimension(:) :: argr

    Real arguments for benchmarks (optional)

procedure, public :: stop_benchmark

Stop a benchmark

  • private impure subroutine stop_benchmark(this, flops)

    Author
    Seyed Ali Ghasemi
    License
    BSD 3-Clause License

    Stops the currently active benchmark, calculates performance metrics, and writes the results to the file and terminal.

    Arguments

    Type IntentOptional Attributes Name
    class(benchmark), intent(inout) :: this

    Benchmark object
    procedure(Fun), optional :: flops

    Function to calculate Floating Point Operations Per Second (optional)

procedure, private :: write_benchmark

Write benchmark data to file

  • private impure subroutine write_benchmark(this)

    Author
    Seyed Ali Ghasemi
    License
    BSD 3-Clause License

    Writes the benchmark data to a specified file, including method, speedup, elapsed time, flops, and other details.

    Arguments

    Type IntentOptional Attributes Name
    class(benchmark), intent(inout) :: this

    Benchmark object

procedure, public :: finalize

Finalize the benchmark object

  • private impure elemental subroutine finalize(this)

    Author
    Seyed Ali Ghasemi
    License
    BSD 3-Clause License

    Finalizes the benchmark object by deallocating memory and performs necessary cleanup.

    Arguments

    Type IntentOptional Attributes Name
    class(benchmark), intent(inout) :: this

    Benchmark object to be finalized

Source Code

   type :: benchmark
      !! author: Seyed Ali Ghasemi
      !! Derived type for benchmarking and performance evaluation.
      !!
      type(mark_co), dimension(:), allocatable :: marks_co[:]     !! Array of mark_co type for each method being benchmarked in each image
      type(mark),    dimension(:), allocatable :: marks           !! Array of mark type for each method being benchmarked in all images
      character(:),                allocatable :: filename        !! Filename for storing the benchmark data in all images
      character(:),                allocatable :: filename_image  !! Filename for storing the benchmark data in each image
      integer                                  :: nloops          !! Number of loops for each benchmark
      integer(ik),   dimension(:), allocatable :: argi            !! Integer arguments for benchmarks
      real(rk),      dimension(:), allocatable :: argr            !! Real arguments for benchmarks
      character(:),                allocatable :: timer           !! Timer object for measuring time
      integer                                  :: imark           !! Index of the current benchmark
   contains
      procedure          :: init             !! Initialization the benchmark object
      procedure          :: start_benchmark  !! Start a benchmark
      procedure          :: stop_benchmark   !! Stop a benchmark
      procedure, private :: write_benchmark  !! Write benchmark data to file
      procedure          :: finalize         !! Finalize the benchmark object
   end type benchmark