1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
======================
Measuring elapsed time
======================
To make it easier to measure how long operations take, we have helpers for both JavaScript and C++.
These helpers record the elapsed time into histograms, so you have to create suitable :doc:`histograms` for them first.
From JavaScript
===============
JavaScript can measure elapsed time using TelemetryStopwatch.
``TelemetryStopwatch`` is a helper that simplifies recording elapsed time (in milliseconds) into histograms (plain or keyed).
API:
.. code-block:: js
TelemetryStopwatch = {
// Start, check if running, cancel & finish recording elapsed time into a
// histogram.
// |aObject| is optional. If specified, the timer is associated with this
// object, so multiple time measurements can be done concurrently.
start(histogramId, aObject);
running(histogramId, aObject);
cancel(histogramId, aObject);
finish(histogramId, aObject);
// Start, check if running, cancel & finish recording elapsed time into a
// keyed histogram.
// |key| specifies the key to record into.
// |aObject| is optional and used as above.
startKeyed(histogramId, key, aObject);
runningKeyed(histogramId, key, aObject);
cancelKeyed(histogramId, key, aObject);
finishKeyed(histogramId, key, aObject);
};
Example:
.. code-block:: js
TelemetryStopwatch.start("SAMPLE_FILE_LOAD_TIME_MS");
// ... start loading file.
if (failedToOpenFile) {
// Cancel this if the operation failed early etc.
TelemetryStopwatch.cancel("SAMPLE_FILE_LOAD_TIME_MS");
return;
}
// ... do more work.
TelemetryStopwatch.finish("SAMPLE_FILE_LOAD_TIME_MS");
// Another loading attempt? Start stopwatch again if
// not already running.
if (!TelemetryStopwatch.running("SAMPLE_FILE_LOAD_TIME_MS")) {
TelemetryStopwatch.start("SAMPLE_FILE_LOAD_TIME_MS");
}
// Periodically, it's necessary to attempt to finish a
// TelemetryStopwatch that's already been canceled or
// finished. Normally, that throws a warning to the
// console. If the TelemetryStopwatch being possibly
// canceled or finished is expected behaviour, the
// warning can be suppressed by passing the optional
// aCanceledOkay argument.
// ... suppress warning on a previously finished
// TelemetryStopwatch
TelemetryStopwatch.finish("SAMPLE_FILE_LOAD_TIME_MS", null,
true /* aCanceledOkay */);
From C++
========
API:
.. code-block:: cpp
// This helper class is the preferred way to record elapsed time.
template<HistogramID id>
class AutoTimer {
// Record into a plain histogram.
explicit AutoTimer(TimeStamp aStart = TimeStamp::Now());
// Record into a keyed histogram, with key |aKey|.
explicit AutoTimer(const nsCString& aKey,
TimeStamp aStart = TimeStamp::Now());
};
// If the Histogram id is not known at compile time:
class RuntimeAutoTimer {
// Record into a plain histogram.
explicit RuntimeAutoTimer(Telemetry::HistogramID aId,
TimeStamp aStart = TimeStamp::Now());
// Record into a keyed histogram, with key |aKey|.
explicit RuntimeAutoTimer(Telemetry::HistogramID aId,
const nsCString& aKey,
TimeStamp aStart = TimeStamp::Now());
};
void AccumulateTimeDelta(HistogramID id, TimeStamp start, TimeStamp end = TimeStamp::Now());
void AccumulateTimeDelta(HistogramID id, const nsCString& key, TimeStamp start, TimeStamp end = TimeStamp::Now());
Example:
.. code-block:: cpp
{
Telemetry::AutoTimer<Telemetry::FIND_PLUGINS> telemetry;
// ... scan disk for plugins.
}
// When leaving the scope, AutoTimers destructor will record the time that passed.
// If the histogram id is not known at compile time.
{
Telemetry::RuntimeAutoTimer telemetry(Telemetry::FIND_PLUGINS);
// ... scan disk for plugins.
}
// When leaving the scope, AutoTimers destructor will record the time that passed.
|
