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 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
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?