timer.f90

Go to the documentation of this file.

!----------------------------------------------------------------------------------------
!
! This file is part of f2k.
!
! Copyright (C) 2016-2017 by the f2k authors
!
! The f2k code is free software;
! You can use it, redistribute it, and/or modify it under the terms
! of the GNU General Public License as published by the Free Software Foundation;
! either version 3 of the License, or (at your option) any later version.
! The full text of the license can be found in the file LICENSE at
! the top level of the f2k distribution.
!
!----------------------------------------------------------------------------------------


!----------------------------------------------------------------------------------------


module f2k_timer

    implicit none

    private

    !----------------------------------------------------------------------------------------
    ! Internal definitions:

    integer, private, parameter :: allocated_num_loops = 50 ! number of elements to allocate temporarily arrays. If length exceeds this number then another chunk of this length is allocated.

    !----------------------------------------------------------------------------------------
    type :: timer

        real    ( kind=8 ), public :: start_time
        real    ( kind=8 ), public :: end_time

        integer ( kind=4 ), public :: number_loops

        real    ( kind=8 ), public, allocatable, dimension(:) :: loop_times

        real    ( kind=8 ), private :: internal_start_time
        real    ( kind=8 ), private :: internal_end_time

    contains

        procedure, public :: start        => timer_start    
        procedure, public :: stop         => timer_stop     
        procedure, public :: loop         => timer_loop     
        procedure, public :: average      => timer_average  
        procedure, public :: variance     => timer_variance 
        procedure, public :: elapsed_time => timer_elapsed  
        procedure, public :: reset        => timer_reset    
        procedure, public :: wait         => timer_wait     
        procedure, public :: time         => timer_time     

    end type timer

    !----------------------------------------------------------------------------------------
    ! public definitions:
    public :: timer

    !----------------------------------------------------------------------------------------

contains

    ! ---------------------------------------------------------------------------------------------
    subroutine timer_start( self )

        implicit none

        class( timer ) :: self

        ! first reset the timer:
        call self%reset()
        ! then start the timer:
        self%start_time = self%time()

    end subroutine timer_start

    ! ---------------------------------------------------------------------------------------------
    subroutine timer_stop( self )

        implicit none

        class( timer ) :: self

        ! stop the timer:
        self%end_time = self%time()

    end subroutine timer_stop

    ! ---------------------------------------------------------------------------------------------
    subroutine timer_loop( self )

        implicit none

        class( timer ) :: self

        integer ( kind=4 ) :: temp_size, ind
        real    ( kind=8 ), allocatable, dimension(:) :: temp_loop_times

        ! take the time:
        self%internal_end_time = self%time()
        ! increase by one the number of loops:
        self%number_loops = self%number_loops +1
        ! check the allocation of the loop array:
        if ( .not. allocated( self%loop_times ) ) then
            allocate( self%loop_times(allocated_num_loops ) )
            self%loop_times = 0.0d0
        end if
        ! get the length of the loop array:
        temp_size = size(self%loop_times)
        ! reallocate the loop array if needed:
        if ( self%number_loops > temp_size ) then
            ! allocate a temporary array:
            allocate( temp_loop_times(temp_size) )
            ! copy the timing array on the temporary one:
            temp_loop_times = self%loop_times
            ! deallocate the loop array and reallocate it:
            deallocate( self%loop_times )
            allocate( self%loop_times( (self%number_loops/allocated_num_loops+1)*allocated_num_loops ) )
            self%loop_times = 0.0d0
            ! copy the time data:
            do ind=1, self%number_loops-1
                self%loop_times(ind) =  temp_loop_times(ind)
            end do
        end if
        ! store the time:
        if ( self%number_loops==1 ) then
            self%loop_times(self%number_loops) = self%internal_end_time -self%start_time
        else
            self%loop_times(self%number_loops) = self%internal_end_time -self%internal_start_time
        end if
        ! restart the timer:
        self%internal_start_time = self%time()

    end subroutine timer_loop

    ! ---------------------------------------------------------------------------------------------
    function timer_average( self )

        implicit none

        class( timer  ) :: self
        real ( kind=8 ) :: timer_average

        integer ( kind=4 ) :: ind

        ! initialize:
        timer_average = 0.0d+0
        ! accumulate time measurements:
        do ind=1, self%number_loops
            timer_average = timer_average +self%loop_times(ind)
        end do
        ! compute and return the average:
        timer_average = timer_average/REAL(self%number_loops)

    end function timer_average

    ! ---------------------------------------------------------------------------------------------
    function timer_variance( self )

        implicit none

        class( timer  ) :: self
        real ( kind=8 ) :: timer_variance

        real    ( kind=8 ) :: average_time
        integer ( kind=4 ) :: ind

        ! initialize:
        timer_variance = 0.0d+0
        ! compute the variance:
        if ( self%number_loops>1 ) then
            average_time = self%average()
            do ind=1, self%number_loops
                timer_variance = timer_variance +( self%loop_times(ind) -average_time )**2
            end do
            timer_variance = sqrt( timer_variance/REAL(self%number_loops-1) )
        end if

    end function timer_variance

    ! ---------------------------------------------------------------------------------------------
    function timer_elapsed( self )

        implicit none

        class(timer)    :: self
        real ( kind=8 ) :: timer_elapsed

        timer_elapsed = self%end_time -self%start_time

    end function timer_elapsed

    ! ---------------------------------------------------------------------------------------------
    subroutine timer_reset( self )

        implicit none

        class(timer)    :: self

        self%start_time   = 0.0d+0
        self%end_time     = 0.0d+0

        self%number_loops = 0

        self%internal_start_time = 0.0d+0
        self%internal_end_time   = 0.0d+0

        if ( allocated( self%loop_times ) ) deallocate( self%loop_times )

    end subroutine timer_reset

    ! ---------------------------------------------------------------------------------------------
    subroutine timer_wait( self, time )

        implicit none

        class( timer  )             :: self
        real ( kind=8 ), intent(in) :: time

        real( kind=8 ) :: start_time, elapsed_time

        start_time = self%time()
        do
            elapsed_time = self%time() -start_time
            if ( elapsed_time > time ) return
        end do

    end subroutine timer_wait

    ! ---------------------------------------------------------------------------------------------
    function timer_time( self )

        implicit none

        class(timer)    :: self
        real ( kind=8 ) :: timer_time

        call cpu_time(timer_time)

    end function timer_time

    ! ---------------------------------------------------------------------------------------------

end module f2k_timer