VirtualBox

source: vbox/trunk/src/VBox/Runtime/testcase/tstTimerLR.cpp@ 13836

Last change on this file since 13836 was 13836, checked in by vboxsync, 16 years ago

s/ELEMENTS/RT_ELEMENTS/g - retiring ELEMENTS (finally).

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 7.3 KB
Line 
1/* $Id: tstTimerLR.cpp 13836 2008-11-05 02:42:54Z vboxsync $ */
2/** @file
3 * IPRT Testcase - Low Resolution Timers.
4 */
5
6/*
7 * Copyright (C) 2006-2008 Sun Microsystems, Inc.
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 *
26 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
27 * Clara, CA 95054 USA or visit http://www.sun.com if you need
28 * additional information or have any questions.
29 */
30
31/*******************************************************************************
32* Header Files *
33*******************************************************************************/
34#include <iprt/timer.h>
35#include <iprt/time.h>
36#include <iprt/thread.h>
37#include <iprt/runtime.h>
38#include <iprt/stream.h>
39#include <iprt/err.h>
40
41
42
43/*******************************************************************************
44* Global Variables *
45*******************************************************************************/
46static volatile unsigned gcTicks;
47static volatile uint64_t gu64Min;
48static volatile uint64_t gu64Max;
49static volatile uint64_t gu64Prev;
50
51static DECLCALLBACK(void) TimerLRCallback(RTTIMERLR hTimerLR, void *pvUser, uint64_t iTick)
52{
53 gcTicks++;
54
55 const uint64_t u64Now = RTTimeNanoTS();
56 if (gu64Prev)
57 {
58 const uint64_t u64Delta = u64Now - gu64Prev;
59 if (u64Delta < gu64Min)
60 gu64Min = u64Delta;
61 if (u64Delta > gu64Max)
62 gu64Max = u64Delta;
63 }
64 gu64Prev = u64Now;
65}
66
67
68int main()
69{
70 /*
71 * Init runtime
72 */
73 unsigned cErrors = 0;
74 int rc = RTR3Init();
75 if (RT_FAILURE(rc))
76 {
77 RTPrintf("tstTimer: RTR3Init() -> %d\n", rc);
78 return 1;
79 }
80
81 /*
82 * Check that the clock is reliable.
83 */
84 RTPrintf("tstTimer: TESTING - RTTimeNanoTS() for 2sec\n");
85 uint64_t uTSMillies = RTTimeMilliTS();
86 uint64_t uTSBegin = RTTimeNanoTS();
87 uint64_t uTSLast = uTSBegin;
88 uint64_t uTSDiff;
89 uint64_t cIterations = 0;
90
91 do
92 {
93 uint64_t uTS = RTTimeNanoTS();
94 if (uTS < uTSLast)
95 {
96 RTPrintf("tstTimer: FAILURE - RTTimeNanoTS() is unreliable. uTS=%RU64 uTSLast=%RU64\n", uTS, uTSLast);
97 cErrors++;
98 }
99 if (++cIterations > (2*1000*1000*1000))
100 {
101 RTPrintf("tstTimer: FAILURE - RTTimeNanoTS() is unreliable. cIterations=%RU64 uTS=%RU64 uTSBegin=%RU64\n", cIterations, uTS, uTSBegin);
102 return 1;
103 }
104 uTSLast = uTS;
105 uTSDiff = uTSLast - uTSBegin;
106 } while (uTSDiff < (2*1000*1000*1000));
107 uTSMillies = RTTimeMilliTS() - uTSMillies;
108 if (uTSMillies >= 2500 || uTSMillies <= 1500)
109 {
110 RTPrintf("tstTimer: FAILURE - uTSMillies=%RI64 uTSBegin=%RU64 uTSLast=%RU64 uTSDiff=%RU64\n",
111 uTSMillies, uTSBegin, uTSLast, uTSDiff);
112 cErrors++;
113 }
114 if (!cErrors)
115 RTPrintf("tstTimer: OK - RTTimeNanoTS()\n");
116
117 /*
118 * Tests.
119 */
120 static struct
121 {
122 unsigned uMilliesInterval;
123 unsigned uMilliesWait;
124 unsigned cLower;
125 unsigned cUpper;
126 } aTests[] =
127 {
128 { 1000, 2500, 3, 3 }, /* (keep in mind the immediate first tick) */
129 { 250, 2000, 6, 10 },
130 { 100, 2000, 17, 23 },
131 };
132
133 unsigned i = 0;
134 for (i = 0; i < RT_ELEMENTS(aTests); i++)
135 {
136 //aTests[i].cLower = (aTests[i].uMilliesWait - aTests[i].uMilliesWait / 10) / aTests[i].uMilliesInterval;
137 //aTests[i].cUpper = (aTests[i].uMilliesWait + aTests[i].uMilliesWait / 10) / aTests[i].uMilliesInterval;
138
139 RTPrintf("\n"
140 "tstTimer: TESTING - %d ms interval, %d ms wait, expects %d-%d ticks.\n",
141 aTests[i].uMilliesInterval, aTests[i].uMilliesWait, aTests[i].cLower, aTests[i].cUpper);
142
143 /*
144 * Start timer which ticks every 10ms.
145 */
146 gcTicks = 0;
147 RTTIMERLR hTimerLR;
148 gu64Max = 0;
149 gu64Min = UINT64_MAX;
150 gu64Prev = 0;
151 rc = RTTimerLRCreateEx(&hTimerLR, aTests[i].uMilliesInterval * (uint64_t)1000000, 0, TimerLRCallback, NULL);
152 if (RT_FAILURE(rc))
153 {
154 RTPrintf("RTTimerLRCreateEX(,%u*1M,,,) -> %d\n", aTests[i].uMilliesInterval, rc);
155 cErrors++;
156 continue;
157 }
158
159 /*
160 * Start the timer an actively wait for it for the period requested.
161 */
162 uint64_t uTSBegin = RTTimeNanoTS();
163 rc = RTTimerLRStart(hTimerLR, 0);
164 if (RT_FAILURE(rc))
165 {
166 RTPrintf("tstTimer: FAILURE - RTTimerLRStart() -> %Rrc\n", rc);
167 cErrors++;
168 }
169
170 while (RTTimeNanoTS() - uTSBegin < (uint64_t)aTests[i].uMilliesWait * 1000000)
171 /* nothing */;
172
173 /* don't stop it, destroy it because there are potential races in destroying an active timer. */
174 rc = RTTimerLRDestroy(hTimerLR);
175 if (RT_FAILURE(rc))
176 {
177 RTPrintf("tstTimer: FAILURE - RTTimerLRDestroy() -> %d gcTicks=%d\n", rc, gcTicks);
178 cErrors++;
179 }
180
181 uint64_t uTSEnd = RTTimeNanoTS();
182 uint64_t uTSDiff = uTSEnd - uTSBegin;
183 RTPrintf("uTS=%RI64 (%RU64 - %RU64)\n", uTSDiff, uTSBegin, uTSEnd);
184
185 /* Check that it really stopped. */
186 unsigned cTicks = gcTicks;
187 RTThreadSleep(aTests[i].uMilliesInterval * 2);
188 if (gcTicks != cTicks)
189 {
190 RTPrintf("tstTimer: FAILURE - RTTimerLRDestroy() didn't really stop the timer! gcTicks=%d cTicks=%d\n", gcTicks, cTicks);
191 cErrors++;
192 continue;
193 }
194
195 /*
196 * Check the number of ticks.
197 */
198 if (gcTicks < aTests[i].cLower)
199 {
200 RTPrintf("tstTimer: FAILURE - Too few ticks gcTicks=%d (expected %d-%d)", gcTicks, aTests[i].cUpper, aTests[i].cLower);
201 cErrors++;
202 }
203 else if (gcTicks > aTests[i].cUpper)
204 {
205 RTPrintf("tstTimer: FAILURE - Too many ticks gcTicks=%d (expected %d-%d)", gcTicks, aTests[i].cUpper, aTests[i].cLower);
206 cErrors++;
207 }
208 else
209 RTPrintf("tstTimer: OK - gcTicks=%d", gcTicks);
210 RTPrintf(" min=%RU64 max=%RU64\n", gu64Min, gu64Max);
211 }
212
213 /*
214 * Test multiple timers running at once.
215 */
216 /** @todo multiple LR timer testcase. */
217
218 /*
219 * Summary.
220 */
221 if (!cErrors)
222 RTPrintf("tstTimer: SUCCESS\n");
223 else
224 RTPrintf("tstTimer: FAILURE %d errors\n", cErrors);
225 return !!cErrors;
226}
227
228
229
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette