blob: df58cb1c9413ef94f8697a41d1172225f0425758 (
plain)
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
@system nothrow @nogc unittest
{
import std.datetime.stopwatch;
import core.thread : Thread;
{
auto sw = StopWatch(AutoStart.yes);
assert(sw.running);
Thread.sleep(usecs(1));
assert(sw.peek() > Duration.zero);
}
{
auto sw = StopWatch(AutoStart.no);
assert(!sw.running);
Thread.sleep(usecs(1));
assert(sw.peek() == Duration.zero);
}
{
StopWatch sw;
assert(!sw.running);
Thread.sleep(usecs(1));
assert(sw.peek() == Duration.zero);
}
assert(StopWatch.init == StopWatch(AutoStart.no));
assert(StopWatch.init != StopWatch(AutoStart.yes));
}
@system nothrow @nogc unittest
{
import std.datetime.stopwatch;
import core.thread : Thread;
auto sw = StopWatch(AutoStart.yes);
Thread.sleep(usecs(1));
sw.stop();
assert(sw.peek() > Duration.zero);
sw.reset();
assert(sw.peek() == Duration.zero);
}
@system nothrow @nogc unittest
{
import std.datetime.stopwatch;
import core.thread : Thread;
StopWatch sw;
assert(!sw.running);
assert(sw.peek() == Duration.zero);
sw.start();
assert(sw.running);
Thread.sleep(usecs(1));
assert(sw.peek() > Duration.zero);
}
@system nothrow @nogc unittest
{
import std.datetime.stopwatch;
import core.thread : Thread;
auto sw = StopWatch(AutoStart.yes);
assert(sw.running);
Thread.sleep(usecs(1));
immutable t1 = sw.peek();
assert(t1 > Duration.zero);
sw.stop();
assert(!sw.running);
immutable t2 = sw.peek();
assert(t2 >= t1);
immutable t3 = sw.peek();
assert(t2 == t3);
}
@system nothrow @nogc unittest
{
import std.datetime.stopwatch;
import core.thread : Thread;
auto sw = StopWatch(AutoStart.no);
assert(sw.peek() == Duration.zero);
sw.start();
Thread.sleep(usecs(1));
assert(sw.peek() >= usecs(1));
Thread.sleep(usecs(1));
assert(sw.peek() >= usecs(2));
sw.stop();
immutable stopped = sw.peek();
Thread.sleep(usecs(1));
assert(sw.peek() == stopped);
sw.start();
Thread.sleep(usecs(1));
assert(sw.peek() > stopped);
}
@system nothrow @nogc unittest
{
import std.datetime.stopwatch;
import core.thread : Thread;
StopWatch sw;
sw.setTimeElapsed(hours(1));
// As discussed in MonoTime's documentation, converting between
// Duration and ticks is not exact, though it will be close.
// How exact it is depends on the frequency/resolution of the
// system's monotonic clock.
assert(abs(sw.peek() - hours(1)) < usecs(1));
sw.start();
Thread.sleep(usecs(1));
assert(sw.peek() > hours(1) + usecs(1));
}
@safe nothrow @nogc unittest
{
import std.datetime.stopwatch;
StopWatch sw;
assert(!sw.running);
sw.start();
assert(sw.running);
sw.stop();
assert(!sw.running);
}
@safe nothrow @nogc unittest
{
import std.datetime.stopwatch;
auto sw = StopWatch(AutoStart.no);
sw.start();
// ... Insert operations to be timed here ...
sw.stop();
long msecs = sw.peek.total!"msecs";
long usecs = sw.peek.total!"usecs";
long nsecs = sw.peek.total!"nsecs";
assert(usecs >= msecs * 1000);
assert(nsecs >= usecs * 1000);
}
@system nothrow @nogc unittest
{
import std.datetime.stopwatch;
import core.thread : Thread;
auto sw = StopWatch(AutoStart.yes);
Duration t1 = sw.peek();
Thread.sleep(usecs(1));
Duration t2 = sw.peek();
assert(t2 > t1);
Thread.sleep(usecs(1));
sw.stop();
Duration t3 = sw.peek();
assert(t3 > t2);
Duration t4 = sw.peek();
assert(t3 == t4);
sw.start();
Thread.sleep(usecs(1));
Duration t5 = sw.peek();
assert(t5 > t4);
// If stopping or resetting the StopWatch is not required, then
// MonoTime can easily be used by itself without StopWatch.
auto before = MonoTime.currTime;
// do stuff...
auto timeElapsed = MonoTime.currTime - before;
}
@safe unittest
{
import std.datetime.stopwatch;
import std.conv : to;
int a;
void f0() {}
void f1() { auto b = a; }
void f2() { auto b = to!string(a); }
auto r = benchmark!(f0, f1, f2)(10_000);
Duration f0Result = r[0]; // time f0 took to run 10,000 times
Duration f1Result = r[1]; // time f1 took to run 10,000 times
Duration f2Result = r[2]; // time f2 took to run 10,000 times
}
|
