Class Stopwatch

Nested Relationships

Nested Types

Class Documentation

class Stopwatch

A class representing a stopwatch. 

Stopwatch swatch();

The Stopwatch class can be used to measure execution time of code, algorithms, etc., // TODO: he Stopwatch can be initialized in two time-taking modes, CPU time and real time:

swatch.set_mode(REAL_TIME);

CPU time is the time spent by the processor on a certain piece of code, while real time is the real amount of time taken by a certain piece of code to execute (i.e. in general if you are doing hard work such as image or video editing on a different process the measured time will probably increase).

How does it work? Basically, one wraps the code to be measured with the following method calls:

swatch.start("My astounding algorithm");
// Hic est code
swatch.stop("My astounding algorithm");

A string representing the code ID is provided so that nested portions of code can be profiled separately:

swatch.start("My astounding algorithm");

swatch.start("My astounding algorithm - Super smart init");
// Initialization
swatch.stop("My astounding algorithm - Super smart init");

swatch.start("My astounding algorithm - Main loop");
// Loop
swatch.stop("My astounding algorithm - Main loop");

swatch.stop("My astounding algorithm");

Note: ID strings can be whatever you like, in the previous example I have used “My astounding algorithm - *” only to enforce the fact that the measured code portions are part of My astounding algorithm, but there’s no connection between the three measurements.

If the code for a certain task is scattered through different files or portions of the same file one can use the start-pause-stop method:

swatch.start("Setup");
// First part of setup
swatch.pause("Setup");

swatch.start("Main logic");
// Main logic
swatch.stop("Main logic");

swatch.start("Setup");
// Cleanup (part of the setup)
swatch.stop("Setup");

Finally, to report the results of the measurements just run:

swatch.report("Code ID");

Thou can also provide an additional std::ostream& parameter to report() to redirect the logging on a different output. Also, you can use the get_total/min/max/average_time() methods to get the individual numeric data, without all the details of the logging. You can also extend Stopwatch to implement your own logging syntax.

To report all the measurements:

swatch.report_all();

Same as above, you can redirect the output by providing a std::ostream& parameter.

Public Functions

Stopwatch(StopwatchMode _mode = NONE)

Constructor.

~Stopwatch()

Destructor.

void enable_profiler()

Enable the profiler.

void disable_profiler()

Disable the profiler.

inline bool profiler_status()

Return if the profiler is enable or disable.

bool performance_exists(std::string perf_name)

Tells if a performance with a certain ID exists.

void set_mode(StopwatchMode mode)

Initialize stopwatch to use a certain time taking mode.

Watcher watcher(const std::string &perf_name)

create a Start the stopwatch related to a certain piece of code

void start(const std::string &perf_name)

Start the stopwatch related to a certain piece of code.

void stop(const std::string &perf_name)

Stops the stopwatch related to a certain piece of code.

void pause(const std::string &perf_name)

Stops the stopwatch related to a certain piece of code.

void reset(const std::string &perf_name)

Reset a certain performance record.

void reset_all()

Resets all the performance records.

void report(const std::string &perf_name, int precision = 2, std::ostream &output = std::cout)

Dump the data of a certain performance record.

void report_all(int precision = 2, std::ostream &output = std::cout)

Dump the data of all the performance records.

long double get_total_time(const std::string &perf_name)

Returns total execution time of a certain performance.

long double get_average_time(const std::string &perf_name)

Returns average execution time of a certain performance.

long double get_min_time(const std::string &perf_name)

Returns minimum execution time of a certain performance.

long double get_max_time(const std::string &perf_name)

Returns maximum execution time of a certain performance.

long double get_last_time(const std::string &perf_name)

Return last measurement of a certain performance.

long double get_time_so_far(const std::string &perf_name)

Return the time since the start of the last measurement of a given performance.

void turn_off()

Turn off clock, all the Stopwatch::* methods return without doing anything after this method is called.

void turn_on()

Turn on clock, restore clock operativity after a turn_off().

long double take_time()

Take time, depends on mode.

Protected Functions

PerformanceData &get_or_create_perf(const std::string &perf_name)
void stop_perf(PerformanceData &perf_info, long double clock_end)

Protected Attributes

bool active

Flag to hold the clock’s status.

StopwatchMode mode

Time taking mode.

std::map<std::string, PerformanceData> *records_of

Dynamic collection of performance data.

bool profiler_active

Indicates if the profiler is enabled.

struct PerformanceData

Struct to hold the performance data.

Public Functions

inline PerformanceData()

Public Members

long double clock_start

Start time.

long double total_time

Cumulative total time.

long double min_time

Minimum time.

long double max_time

Maximum time.

long double last_time

Last time.

bool paused

Tells if this performance has been paused, only for internal use

int stops

How many cycles have been this stopwatch executed?

struct Watcher

Public Functions

inline Watcher(Stopwatch &_w, std::string _n, PerformanceData *_p)
inline void start()
inline void stop()

Public Members

Stopwatch &w
std::string n
PerformanceData *p