 |
deal.II version GIT relicensing-6766-gb5b3195129 2026-09-21 11:00:01+00:00
|
Loading...
Searching...
No Matches
|
deal.II version GIT relicensing-6766-gb5b3195129 2026-09-21 11:00:01+00:00
|
#include <deal.II/base/timer.h>
The Timer class provides a way to measure both the amount of wall time (i.e., the amount of time elapsed on a wall clock) and the amount of CPU time that certain sections of an application have used. This class also offers facilities for synchronizing the elapsed time across an MPI communicator.
The Timer class can be started and stopped several times. It stores both the amount of time elapsed over the last start-stop cycle, or lap, as well as the total time elapsed over all laps. Here is an example:
Alternatively, you can also start the timer again instead of resetting it. The times between successive calls to start() and stop() (i.e., the laps) will then be accumulated. The usage of this class is also explained in the step-28 tutorial program.
sync_lap_times is set to true, then all of the operations of this class are collective operations that have to be performed on all MPI ranks. It is impossible to query a timer object on only some of the MPI ranks. This in particular means that you should not query information from this class in destructors of other objects, because destructors may be triggered during exception handling. If only some of the MPI ranks threw an exception the communication will cause a deadlock and your program will hang without output. The only two safe operations you can do with this class in a destructor are to destroy the object or to call stop(). Classes | |
| struct | ClockMeasurements |
Public Member Functions | |
| Timer () | |
| Timer (const MPI_Comm mpi_communicator, const bool sync_lap_times=false) | |
| const Utilities::MPI::MinMaxAvg & | get_last_lap_wall_time_data () const |
| const Utilities::MPI::MinMaxAvg & | get_accumulated_wall_time_data () const |
| template<typename StreamType > | |
| void | print_last_lap_wall_time_data (StreamType &stream) const |
| template<typename StreamType > | |
| void | print_accumulated_wall_time_data (StreamType &stream) const |
| void | start () |
| void | stop () |
| void | reset () |
| void | restart () |
| bool | is_running () const |
| double | wall_time () const |
| double | last_wall_time () const |
| double | cpu_time () const |
| double | last_cpu_time () const |
| unsigned int | n_laps () const |
Private Types | |
| using | wall_clock_type = std::chrono::steady_clock |
| using | cpu_clock_type = CPUClock |
Private Member Functions | |
| void | synchronize_and_update () const |
|
private |
|
private |
| Timer::Timer | ( | ) |
Constructor. Sets the accumulated times to zero and starts the timer.
This constructor specifies that CPU times should be summed over the given mpi_communicator. If sync_lap_times is true then the Timer will set the elapsed wall and CPU times over the last lap to their maximum values across the provided communicator. This synchronization is only performed if Timer::stop() is called before the timer is queried for time duration values.
|
inline |
Return a reference to the data structure containing basic statistics on the last lap's wall time measured across all MPI processes in the given communicator. This structure does not contain meaningful values until Timer::stop() has been called.
|
inline |
Return a reference to the data structure containing basic statistics on the accumulated wall time measured across all MPI processes in the given communicator. This structure does not contain meaningful values until Timer::stop() has been called.
|
inline |
Print the data returned by Timer::get_last_lap_wall_time_data() to the given stream.
|
inline |
Print the data returned by Timer::get_accumulated_wall_time_data() to the given stream.
| void Timer::start | ( | ) |
| void Timer::stop | ( | ) |
| void Timer::reset | ( | ) |
|
inline |
Equivalent to calling Timer::reset() followed by calling Timer::start().
| bool Timer::is_running | ( | ) | const |
| double Timer::wall_time | ( | ) | const |
Return the current accumulated wall time (including the current lap, if the timer is running) in seconds without stopping the timer.
If the timer is running, and an MPI communicator was provided to the constructor of this class and the lap times are synchronized, the portion of the wall time up to the end of the last lap is synchronized between processors. However, the currently running lap is not synchronized and can therefore vary between processors. This avoids introducing unnecessary synchronization in this function.
| double Timer::last_wall_time | ( | ) | const |
Return the wall time of the last lap in seconds. The timer is not stopped by this function.
If an MPI communicator was provided to the constructor and sync_lap_times is true, then the returned lap time is synchronized over all processors in the communicator (i.e., the lap time was set to the maximum wall time of all processors).
| double Timer::cpu_time | ( | ) | const |
Return the accumulated CPU time (including the current lap, if the timer is running) in seconds without stopping the timer.
If an MPI communicator was provided to the constructor then the returned value is the sum of all accumulated CPU times over all processors in the communicator.
| double Timer::last_cpu_time | ( | ) | const |
Return the CPU time of the last lap in seconds. The timer is not stopped by this function.
If an MPI communicator was provided to the constructor and sync_lap_times is true, then the returned CPU time is synchronized across all processors (i.e., the lap time was set to the maximum CPU time of all processors).
Note, that unlike cpu_time() the result is not summed across processors.
| unsigned int Timer::n_laps | ( | ) | const |
|
private |
After a lap has been stopped it is necessary to update the accumulated wall time and CPU time with the results of the last lap. However, if sync_lap_times is set to true this requires MPI communication in parallel models before the update. We delay this communication and the update until the results are needed instead of immediately updating after calling stop(). This is useful because it avoids MPI communication if the timer is stopped because of stack unwinding during exception handling. In serial models this function simply updates the accumulated wall time and CPU time with the last lap time.
|
mutableprivate |
Collection of wall time measurements. Marked as mutable for the reasons outlined in the documentation of Timer::is_synchronized.
|
mutableprivate |
Collection of CPU time measurements. Marked as mutable for the reasons outlined in the documentation of Timer::is_synchronized.
|
private |
|
mutableprivate |
Store whether the timer results are currently synchronized across MPI processes. Marked as mutable, as synchronization is delayed until the results are needed for the reasons discussed in the documentation of synchronize_and_update(). This means output functions marked as const like cpu_time() will still update this variable if necessary.
|
private |
|
private |
Store whether or not the wall time and CPU time will be synchronized across the communicator in synchronize_and_update().
|
mutableprivate |
A structure for parallel wall time measurement that includes the minimum, maximum, and average over all processors known to the MPI communicator of the last lap time. Marked as mutable for the reasons outlined in the documentation of Timer::is_synchronized.
|
mutableprivate |
A structure for parallel wall time measurement that includes the minimum time recorded among all processes, the maximum time as well as the average time defined as the sum of all individual times divided by the number of MPI processes in the MPI_Comm for the total run time. Marked as mutable for the reasons outlined in the documentation of Timer::is_synchronized.
|
private |
|
mutableprivate |
A lock that makes sure that this class gives reasonable results even when used with several threads. Note that thread-safety with a timer that is shared between different threads is hard to establish, and it is in particular discouraged to have multiple threads starting and stopping the timer. This case only works if each thread makes sure the timer is not already running before starting it, and stopping the timer before any other thread can use it.
1.9.8