mod_clock.f90

Go to the documentation of this file.

!/===========================================================================/
! Copyright (c) 2007, The University of Massachusetts Dartmouth 
! Produced at the School of Marine Science & Technology 
! Marine Ecosystem Dynamics Modeling group
! All rights reserved.
!
! FVCOM has been developed by the joint UMASSD-WHOI research team. For 
! details of authorship and attribution of credit please see the FVCOM
! technical manual or contact the MEDM group.
!
! 
! This file is part of FVCOM. For details, see http://fvcom.smast.umassd.edu 
! The full copyright notice is contained in the file COPYRIGHT located in the 
! root directory of the FVCOM code. This original header must be maintained
! in all distributed versions.
!
! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
! AND ANY EXPRESS OR  IMPLIED WARRANTIES, INCLUDING,  BUT NOT  LIMITED TO,
! THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS FOR A PARTICULAR
! PURPOSE ARE DISCLAIMED.  
!
!/---------------------------------------------------------------------------/
! CVS VERSION INFORMATION
! $Id$
! $Name$
! $Revision$
!/===========================================================================/

MODULE mod_clock
   USE mod_prec
   USE mod_time
   USE control, only: use_real_world_time,ipt
   USE mod_utils
   IMPLICIT NONE

! SUBROUTINES IN MOD_CLOCK:
!   TIMER ROUTINES
! WATCH_INIT(TYPE::WATCH)
! WATCH_TIME(TYPE::WATCH) RETURN(REAL(DP))
! WATCH_RESET(TYPE::WATCH)
! WATCH_LAP(TYPE::WATCH)
! WATCH_LAP(TYPE::WATCH,INTEGER::UNIT#,CHARACTER(LEN*)::MESSAGE)
! WATCH_REPORT(TYPE::WATCH,INTEGER,CHARACTER(LEN*))
!
!    TIME STRING FORMATTING
! GETTIME(CHARACTER(LEN=13),INTEGER)
! GET_TIMESTAMP(CHARACTER(LEN=*))
!
! REPORT_TIME(INTEGER(ITIME),INTEGER(ITIME),INTEGER(ITIME),TYPE::TIME)



   TYPE watch
      INTEGER  :: count_rate,count_max
      INTEGER  :: count_0
      INTEGER  :: count_current, count_last
      INTEGER  :: lap_count
   END TYPE watch

   TYPE(watch):: report_watch

   INTERFACE watch_lap
      MODULE PROCEDURE watch_lap_noprint
      MODULE PROCEDURE watch_lap_print
   END INTERFACE

!!$EXAMPLE OF TIMER USE:
!!$
!!$! Declare a watch type
!!$TYPE(WATCH):: atimer
!!$real(sp) :: atime
!!$
!!$! Initialize the Timer
!!$CALL WATCH_INIT(atimer)
!!$
!!$
!!$Do J = 1:KB
!!$   
!!$   Do I = 1:NT
!!$   ! DO SOMETHING
!!$
!!$   END Do
!!$   ! Prints the time take for each internal do-loop
!!$   call Watch_lap(atimer)   ! JUST COUNT FOR LATER
!!$        OR
!!$   call Watch_lap(atimer,ipt,"what am I counting!") ! PRINTS TO SCREEN
!!$END Do
!!$
!!$ ! Prints the average time taken for all laps
!!$ call Watch_report(atimer)
!!$
!!$ ! Return time since watch started
!!$ atime = Watch_time(atimer)
!!$
!!$ ! RESET THE WATCH
!!$ CALL WATCH_RESET(atimer)


   CONTAINS

!==============================================================================!
!  Initialize STOPWATCH                                                        !
!==============================================================================!
SUBROUTINE watch_init(MYWATCH)
  IMPLICIT NONE
  TYPE(watch) :: MYWATCH
  
  mywatch%COUNT_RATE    = 0
  mywatch%COUNT_MAX     = 0
  mywatch%COUNT_CURRENT = 0
  mywatch%COUNT_LAST    = 0
  mywatch%COUNT_0        = 0
  mywatch%Lap_Count     = 0

 CALL system_clock (mywatch%COUNT_CURRENT, mywatch%COUNT_RATE, mywatch%COUNT_MAX)
 
 mywatch%COUNT_0     = mywatch%COUNT_CURRENT
 mywatch%COUNT_LAST = mywatch%COUNT_CURRENT

     IF(mywatch%COUNT_MAX == 0) CALL fatal_error &
          & ("MOD_CLOCK: FORTRAN DOES NOT RECOGNIZE YOUR SYSTEM CLOCK!",&
          & "INTIRINISIC, SYSTEM_CLOCK returned COUNT_MAX==0")

     IF(mywatch%COUNT_RATE .LE. 0) CALL fatal_error &
          & ("MOD_CLOCK: FORTRAN DOES NOT RECOGNIZE YOUR SYSTEM CLOCK!",&
          & .LE."INTIRINISIC, SYSTEM_CLOCK returned COUNT_RATE  0")

     IF(mywatch%COUNT_0 .LT. 0) CALL fatal_error &
          & ("MOD_CLOCK: FORTRAN DOES NOT RECOGNIZE YOUR SYSTEM CLOCK!",&
          & .LT."INTIRINISIC, SYSTEM_CLOCK returned COUNT  0")

END SUBROUTINE watch_init
!==============================================================================!
!  Retrieve Stopwatch time                                                     !
!  Return a double # of seconds since watch_initialize
!==============================================================================!
   FUNCTION watch_time(MYWATCH) 
     IMPLICIT NONE  
     TYPE(watch) :: mywatch
     REAL(dp) :: watch_time
     INTEGER(ITIME) :: big_count
     INTEGER :: my_count

     CALL system_clock(count=my_count)
     big_count = my_count - mywatch%COUNT_0
     IF (big_count < 0) big_count = big_count + mywatch%COUNT_MAX

     watch_time = dble(big_count) / dble(mywatch%COUNT_RATE)
     
   END FUNCTION watch_time

!==============================================================================!
!  Start Watch lapstart                                                             !
!==============================================================================!
   SUBROUTINE watch_reset(MYWATCH) 
     IMPLICIT NONE  
     TYPE(watch) :: MYWATCH
     
     CALL system_clock(mywatch%COUNT_CURRENT)
     mywatch%LAP_Count = 0
     mywatch%Count_LAST = mywatch%COUNT_CURRENT
     mywatch%Count_0     = mywatch%COUNT_CURRENT

   END SUBROUTINE watch_reset

!==============================================================================!
!  Watch lap                                                             !
!==============================================================================!
   SUBROUTINE watch_lap_noprint(MYWATCH) 
     IMPLICIT NONE  
     TYPE(watch) :: MYWATCH

     mywatch%COUNT_LAST = mywatch%COUNT_CURRENT
     CALL system_clock(mywatch%COUNT_CURRENT)
     mywatch%LAP_Count = mywatch%LAP_Count + 1

   END SUBROUTINE watch_lap_noprint

!==============================================================================!
!  Watch Start lap                                                             !
!==============================================================================!
   SUBROUTINE watch_start_lap(MYWATCH) 
     IMPLICIT NONE  
     TYPE(watch) :: MYWATCH

     CALL system_clock(mywatch%COUNT_CURRENT)
     !IGNORE TIME SINCE LAST STOP
     mywatch%Count_0 =mywatch%Count_0 + (mywatch%COUNT_CURRENT - mywatch%COUNT_LAST)

   END SUBROUTINE watch_start_lap

!==============================================================================!
!  Watch Stop lap                                                             !
!==============================================================================!
   SUBROUTINE watch_stop_lap(MYWATCH) 
     IMPLICIT NONE  
     TYPE(watch) :: MYWATCH

     CALL system_clock(mywatch%COUNT_CURRENT)
     mywatch%COUNT_LAST = mywatch%COUNT_CURRENT
     mywatch%LAP_Count = mywatch%LAP_Count + 1

   END SUBROUTINE watch_stop_lap
!==============================================================================!
!  Print Watch Report                                                          !
!==============================================================================!
   SUBROUTINE watch_report(MYWATCH,UNIT,MSG) 
     IMPLICIT NONE  
     

     TYPE(watch) :: MYWATCH   
     integer, intent(in) :: unit
     Character(len=*), intent(in) :: MSG
     INTEGER(ITIME) :: BIG_COUNT
     Character(len=16)  :: lcnt,ltime
     REAL(DP) :: AVG_TIME

     write(lcnt,'(I8.8)')mywatch%LAP_COUNT

     big_count = mywatch%COUNT_CURRENT - mywatch%COUNT_0
     IF (big_count < 0) big_count = big_count + mywatch%COUNT_MAX

     avg_time = dble(big_count) / dble(mywatch%COUNT_RATE * mywatch%LAP_COUNT)

     write(ltime,'(F16.6)') avg_time

     write(unit,*) "! === "//trim(msg)//" ==="
     write(unit,*) "! Average Lap Time(seconds):"//trim(adjustl(ltime))//"; &
          &Lap Count:"//trim(adjustl(lcnt))
     write(unit,*) "! ==============================="
     
  
   END SUBROUTINE watch_report
!==============================================================================!
!  Print Watch Print                                                            !
!==============================================================================!
   SUBROUTINE watch_lap_print(MYWATCH,UNIT,MSG) 
     IMPLICIT NONE  
     

     TYPE(watch) :: MYWATCH
     integer, intent(in) :: unit
     Character(len=*), intent(in) :: MSG
     INTEGER(ITIME) :: BIG_COUNT
     REAL(DP) :: LAP_TIME
     Character(len=16)  :: ltime
     

     CALL watch_lap_noprint(mywatch)
     big_count = mywatch%COUNT_CURRENT - mywatch%COUNT_LAST
     IF (big_count < 0) big_count = big_count + mywatch%COUNT_MAX

     lap_time = dble(big_count) / dble(mywatch%COUNT_RATE)

     write(ltime,'(F16.6)') lap_time

     write(unit,*) "! === "//trim(msg)//" ==="
     write(unit,*) "! Last Lap Time(seconds):"//trim(adjustl(ltime))
     write(unit,*) "! ==============================="
  
   END SUBROUTINE watch_lap_print

!==============================================================================!
!   Return a Time String Days:Hours:Minutes:Seconds from Number of Seconds     !
!==============================================================================!

   SUBROUTINE gettime(INSTRING,INSECS)

   IMPLICIT NONE
   INTEGER, INTENT(IN) :: INSECS 
   CHARACTER(LEN=13), INTENT(INOUT) :: INSTRING
   CHARACTER(LEN=4)  :: S0
   CHARACTER(LEN=2)  :: S1,S2,S3
   INTEGER :: DTCP,HTCP,MTCP,STCP
 
   dtcp = insecs/(3600*24)
   htcp = mod(insecs,(3600*24))/3600
   mtcp = mod(insecs,(3600))/60
   stcp = insecs - (dtcp*3600*24 + htcp*3600 + mtcp*60)

   IF(dtcp >= 10000 ) then
      
      instring = "> 10000 DAYS"
      return
      
   else if (dtcp < 0) THEN
      
      instring = " < 0 DAYS?"
      return
      
   else
      
      WRITE(s0,"(I4.4)")int(dtcp)
      
   END IF
   
   WRITE(s1,"(I2.2)")int(htcp)
   
   WRITE(s2,"(I2.2)")int(mtcp)
   
   WRITE(s3,"(I2.2)")int(stcp)
   

   instring = s0//":"//s1//":"//s2//":"//s3
   
   END SUBROUTINE gettime
!==============================================================================!
!  Get Current Time As Sting                                                   !
!==============================================================================!
SUBROUTINE get_timestamp(TS)
  CHARACTER(LEN=*)  TS
  CHARACTER(LEN=8)  D
  CHARACTER(LEN=10) T
                                                                                      
  CALL date_and_time ( date=d,time=t )
  ts = d(7:8)//'/'//d(5:6)//'/'//d(1:4)//'   '//t(1:2)//':'//t(3:4)
END SUBROUTINE get_timestamp
!==============================================================================!
!   Report Calculation Speed and Time to Complete                              !
!==============================================================================!

   SUBROUTINE report_time(IINT,ISTART,IEND,STIME)

   IMPLICIT NONE
   INTEGER(itime), INTENT(IN) :: IINT,ISTART,IEND
   Type(time),INTENT(IN) :: STIME
   REAL(SP) :: TTCP,TAVE
   CHARACTER(LEN=80)  :: SIMTIME,FINTIME 
   CHARACTER(LEN=22) :: PCOMP
   INTEGER :: I,ICMP,ICMP2
   INTEGER(ITIME) :: BIG_COUNT
   LOGICAL, SAVE :: INITIALIZED

   real(DP):: tmp, seconds
   integer :: hours, minutes
   Character(len=2) :: h, m
   Character(Len=9) :: s
   Character(Len=6) :: d

   IF(.not. initialized) THEN
      CALL watch_init(report_watch)

      tave = -1.0_sp
      fintime = "   UNKNOWN"
      initialized = .true.
      
   ELSE
      !
      !  CALCULATE CURRENT TIME
      !
      CALL watch_lap(report_watch)
      
      !
      !  CALCULATE AVERAGE TIME/ITERATION
      !
      big_count = report_watch%COUNT_CURRENT - report_watch%COUNT_0
      IF (big_count < 0) big_count = big_count + report_watch%COUNT_MAX
      
      tave = dble(big_count) / dble(report_watch%COUNT_RATE * report_watch%LAP_COUNT)
      
      IF(tave < 0) tave = 0.0_sp
      
      !
      !  CALCULATE TIME TO COMPLETION
      !
      ttcp = tave*(iend-iint)
      
      CALL gettime(fintime,int(ttcp))
      
   END IF

!
!  CALCULATE COMPLETION PERCENTAGE GRAPHIC
!
!   IF(MOD(IINT,1) /= 0) RETURN
   icmp = int( 100.*float(iint-istart+1)/float(iend-istart+1)) 
   icmp2 = icmp/5
   pcomp = " "
   pcomp(1:1)  = "|"
   pcomp(22:22) = "|"

   DO i=2,icmp2+1
     pcomp(i:i) = "="
   END DO

   if (use_real_world_time) then
      !  Get the date and time of the current iterationr
      simtime = write_datetime(stime,6,"UTC")

      
      !
      !  REPORT
      !
      IF(mod(iint-1,10_dp) ==0) THEN
         WRITE(ipt,102)
      END IF
      WRITE(ipt,101)iint,simtime,fintime,tave,pcomp
      
   else
      
      tmp = real(stime%MuSOD,dp) / real(million,dp)
      
      hours = tmp/3600
      minutes = (tmp-hours*3600)/60
      seconds = mod(tmp,60.0_dp)
      
      write(d,'(i6.6)') stime%mjd
      write(h,'(i2.2)') hours
      write(m,'(i2.2)') minutes
      write(s,'(F9.6)') seconds

      simtime = "D"//d//"T"//h//":"//m//":"//s
      IF(mod(iint-1,10_dp) ==0) THEN
         WRITE(ipt,103)
      END IF

      WRITE(ipt,101)iint,simtime,fintime,tave,pcomp
   end if

   return
101 FORMAT(1x,"!",i7,3x,a26,3x,a13,3x,f8.4,2x,a22)  
102 FORMAT(1x,"!   IINT ",6x,"  SIMTIME(UTC)  ",9x," FINISH IN ",5x," SECS/IT ",1x," PERCENT COMPLETE   ")  
103 FORMAT(1x,"!   IINT ",6x,"  SIMTIME  ",14x," FINISH IN ",5x," SECS/IT ",1x," PERCENT COMPLETE   ")  

   END SUBROUTINE report_time

     
END MODULE mod_clock