serial/en/dc__clock_8f90_source.html

! -*- mode: f90; coding: utf-8 -*-

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

! Copyright (c) 2006-2026 Gtool Development Group. All rights reserved.

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

!>

!> @author    Yasuhiro MORIKAWA

!> @copyright Copyright (C) GFD Dennou Club, 2006-2026. All rights reserved. <br/>

!>            License is BSD-2-Clause. see [COPYRIGHT](@ref COPYRIGHT) in detail

!>

!> @en

!> @brief Monitor of CPU TIME

!> @details

!> Measures and displays the CPU time consumed by program processing.

!>

!> @section dc_clock_procedures Procedures List

!>

!> | Procedure       | Description                                      |

!> |-----------------|--------------------------------------------------|

!> | DCClockCreate   | Initialize CLOCK type variable                   |

!> | DCClockStart    | Start measurement                                |

!> | DCClockStop     | Pause measurement                                |

!> | DCClockClose    | Finalize CLOCK type variable                     |

!> | DCClockGet      | Get CPU time (in seconds)                        |

!> | DCClockEvalSec  | Get CPU time (in seconds) as function            |

!> | DCClockToChar   | Convert CPU time to formatted string             |

!> | DCClockPutLine  | Display CLOCK variable information               |

!> | DCClockResult   | Display comprehensive CPU time information       |

!> | DCClockPredict  | Display predicted CPU time and date to completion|

!> | DCClockSetName  | Reset name                                       |

!> | operator(+)     | Addition (between CLOCK types)                   |

!> | operator(-)     | Subtraction (between CLOCK types)                |

!>

!> @section dc_clock_usage Usage

!>

!> First, define a CLOCK type variable and initialize it with DCClockCreate.

!> Call DCClockStart at the measurement start point in your program,

!> and call DCClockStop at the point to pause measurement.

!> Display elapsed time with DCClockResult.

!> Use DCClockPredict to display estimated remaining CPU time.

!>

!> @note CPU time measurement uses the *cpu_time* intrinsic subroutine

!> (introduced in Fortran 95). Whether the measured CPU time is system

!> CPU time, user CPU time, or the sum of both depends on the implementation.

!>

!> @enden

!>

!> @ja

!> @brief CPU 時間の計測

!> @details

!> プログラムの処理に要した CPU 時間を計測して表示します。

!>

!> @section dc_clock_procedures_ja 手続一覧

!>

!> | 手続名          | 説明                                             |

!> |-----------------|--------------------------------------------------|

!> | DCClockCreate   | CLOCK 型変数の初期設定                           |

!> | DCClockStart    | 計測の開始                                       |

!> | DCClockStop     | 計測の一時停止                                   |

!> | DCClockClose    | 構造型 CLOCK 変数の終了処理                      |

!> | DCClockGet      | CPU 時間 (単位: 秒) の取得                       |

!> | DCClockEvalSec  | CPU 時間 (単位: 秒) の取得 (関数)                |

!> | DCClockToChar   | CPU 時間を適当に整形して文字型変数に変換         |

!> | DCClockPutLine  | 構造型 CLOCK 変数の情報を表示                    |

!> | DCClockResult   | CPU 時間に関する総合的な情報を表示               |

!> | DCClockPredict  | プログラム終了までの予測 CPU 時間・日時を表示    |

!> | DCClockSetName  | 名称の再設定                                     |

!> | operator(+)     | 加算 (CLOCK 型同士)                              |

!> | operator(-)     | 減算 (CLOCK 型同士)                              |

!>

!> @section dc_clock_usage_ja 使用方法

!>

!> 始めに、構造型 CLOCK の変数を定義し、DCClockCreate で初期化します。

!> プログラム中の計測開始地点で DCClockStart を呼び出し、

!> 計測を一時停止する地点で DCClockStop を呼び出します。

!> DCClockResult によって経過時間を表示します。

!> DCClockPredict を使用することでプログラム終了までの残り CPU 時間

!> の予測値を表示することが可能です。

!>

!> @note CPU 時間の計測に *cpu_time* サブルーチン (Fortran 95 規格で導入)

!> を使用しているため、計測された CPU 時間がシステム CPU 時間なのか

!> ユーザ CPU 時間なのか、もしくは両方の合計なのかは処理系に依存します。

!>

!> @endja

!>

module dc_clock

  use dc_types, only: string, dp

  use dc_trace, only: beginsub, endsub, dbgmessage

  use dc_date_types, only: dc_difftime, dc_datetime

  implicit none

  private

  public:: clock

  public:: dcclockcreate, dcclockclose, dcclockstart, dcclockstop

  public:: dcclockputline, dcclockresult, dcclocksetname

  public:: operator(+), operator(-)

  public:: dcclockget, dcclockevalsec, dcclocktochar, dcclockpredict

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

  ! 後方互換用

  ! For backward compatibility

  public:: create, Close, start, stop, putline, result, set_name

  public:: get, evalsec, tochar, predict

  !> @en

  !> @brief Structure for CPU time measurement

  !> @details

  !> Use Create for initialization and Close for finalization.

  !> See dc_clock Usage for detailed usage.

  !> @enden

  !>

  !> @ja

  !> @brief CPU 時刻計測用の構造体

  !> @details

  !> 初期化には Create を、終了処理には Close を用います。

  !> 詳しい使い方は dc_clock の Usage を参照ください。

  !> @endja


  type clock

    private

    character(STRING):: name

    real(dp):: start_time           ! 計測を開始した時間

                                    ! (計測の一時停止中には負の値が設定される)

    real(dp):: elapsed_time         ! 経過時間の累計値

    type(dc_datetime):: start_date  ! 計測を開始した日時

    logical:: initialized = .false. ! CLOCK 構造体の初期化チェック用フラグ

  end type clock


  interface dcclockcreate

    module procedure dcclockcreate0


  end interface


  interface dcclockclose

    module procedure dcclockclose0


  end interface


  interface dcclockstart

    module procedure dcclockstart0


  end interface


  interface dcclockstop

    module procedure dcclockstop0


  end interface


  interface dcclockputline

    module procedure dcclockputline0


  end interface


  interface dcclockget

    module procedure dcclockgetr

    module procedure dcclockgetd


  end interface


  interface dcclockevalsec

    module procedure dcclockevalsecd


  end interface


  interface dcclocktochar

    module procedure dcclocktochar0


  end interface


  interface dcclockresult

    module procedure dcclockresult0


  end interface


  interface operator(+)

    module procedure dcclockadd


  end interface


  interface operator(-)

    module procedure dcclocksubtract


  end interface


  interface dcclocksetname

    module procedure dcclocksetname0


  end interface


  interface dcclockpredict

    module procedure dcclockpredict0


  end interface

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

  ! 後方互換用

  ! For backward compatibility


  interface create

    module procedure dcclockcreate0


  end interface


  interface close

    module procedure dcclockclose0


  end interface


  interface start

    module procedure dcclockstart0


  end interface


  interface stop

    module procedure dcclockstop0


  end interface


  interface putline

    module procedure dcclockputline0


  end interface


  interface get

    module procedure dcclockgetr

    module procedure dcclockgetd


  end interface


  interface evalsec

    module procedure dcclockevalsecd


  end interface


  interface tochar

    module procedure dcclocktochar0


  end interface


  interface result

    module procedure dcclockresult0


  end interface


  interface set_name

    module procedure dcclocksetname0


  end interface


  interface predict

    module procedure dcclockpredict0


  end interface

  character(*), parameter:: version = &

    & '$Name:  $' // &

    & '$Id: dc_clock.F90,v 1.1 2009-03-20 09:09:53 morikawa Exp $'

contains

  !> @en

  !> @brief Initialize CLOCK variable

  !> @details

  !> Initialize a CLOCK type variable before using it.

  !> Give the measurement content to `name`.

  !>

  !> @param[out] clk CLOCK type variable to initialize

  !> @param[in] name Name of measurement content

  !> @enden

  !>

  !> @ja

  !> @brief CLOCK の初期化用サブルーチン

  !> @details

  !> CLOCK 型の変数を利用する際にはまずこのサブルーチンによって

  !> 初期化を行ってください。`name` には計測内容を与えてください。

  !>

  !> @param[out] clk 初期化する CLOCK 型変数

  !> @param[in] name 計測内容の名称

  !> @endja


  subroutine dcclockcreate0(clk, name)

    use dc_message, only: messagenotify

    use dc_date, only: dcdatetimecreate

    implicit none

    type(clock), intent(out):: clk

    character(*), intent(in):: name

    character(*), parameter:: subname = 'DCClockCreate'

  continue

    call beginsub(subname, 'name=%c', c1=trim(name), version=version)

    if (clk % initialized) then

      call messagenotify('W', subname, 'This argument (type CLOCK) is already initialized.')

      call dbgmessage('already initialized')

      goto 999

    end if

    clk % name = name

    clk % elapsed_time = 0.0

    clk % start_time = - 1.0

    clk % initialized = .true.

    call dcdatetimecreate(clk % start_date)

    call dbgmessage('normal initialized')

999 continue

    call endsub(subname)


  end subroutine dcclockcreate0

  !> @en

  !> @brief Close CLOCK variable

  !> @details

  !> Closes a CLOCK type variable.

  !>

  !> @param[in,out] clk CLOCK type variable to close

  !> @enden

  !>

  !> @ja

  !> @brief CLOCK の終了サブルーチン

  !> @details

  !> CLOCK 型の変数をクローズします。

  !>

  !> @param[in,out] clk クローズする CLOCK 型変数

  !> @endja


  subroutine dcclockclose0(clk)

    implicit none

    type(clock), intent(inout):: clk

    character(*), parameter:: subname = 'DCClockClose'

  continue

    call beginsub(subname)

    if (clk % initialized) then

      clk % initialized = .false.

      clk % name = ''

    end if

    call endsub(subname)


  end subroutine dcclockclose0

  !> @en

  !> @brief Start measurement

  !> @details

  !> Starts measurement at the point this subroutine is called.

  !>

  !> If `clk` has not been initialized by DCClockCreate, an error is raised.

  !> If `err` is provided, .true. is returned in `err` and the program continues.

  !>

  !> @param[in,out] clk CLOCK type variable

  !> @param[out] err Error flag (optional). .true. if error occurred.

  !> @enden

  !>

  !> @ja

  !> @brief 計測の開始

  !> @details

  !> このサブルーチンを呼んだ時点で計測を開始します。

  !>

  !> `clk` に対して DCClockCreate による初期化が行われていない場合、

  !> エラーを発生させます。`err` を与える場合には `err` に .true. が返り、

  !> プログラムは続行されます。

  !>

  !> @param[in,out] clk CLOCK 型変数

  !> @param[out] err エラーフラグ (省略可)。エラー時に .true.。

  !> @endja


  subroutine dcclockstart0(clk, err)

    use dc_message, only: messagenotify

    use dc_string, only: tochar

    use dc_error, only: storeerror, dc_enotinit, dc_noerr

    use dc_date, only: evalsec

    !$ use omp_lib

    implicit none

    type(clock), intent(inout):: clk

    logical, intent(out), optional:: err

    character(STRING):: cause_c

    integer:: stat

    character(*), parameter:: subname = 'DCClockStart'

  continue

    call beginsub(subname)

    stat = dc_noerr

    cause_c = 'CLOCK'

    if (.not. clk % initialized) then

      call messagenotify('W', subname, 'Call Create before Start in dc_clock.')

      call dbgmessage('Ignored because input argument was not initialized.')

      stat = dc_enotinit

      goto 999

    end if

    call cpu_time(clk % start_time) ! (out)

    !$ clk % start_time = omp_get_wtime()

    call dbgmessage('name=%c, cpu_time=%f', &

      & c1=trim(clk % name), d=(/clk % start_time/) )

999 continue

    call storeerror(stat, subname, err, cause_c)

    call endsub(subname)


  end subroutine dcclockstart0

  !> @en

  !> @brief Pause measurement

  !> @details

  !> Pauses measurement at the point this subroutine is called.

  !>

  !> If `clk` has not been initialized by DCClockCreate, an error is raised.

  !> If `err` is provided, .true. is returned in `err` and the program continues.

  !>

  !> @param[in,out] clk CLOCK type variable

  !> @param[out] err Error flag (optional). .true. if error occurred.

  !> @enden

  !>

  !> @ja

  !> @brief 計測の一時停止

  !> @details

  !> このサブルーチンを呼んだ時点で計測を一時停止します。

  !>

  !> `clk` に対して DCClockCreate による初期化が行われていない場合、

  !> エラーを発生させます。`err` を与える場合には `err` に .true. が返り、

  !> プログラムは続行されます。

  !>

  !> @param[in,out] clk CLOCK 型変数

  !> @param[out] err エラーフラグ (省略可)。エラー時に .true.。

  !> @endja


  subroutine dcclockstop0(clk, err)

    use dc_message, only: messagenotify

    use dc_string, only: tochar

    use dc_error, only: storeerror, dc_enotinit, dc_noerr

    use dc_date, only: evalsec, operator(+), operator(-)

    use dc_date_types, only: dc_difftime

    use dc_types, only: dp

    !$ use omp_lib

    implicit none

    type(clock), intent(inout):: clk

    logical, intent(out), optional:: err

    character(STRING):: cause_c

    real(DP):: stop_time

    integer:: stat

    character(*), parameter:: subname = 'DCClockStop'

  continue

    call beginsub(subname)

    stat = dc_noerr

    cause_c = 'CLOCK'

    if (.not. clk % initialized) then

      call messagenotify('W', subname, 'Call Create before Stop in dc_clock.')

      call dbgmessage('Ignored because input argument was not initialized.')

      stat = dc_enotinit

      goto 999

    elseif (clk % start_time < 0.0_dp) then

      call messagenotify('W', subname, 'Call Start before Stop in dc_clock.')

      call dbgmessage('Ignored because input argument was not started.')

      goto 999

    end if

    call cpu_time(stop_time)

    !$ stop_time = omp_get_wtime()

    clk % elapsed_time = clk % elapsed_time + stop_time - clk % start_time

    clk % start_time = - 1.0

    call dbgmessage('name=%c, cpu_time=%f, elapsed_time=%f', &

      & c1=trim(clk % name), d=(/stop_time, clk % elapsed_time/))

999 continue

    call storeerror(stat, subname, err, cause_c)

    call endsub(subname)


  end subroutine dcclockstop0

  !> @en

  !> @brief Get CPU time (in seconds) - single precision

  !> @details

  !> Gets CPU time (in seconds) to `sec`.

  !>

  !> If `clk` has not been initialized by DCClockCreate, an error is raised.

  !> If `err` is provided, .true. is returned in `err` and the program continues.

  !>

  !> @param[in] clk CLOCK type variable

  !> @param[out] sec CPU time in seconds (single precision)

  !> @param[out] err Error flag (optional). .true. if error occurred.

  !> @enden

  !>

  !> @ja

  !> @brief CPU 時間 (単位: 秒) の取得 (単精度)

  !> @details

  !> CPU 時間 (単位: 秒) を `sec` に取得します。

  !>

  !> `clk` に対して DCClockCreate による初期化が行われていない場合、

  !> エラーを発生させます。`err` を与える場合には `err` に .true. が返り、

  !> プログラムは続行されます。

  !>

  !> @param[in] clk CLOCK 型変数

  !> @param[out] sec CPU 時間 (秒、単精度)

  !> @param[out] err エラーフラグ (省略可)。エラー時に .true.。

  !> @endja


  subroutine dcclockgetr(clk, sec, err) !:doc-priority 40:

    use dc_message, only: messagenotify

    use dc_date, only: evalsec

    use dc_string, only: cprintft

    use dc_error, only: storeerror, dc_enotinit, dc_noerr

    implicit none

    type(clock), intent(in):: clk

    real, intent(out):: sec

    logical, intent(out), optional:: err

    character(STRING):: cause_c

    integer:: stat

    character(*), parameter:: subname = 'DCClockGetR'

  continue

    call beginsub(subname)

    stat = dc_noerr

    cause_c = 'CLOCK'

    if (.not. clk % initialized) then

      call messagenotify('W', subname, 'Call Create before Get in dc_clock.')

      call dbgmessage('Ignored because input argument was not initialized.')

      stat = dc_enotinit

      goto 999

    end if

    sec = real(clk % elapsed_time, kind=kind(sec))

    call dbgmessage('name=%c, return sec=<%r>', &

      & c1=trim(clk % name), r=(/sec/))

999 continue

    call storeerror(stat, subname, err, cause_c)

    call endsub(subname)


  end subroutine dcclockgetr

  !> @en

  !> @brief Get CPU time (in seconds) - double precision

  !> @details

  !> Gets CPU time (in seconds) to `sec`.

  !>

  !> If `clk` has not been initialized by DCClockCreate, an error is raised.

  !> If `err` is provided, .true. is returned in `err` and the program continues.

  !>

  !> @param[in] clk CLOCK type variable

  !> @param[out] sec CPU time in seconds (double precision)

  !> @param[out] err Error flag (optional). .true. if error occurred.

  !> @enden

  !>

  !> @ja

  !> @brief CPU 時間 (単位: 秒) の取得 (倍精度)

  !> @details

  !> CPU 時間 (単位: 秒) を `sec` に取得します。

  !>

  !> `clk` に対して DCClockCreate による初期化が行われていない場合、

  !> エラーを発生させます。`err` を与える場合には `err` に .true. が返り、

  !> プログラムは続行されます。

  !>

  !> @param[in] clk CLOCK 型変数

  !> @param[out] sec CPU 時間 (秒、倍精度)

  !> @param[out] err エラーフラグ (省略可)。エラー時に .true.。

  !> @endja


  subroutine dcclockgetd(clk, sec, err) !:doc-priority 60:

    use dc_types, only: dp

    use dc_string, only: cprintf

    use dc_message, only: messagenotify

    use dc_date, only: evalsec

    use dc_error, only: storeerror, dc_enotinit, dc_noerr

    implicit none

    type(clock), intent(in):: clk

    real(DP), intent(out):: sec

    logical, intent(out), optional:: err

    character(STRING):: cause_c

    integer:: stat

    character(*), parameter:: subname = 'DCClockGetD'

  continue

    call beginsub(subname)

    stat = dc_noerr

    cause_c = 'CLOCK'

    if (.not. clk % initialized) then

      call messagenotify('W', subname, 'Call Create before Get in dc_clock.')

      call dbgmessage('Ignored because input argument was not initialized.')

      stat = dc_enotinit

      goto 999

    end if

    sec = clk % elapsed_time

    call dbgmessage('name=%c, return sec=<%f>', &

      & c1=trim(clk % name), d=(/sec/))

999 continue

    call storeerror(stat, subname, err, cause_c)

    call endsub(subname)


  end subroutine dcclockgetd

  !> @en

  !> @brief Get CPU time (in seconds) as function

  !> @details

  !> Returns CPU time (in seconds).

  !> If `clk` has not been initialized by DCClockCreate, -1.0 is returned.

  !>

  !> @param[in] clk CLOCK type variable

  !> @return CPU time in seconds (double precision). -1.0 if not initialized.

  !> @enden

  !>

  !> @ja

  !> @brief CPU 時間 (単位: 秒) の取得 (関数)

  !> @details

  !> CPU 時間 (単位: 秒) を返します。

  !> `clk` に対して DCClockCreate による初期化が行われていない場合、

  !> -1.0 が返ります。

  !>

  !> @param[in] clk CLOCK 型変数

  !> @return CPU 時間 (秒、倍精度)。初期化されていない場合は -1.0。

  !> @endja


  function dcclockevalsecd(clk) result(result)

    use dc_types, only: dp

    implicit none

    type(clock), intent(in):: clk

    real(dp):: result

    logical:: err

  continue

    call dcclockgetd(clk, result, err)

    if (err) result = -1.0_dp


  end function dcclockevalsecd

  !> @en

  !> @brief Convert CPU time to formatted string

  !> @details

  !> Formats CPU time appropriately and returns it as a character variable.

  !> If `clk` has not been initialized by DCClockCreate, an empty string is returned.

  !>

  !> @param[in] clk CLOCK type variable

  !> @return Formatted string of CPU time

  !> @enden

  !>

  !> @ja

  !> @brief CPU 時間を適当に整形して文字型変数に変換

  !> @details

  !> CPU 時間に関して適当に整形を行い、文字型変数に変換して返します。

  !> `clk` に対して DCClockCreate による初期化が行われていない場合、

  !> 空文字が返ります。

  !>

  !> @param[in] clk CLOCK 型変数

  !> @return 整形された CPU 時間の文字列

  !> @endja


  function dcclocktochar0(clk) result(result)

    use dc_string, only: cprintf

    use dc_date, only: evalsec

    implicit none

    type(clock), intent(in):: clk

    character(STRING):: result

    character(20):: clk_name

    integer:: name_len

  continue

    clk_name = ''

    name_len = min(len(clk_name), len_trim(clk % name))

    if (name_len > 0) then

      clk_name(1:name_len) = clk % name(1:name_len)

    end if

    if (clk % initialized) then

      result = cprintf(' %c%c  %c', c1 = clk_name, &

        & c2=trim(result_value_form(clk % elapsed_time)), &

        & c3=trim(fit_unit_value(clk % elapsed_time)))

    else

      result = ''

    end if


  end function dcclocktochar0

  !> @en

  !> @brief Display CLOCK variable information

  !> @details

  !> Displays information about a CLOCK type variable.

  !> Specify the output unit number in `unit`. If `unit` is not given,

  !> output goes to standard output.

  !>

  !> If `clk` has not been initialized by DCClockCreate, an error is raised.

  !> If `err` is provided, .true. is returned in `err` and the program continues.

  !>

  !> @param[in] clk CLOCK type variable

  !> @param[in] unit Output unit number (optional). Default: standard output.

  !> @param[in] indent Indent of displayed messages (optional)

  !> @param[out] err Error flag (optional). .true. if error occurred.

  !> @enden

  !>

  !> @ja

  !> @brief 構造型 CLOCK 変数の情報を表示

  !> @details

  !> 構造型 CLOCK 変数に関する情報を表示します。`unit` には出力先の装置番号を

  !> 与えてください。`unit` を与えない場合、標準出力へ表示されます。

  !>

  !> `clk` に対して DCClockCreate による初期化が行われていない場合、

  !> エラーを発生させます。`err` を与える場合には `err` に .true. が返り、

  !> プログラムは続行されます。

  !>

  !> @param[in] clk CLOCK 型変数

  !> @param[in] unit 出力先装置番号 (省略可)。デフォルト: 標準出力。

  !> @param[in] indent 表示されるメッセージの字下げ (省略可)

  !> @param[out] err エラーフラグ (省略可)。エラー時に .true.。

  !> @endja


  subroutine dcclockputline0(clk, unit, indent, err)

    use dc_types, only: stdout

    use dc_message, only: messagenotify

    use dc_string, only: printf, tochar, cprintf

    use dc_date, only: evalsec, evalday, tochar

    use dc_error, only: storeerror, dc_enotinit, dc_noerr

    use dc_types, only: dp

    implicit none

    type(clock), intent(in):: clk

    integer, intent(in), optional:: unit

    character(*), intent(in), optional:: indent

    logical, intent(out), optional:: err

    integer:: out_unit

    character(STRING):: cause_c

    integer:: stat

    integer:: indent_len

    character(STRING):: indent_str

    character(*), parameter:: subname = 'DCClockPutLine'

  continue

    call beginsub(subname)

    stat = dc_noerr

    cause_c = 'CLOCK'

    if (.not. clk % initialized) then

      call messagenotify('W', subname, 'Call Create before PutLine in dc_clock.')

      call dbgmessage('Ignored because input argument was not initialized.')

      stat = dc_enotinit

      goto 999

    end if

    if (present(unit)) then

      out_unit = unit

    else

      out_unit = stdout

    end if

    indent_len = 0

    indent_str = ''

    if (present(indent)) then

      if (len(indent) /= 0) then

        indent_len = len(indent)

        indent_str(1:indent_len) = indent

      end if

    end if

    call printf(out_unit, &

      & indent_str(1:indent_len) // &

      & '#<CLOCK:: @name=%c @clocking=%y @elapsed_time=%f sec. %c @start_date=%c>', &

      & c1=trim(clk % name), l=(/clk % start_time > 0.0_dp/), &

      & d=(/clk % elapsed_time/), &

      & c2=trim(fit_unit_value(clk % elapsed_time)), &

      & c3=trim(tochar(clk % start_date)))

    call dbgmessage('name=%c, output to device number %d', &

      & c1=trim(clk % name), i=(/out_unit/))

999 continue

    call storeerror(stat, subname, err, cause_c)

    call endsub(subname)


  end subroutine dcclockputline0

  !> @en

  !> @brief Display CPU time summary

  !> @details

  !> Displays the total CPU time summary. Pass an array of CLOCK variables to `clks`.

  !> This is intended to be called at the end of the program.

  !> Specify the output unit number in `unit`. If `unit` is not given,

  !> output goes to standard output.

  !>

  !> If `total_auto` is .true., the sum of all `clks` is automatically displayed.

  !> If `clk_total` is given, it takes precedence.

  !>

  !> If `clk_total` is given, this CLOCK variable is displayed as the total.

  !>

  !> If `total_name` is given, this string is output at the beginning of the summary.

  !>

  !> If any `clk` in `clks` has not been initialized by DCClockCreate, an error is raised.

  !> If `err` is provided, .true. is returned in `err` and the program continues.

  !>

  !> @param[in] clks Array of CLOCK type variables

  !> @param[in] unit Output unit number (optional). Default: standard output.

  !> @param[in] total_auto If .true., automatically display sum of all clks (optional)

  !> @param[in] clk_total CLOCK variable to display as total (optional)

  !> @param[in] total_name String to output at the beginning of summary (optional)

  !> @param[out] err Error flag (optional). .true. if error occurred.

  !> @enden

  !>

  !> @ja

  !> @brief CPU 時間の総計を表示

  !> @details

  !> CPU 時間の総計を表示します。`clks` へ CLOCK 変数の配列を与えてください。

  !> プログラムの最後で呼び出されることを想定しています。

  !> `unit` には出力先の装置番号を与えてください。

  !> `unit` を与えない場合、標準出力へ表示されます。

  !>

  !> `total_auto` に .true. を与えると、`clks` を全て足し合わせた

  !> 合計値を自動的に表示します。`clk_total` が与えられている場合は

  !> `clk_total` が優先されます。

  !>

  !> `clk_total` に CLOCK 変数を与えると、この変数を合計値として表示します。

  !>

  !> `total_name` に文字型変数を与えると、総計メッセージの冒頭に

  !> この文字列を出力します。

  !>

  !> `clks` 内の `clk` に対して DCClockCreate による初期化が行われていない場合、

  !> エラーを発生させます。`err` を与える場合には `err` に .true. が返り、

  !> プログラムは続行されます。

  !>

  !> @param[in] clks CLOCK 型変数の配列

  !> @param[in] unit 出力先装置番号 (省略可)。デフォルト: 標準出力。

  !> @param[in] total_auto .true. の場合、全 clks の合計を自動表示 (省略可)

  !> @param[in] clk_total 合計として表示する CLOCK 変数 (省略可)

  !> @param[in] total_name 総計メッセージ冒頭に出力する文字列 (省略可)

  !> @param[out] err エラーフラグ (省略可)。エラー時に .true.。

  !> @endja


  subroutine dcclockresult0(clks, unit, total_auto, clk_total, total_name, err)

    use dc_types, only: stdout, string, dp

    use dc_message, only: messagenotify

    use dc_string, only: printf, tochar, cprintf

    use dc_date, only: evalsec

    use dc_error, only: storeerror, dc_enotinit, dc_noerr

    implicit none

    type(clock), intent(in):: clks(:)

    integer, intent(in), optional:: unit

    logical, intent(in), optional:: total_auto

    type(clock), intent(in), optional:: clk_total

    logical, intent(out), optional:: err

    character(*), intent(in), optional:: total_name

    integer:: out_unit, i, clks_size, ra

    character(20):: clk_name

    integer:: name_len

    character(STRING):: cause_c

    character(STRING):: total_name_work

    type(clock):: clk_auto_total

    logical:: total_print_complete

    real(DP):: elapsed_time_val_cor

    integer:: stat

    character(*), parameter:: total_time_mes = '       TOTAL TIME = '

    integer:: myrank_mpi, nprocs_mpi

    character(*), parameter:: subname = 'DCClockResult'

  continue

    call beginsub(subname)

    stat = dc_noerr

    cause_c = 'CLOCK'

    clks_size = size(clks)

    do i = 1, clks_size

      if (.not. clks(i) % initialized) then

        call messagenotify('W', subname, 'Call Create before Result in dc_clock.')

        call dbgmessage('Ignored because input argument was not initialized.')

        stat = dc_enotinit

        goto 999

      end if

    end do

    if (present(unit)) then

      out_unit = unit

    else

      out_unit = stdout

    end if

    if (present(total_name)) then

      total_name_work = ' (' // trim(total_name) // ')'

    else

      total_name_work = ''

    end if

    myrank_mpi = -1

    nprocs_mpi = 1

    do ra = 0, nprocs_mpi - 1

      call printf(out_unit, '')

      if ( myrank_mpi < 0 ) then

        call printf(out_unit, &

          & ' ############## CPU TIME SUMMARY%c################', &

          & c1=trim(total_name_work) // ' ')

      else

        call printf(out_unit, &

          & ' ####### CPU TIME SUMMARY%c#### [rank=%06d] ####', &

          & c1=trim(total_name_work) // ' ', &

          & i = (/myrank_mpi/) )

      end if

      do i = 1, clks_size

        clk_name = ''

        name_len = min(len(clk_name), len_trim(clks(i) % name))

        if (name_len > 0) then

          clk_name(1:name_len) = clks(i) % name(1:name_len)

        end if

        elapsed_time_val_cor = clks(i) % elapsed_time

        if (elapsed_time_val_cor < 0.0_dp) elapsed_time_val_cor = 0.0_dp

        call printf(out_unit, &

          & ' %c%c  %c', c1=clk_name, &

          & c2=trim(result_value_form(elapsed_time_val_cor)), &

          & c3=trim(fit_unit_value(clks(i) % elapsed_time)))

      end do

      total_print_complete = .false.

      if (present(clk_total)) then

        if (clk_total % initialized) then

          call printf(out_unit, &

            & ' ------------------------------------------------')

          elapsed_time_val_cor = clk_total % elapsed_time

          if (elapsed_time_val_cor < 0.0_dp) elapsed_time_val_cor = 0.0_dp

          call printf(out_unit, &

            & ' %c%c  %c', c1=total_time_mes, &

            & c2=trim(result_value_form(elapsed_time_val_cor)), &

            & c3=trim(fit_unit_value(clk_total % elapsed_time)))

          total_print_complete = .true.

        end if

      end if

      if (present(total_auto) .and. .not. total_print_complete) then

        if (total_auto) then

          clk_auto_total = clks(1)

          if (clks_size > 1) then

            do i = 2, clks_size

              clk_auto_total = clk_auto_total + clks(i)

            end do

          end if

          call printf(out_unit, &

            & ' ------------------------------------------------')

          elapsed_time_val_cor = clk_auto_total % elapsed_time

          if (elapsed_time_val_cor < 0.0_dp) elapsed_time_val_cor = 0.0_dp

          call printf(out_unit, &

            & ' %c%c  %c', c1=total_time_mes, &

            & c2=trim(result_value_form(elapsed_time_val_cor)), &

            & c3=trim(fit_unit_value(clk_auto_total % elapsed_time)))

        end if

      end if

      call dbgmessage('total results, output to device number %d', &

        & i=(/out_unit/))

    end do

999 continue

    call storeerror(stat, subname, err, cause_c)

    call endsub(subname)


  end subroutine dcclockresult0

  !> @brief Format double precision value to exponential notation string

  !> @param[in] value Double precision value to format

  !> @return Formatted string (e.g., "0.183400E+02")

  function result_value_form(value) result(result)

    use dc_types, only: dp, token

    implicit none

    character(TOKEN):: result

    real(DP), intent(in):: value

  continue

    write(result, "(e15.6)") value

  end function result_value_form

  !> @brief Format seconds to appropriate unit string

  !> @details

  !> Treats the value given to `sec` as seconds and formats it as:

  !> "(23.18 days)". The unit is chosen from days, hrs., minutes

  !> (chosen so the value is >= 1). Returns empty string if < 1 minute.

  !> @param[in] sec Seconds value

  !> @param[in] diff DC_DIFFTIME to use directly (optional)

  !> @return Formatted string (e.g., "(23.18 days)")

  function fit_unit_value(sec, diff) result(result)

    use dc_types, only: dp, token

    use dc_date_types, only: dc_difftime

    use dc_date, only: dcdifftimecreate, evalday, evalhour, evalmin, evalsec

    implicit none

    character(TOKEN):: result

    real(DP), intent(in):: sec

    type(dc_difftime), intent(in), optional:: diff

    type(dc_difftime):: diffw

    character(TOKEN):: unit

    real(DP):: value

    character(TOKEN):: cval

  continue

    if ( present(diff) ) then

      diffw = diff

    else

      call dcdifftimecreate( diffw, sec = sec )

    end if

    if (evalday(diffw) > 1.0_dp) then

      unit = ' days'

      value = evalday(diffw)

    elseif (evalhour(diffw) > 1.0_dp) then

      unit = ' hrs.'

      value = evalhour(diffw)

    elseif (evalmin(diffw) > 1.0_dp) then

      unit = ' minutes'

      value = evalmin(diffw)

    else

      result = ''

      return

    end if

    cval = printf_g5_2(value)

    result = '(' // trim(adjustl(cval)) // trim(unit) // ')'

  end function fit_unit_value

  !> @brief Format numeric value with 2 decimal places

  !> @details

  !> Formats the value given as: "23.18" or "0.23"

  !> @param[in] value Numeric value to format

  !> @return Formatted string

  function printf_g5_2(value) result(result)

    use dc_types, only: dp, token

    use dc_string, only: cprintft

    implicit none

    character(TOKEN):: result

    real(DP), intent(in):: value

    character(TOKEN):: int_part, dem_part

    integer:: dem_int

  continue

    write(int_part, "(i20)") int(value)

    dem_int = nint((value - int(value)) * 100)

    if (dem_int < 0) dem_int = - dem_int

    if (dem_int == 100) then

      dem_int = 0

      write(int_part, "(i20)") int(value) + 1

    end if

    dem_part = cprintft('%02d', i=(/dem_int/))

    result = trim(adjustl(int_part)) // '.' // trim(dem_part)

  end function printf_g5_2

  !> @en

  !> @brief Add CLOCK variables

  !> @details

  !> Adds CLOCK variables `clk1` and `clk2`.

  !> Sums the CPU times of the two given CLOCK variables and returns as CLOCK.

  !> The name of the result is a combination of `clk1` and `clk2` names joined by '+'.

  !>

  !> @param[in] clk1 First CLOCK variable

  !> @param[in] clk2 Second CLOCK variable

  !> @return Sum of the two CLOCK variables

  !> @enden

  !>

  !> @ja

  !> @brief CLOCK 変数を足し合わせる

  !> @details

  !> CLOCK 変数 `clk1` と `clk2` を足し合わせます。

  !> 与えられた 2 つの CLOCK 変数の CPU 時間を合計し、

  !> CLOCK 変数として返します。計測内容の名称は `clk1` と `clk2`

  !> の名称を '+' で組み合わせたものとなります。

  !>

  !> @param[in] clk1 1つ目の CLOCK 変数

  !> @param[in] clk2 2つ目の CLOCK 変数

  !> @return 2 つの CLOCK 変数の合計

  !> @endja


  function dcclockadd(clk1, clk2) result(clk_total)

    use dc_string, only: cprintf

    use dc_date, only: operator(+), operator(<)

    implicit none

    type(clock), intent(in):: clk1

    type(clock), intent(in):: clk2

    type(clock):: clk_total

  continue

    if (.not. clk1 % initialized .or. .not. clk2 % initialized) then

      clk_total % initialized = .false.

      return

    end if

    clk_total % name = cprintf('%c+%c', &

      & c1=trim(clk1 % name), c2=trim(clk2 % name))

    clk_total % start_time = - 1.0

    clk_total % initialized = .true.

    clk_total % elapsed_time = 0.0

    if (clk1 % start_date < clk2 % start_date) then

      clk_total % start_date = clk1 % start_date

    else

      clk_total % start_date = clk2 % start_date

    end if

    clk_total % elapsed_time = &

      & clk1 % elapsed_time + clk2 % elapsed_time


  end function dcclockadd

  !> @en

  !> @brief Subtract CLOCK variables

  !> @details

  !> Subtracts `clk2` from CLOCK variable `clk1`.

  !> Returns the difference between the CPU times of the two CLOCK variables.

  !> The name of the result is a combination of `clk1` and `clk2` names joined by '-'.

  !>

  !> @param[in] clk1 First CLOCK variable (minuend)

  !> @param[in] clk2 Second CLOCK variable (subtrahend)

  !> @return Difference of the two CLOCK variables

  !> @enden

  !>

  !> @ja

  !> @brief CLOCK 変数を引き算する

  !> @details

  !> CLOCK 変数 `clk1` から `clk2` を引きます。

  !> 1 つ目の CLOCK 変数の CPU 時間と 2 つ目の CLOCK 変数の CPU 時間との差を

  !> CLOCK 変数として返します。計測内容の名称は `clk1` と `clk2`

  !> の名称を '-' で組み合わせたものとなります。

  !>

  !> @param[in] clk1 1つ目の CLOCK 変数 (被減数)

  !> @param[in] clk2 2つ目の CLOCK 変数 (減数)

  !> @return 2 つの CLOCK 変数の差

  !> @endja


  function dcclocksubtract(clk1, clk2) result(clk_total)

    use dc_string, only: cprintf

    use dc_date, only: operator(-), operator(<)

    implicit none

    type(clock), intent(in):: clk1

    type(clock), intent(in):: clk2

    type(clock):: clk_total

  continue

    if (.not. clk1 % initialized .or. .not. clk2 % initialized) then

      clk_total % initialized = .false.

      return

    end if

    clk_total % name = cprintf('%c-%c', &

      & c1=trim(clk1 % name), c2=trim(clk2 % name))

    clk_total % start_time = - 1.0

    clk_total % initialized = .true.

    clk_total % elapsed_time = 0.0

    if (clk1 % start_date < clk2 % start_date) then

      clk_total % start_date = clk1 % start_date

    else

      clk_total % start_date = clk2 % start_date

    end if

    clk_total % elapsed_time = &

      & clk1 % elapsed_time - clk2 % elapsed_time


  end function dcclocksubtract

  !> @en

  !> @brief Change the measurement name

  !> @details

  !> Changes the measurement name of CLOCK variable `clk`.

  !> This name was originally specified by the `name` argument in Create.

  !>

  !> If `clk` has not been initialized by DCClockCreate, an error is raised.

  !> If `err` is provided, .true. is returned in `err` and the program continues.

  !>

  !> @param[in,out] clk CLOCK type variable

  !> @param[in] name New measurement name

  !> @param[out] err Error flag (optional). .true. if error occurred.

  !> @enden

  !>

  !> @ja

  !> @brief 測定内容の名称を変更する

  !> @details

  !> CLOCK 変数 `clk` の計測内容の名称を変更します。

  !> この名称は Create の `name` 引数で指定されたものです。

  !>

  !> `clk` に対して DCClockCreate による初期化が行われていない場合、

  !> エラーを発生させます。`err` を与える場合には `err` に .true. が返り、

  !> プログラムは続行されます。

  !>

  !> @param[in,out] clk CLOCK 型変数

  !> @param[in] name 新しい計測内容の名称

  !> @param[out] err エラーフラグ (省略可)。エラー時に .true.。

  !> @endja


  subroutine dcclocksetname0(clk, name, err)

    use dc_message, only: messagenotify

    use dc_string, only: tochar, cprintf

    use dc_error, only: storeerror, dc_enotinit, dc_noerr

    implicit none

    type(clock), intent(inout):: clk

    character(*), intent(in):: name

    logical, intent(out), optional:: err

    character(STRING):: cause_c

    integer:: stat

    character(*), parameter:: subname = 'DCClockSetName'

  continue

    call beginsub(subname)

    stat = dc_noerr

    cause_c = 'CLOCK'

    if (.not. clk % initialized) then

      call messagenotify('W', subname, 'Call Create before Set_Name in dc_clock.')

      call dbgmessage('Ignored because input argument was not initialized.')

      stat = dc_enotinit

      goto 999

    end if

    clk % name = name

    call dbgmessage('set new name "%c"', c1=trim(clk % name))

999 continue

    call storeerror(stat, subname, err, cause_c)

    call endsub(subname)


  end subroutine dcclocksetname0

  !> @en

  !> @brief Display predicted CPU time and completion date

  !> @details

  !> From CLOCK variable `clk` and `progress`, displays predicted CPU time

  !> and completion date as follows:

  !>

  !> @code

  !> ########## PREDICTION OF CALCULATION ###########

  !> Start Date             2007-03-08T16:49:25+09:00

  !> Current Date           2007-03-08T16:49:27+09:00

  !> Progress     66.67%  [****************         ]

  !> Remaining CPU TIME      0.100000E+01

  !> Completion Date        2007-03-08T16:49:28+09:00

  !> @endcode

  !>

  !> Give `progress` a value from 0 to 1. 0 is program start, 1 is end.

  !> (For example, give 0.5 when the program is half done.)

  !>

  !> Note: The "prediction" is calculated by a simple algorithm from elapsed

  !> time and progress, so it is not an accurate prediction. Use as a guide only.

  !>

  !> Specify the output unit number in `unit`. If `unit` is not given,

  !> output goes to standard output.

  !>

  !> If `clk` has not been initialized by DCClockCreate, an error is raised.

  !> If `err` is provided, .true. is returned in `err` and the program continues.

  !>

  !> @param[in] clk CLOCK type variable

  !> @param[in] progress Progress value (0.0 to 1.0)

  !> @param[in] unit Output unit number (optional). Default: standard output.

  !> @param[out] err Error flag (optional). .true. if error occurred.

  !> @enden

  !>

  !> @ja

  !> @brief プログラムが終了するまでの予測 CPU 時間・日時を表示

  !> @details

  !> CLOCK 変数 `clk` と `progress` から、プログラムが終了するまでの

  !> 予測 CPU 時間および日時を以下のように表示します。

  !>

  !> @code

  !> ########## PREDICTION OF CALCULATION ###########

  !> Start Date             2007-03-08T16:49:25+09:00

  !> Current Date           2007-03-08T16:49:27+09:00

  !> Progress     66.67%  [****************         ]

  !> Remaining CPU TIME      0.100000E+01

  !> Completion Date        2007-03-08T16:49:28+09:00

  !> @endcode

  !>

  !> `progress` には 0 〜 1 までの値を与えてください。

  !> プログラムの開始時を 0、終了時を 1 とします

  !> (例: プログラムが半分進んだ時には 0.5 を与えます)。

  !>

  !> @note ここで行う「予測」とは、これまでの経過時間および終了した

  !> プログラムの分量から単純なアルゴリズムで割り出しているものなので、

  !> 正確な予測値を返すわけではありません。あくまで目安として利用してください。

  !>

  !> `unit` には出力先の装置番号を与えてください。

  !> `unit` を与えない場合、標準出力へ表示されます。

  !>

  !> `clk` に対して DCClockCreate による初期化が行われていない場合、

  !> エラーを発生させます。`err` を与える場合には `err` に .true. が返り、

  !> プログラムは続行されます。

  !>

  !> @param[in] clk CLOCK 型変数

  !> @param[in] progress 進捗値 (0.0 〜 1.0)

  !> @param[in] unit 出力先装置番号 (省略可)。デフォルト: 標準出力。

  !> @param[out] err エラーフラグ (省略可)。エラー時に .true.。

  !> @endja


  subroutine dcclockpredict0(clk, progress, unit, err)

    use dc_types, only: stdout, dp

    use dc_message, only: messagenotify

    use dc_string, only: tochar, cprintf, printf

    use dc_error, only: storeerror, dc_enotinit, dc_noerr

    use dc_date_types, only: dc_difftime, dc_datetime

    use dc_date, only: operator(+), dcdatetimecreate, tochar, evalsec, &

      & dcdifftimecreate

    implicit none

    type(clock), intent(in):: clk

    real, intent(in):: progress

    integer, intent(in), optional:: unit

    logical, intent(out), optional:: err

    character(STRING):: cause_c

    integer:: stat, out_unit

    type(dc_difftime):: remain_diff

    type(dc_datetime):: comp_date, cur_date

    character(7):: prog_percent

    character(25):: prog_bar

    integer:: prog_bar_ptr

    real:: prog_valid

    character(*), parameter:: subname = 'DCClockPredict'

  continue

    call beginsub(subname)

    stat = dc_noerr

    cause_c = 'CLOCK'

    if (.not. clk % initialized) then

      call messagenotify('W', subname, 'Call Create before Predict in dc_clock.')

      call dbgmessage('Ignored because input argument was not initialized.')

      stat = dc_enotinit

      goto 999

    end if

    if (progress <= 0.0) then

      call messagenotify('W', subname, 'Specify 0.0 -- 1.0 value to "progress"')

      return

    elseif (progress > 1.0) then

      call messagenotify('W', subname, 'Over 1.0 value to "progress" was modified to 1.0')

      prog_valid = 1.0

    else

      prog_valid = progress

    end if

    if (present(unit)) then

      out_unit = unit

    else

      out_unit = stdout

    end if

    call dcdifftimecreate( remain_diff, &

      & sec = real(nint(evalsec(clk) / prog_valid * (1.0 - prog_valid)), dp) )

    call dcdatetimecreate(cur_date)

    comp_date = cur_date + remain_diff

    prog_percent = ''

    prog_percent = adjustr(trim(printf_g5_2(real(prog_valid * 100, dp))) // '%')

    prog_bar = ''

    prog_bar_ptr = int(prog_valid * 25)

    if (prog_bar_ptr > 0) prog_bar(1:prog_bar_ptr) = '*************************'

    call printf(out_unit, '')

    call printf(out_unit, &

      & ' ########## PREDICTION OF CALCULATION ###########')

    call printf(out_unit, &

      & ' Start Date             %c', c1=trim(tochar(clk % start_date)))

    call printf(out_unit, &

      & ' Current Date           %c', c1=trim(tochar(cur_date)))

    call printf(out_unit, &

      & ' Progress     %c [%c]', c1=prog_percent, c2=prog_bar)

    call printf(out_unit, &

      & ' Remaining CPU TIME   %c %c', &

      & c1=trim(result_value_form(evalsec(remain_diff))), &

      & c2=trim(fit_unit_value(0.0_dp, remain_diff)))

    call printf(out_unit, &

      & ' Completion Date        %c', c1=trim(tochar(comp_date)))

999 continue

    call storeerror(stat, subname, err, cause_c)

    call endsub(subname)


  end subroutine dcclockpredict0

  !> @namespace dc_clock

end module dc_clock

dc_clock::close
Definition dc_clock.f90:169

dc_clock::create
Definition dc_clock.f90:166

dc_clock::dcclockclose
Definition dc_clock.f90:126

dc_clock::dcclockcreate
Definition dc_clock.f90:123

dc_clock::dcclockevalsec
Definition dc_clock.f90:142

dc_clock::dcclockget
Definition dc_clock.f90:138

dc_clock::dcclockpredict
Definition dc_clock.f90:160

dc_clock::dcclockputline
Definition dc_clock.f90:135

dc_clock::dcclockresult
Definition dc_clock.f90:148

dc_clock::dcclocksetname
Definition dc_clock.f90:157

dc_clock::dcclockstart
Definition dc_clock.f90:129

dc_clock::dcclockstop
Definition dc_clock.f90:132

dc_clock::dcclocktochar
Definition dc_clock.f90:145

dc_clock::evalsec
Definition dc_clock.f90:185

dc_clock::get
Definition dc_clock.f90:181

dc_clock::predict
Definition dc_clock.f90:197

dc_clock::putline
Definition dc_clock.f90:178

dc_clock::result
Definition dc_clock.f90:191

dc_clock::set_name
Definition dc_clock.f90:194

dc_clock::start
Definition dc_clock.f90:172

dc_clock::stop
Definition dc_clock.f90:175

dc_clock::tochar
Definition dc_clock.f90:188

dc_message::messagenotify
Definition dc_message.f90:60

dc_string::cprintf
Definition dc_string.f90:213

dc_string::cprintft
Definition dc_string.f90:227

dc_string::printf
Definition dc_string.f90:241

dc_clock
Monitor of CPU TIME.
Definition dc_clock.f90:85

dc_date_types
Derived types and parameters for date and time.
Definition dc_date_types.f90:110

dc_date
Date and time manipulation module.
Definition dc_date.f90:57

dc_error
Error handling module.
Definition dc_error.f90:454

dc_error::storeerror
subroutine, public storeerror(number, where, err, cause_c, cause_i)
Definition dc_error.f90:891

dc_error::dc_enotinit
integer, parameter, public dc_enotinit
-400 or less: DC utilities errors
Definition dc_error.f90:534

dc_error::dc_noerr
integer, parameter, public dc_noerr
Error storage variables
Definition dc_error.f90:468

dc_message
Message output module.
Definition dc_message.f90:55

dc_string
Handling character types.
Definition dc_string.f90:83

dc_trace
Debug tracing module.
Definition dc_trace.f90:150

dc_trace::dbgmessage
subroutine, public dbgmessage(fmt, i, r, d, l, n, c1, c2, c3, ca)
Definition dc_trace.f90:661

dc_trace::beginsub
subroutine, public beginsub(name, fmt, i, r, d, l, n, c1, c2, c3, ca, version)
Definition dc_trace.f90:457

dc_trace::endsub
subroutine, public endsub(name, fmt, i, r, d, l, n, c1, c2, c3, ca)
Definition dc_trace.f90:580

dc_types
Provides kind type parameter values.
Definition dc_types.f90:55

dc_types::token
integer, parameter, public token
Character length for word, token
Definition dc_types.f90:128

dc_types::string
integer, parameter, public string
Character length for string
Definition dc_types.f90:137

dc_types::stdout
integer, parameter, public stdout
Unit number for Standard OUTPUT
Definition dc_types.f90:117

dc_types::dp
integer, parameter, public dp
Double Precision Real number
Definition dc_types.f90:92

dc_clock::clock
Definition dc_clock.f90:114

dc_date_types::dc_datetime
Definition dc_date_types.f90:348

dc_date_types::dc_difftime
Definition dc_date_types.f90:387