VirtualBox

source: vbox/trunk/src/VBox/HostDrivers/Support/testcase/tstSupSem.cpp@ 64281

Last change on this file since 64281 was 62490, checked in by vboxsync, 8 years ago

(C) 2016
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 29.9 KB
Line 
1/* $Id: tstSupSem.cpp 62490 2016-07-22 18:41:49Z vboxsync $ */
2/** @file
3 * Support Library Testcase - Ring-3 Semaphore interface.
4 */
5
6/*
7 * Copyright (C) 2009-2016 Oracle Corporation
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
27
28/*********************************************************************************************************************************
29* Header Files *
30*********************************************************************************************************************************/
31#include <VBox/sup.h>
32
33#include <VBox/param.h>
34#include <iprt/err.h>
35#include <iprt/initterm.h>
36#include <iprt/message.h>
37#include <iprt/stream.h>
38#include <iprt/test.h>
39#include <iprt/thread.h>
40#include <iprt/process.h>
41#include <iprt/env.h>
42#include <iprt/string.h>
43#include <iprt/time.h>
44
45
46/*********************************************************************************************************************************
47* Structures and Typedefs *
48*********************************************************************************************************************************/
49static PSUPDRVSESSION g_pSession;
50static RTTEST g_hTest;
51static uint32_t g_cMillies; /* Used by the interruptible tests. */
52
53
54
55static DECLCALLBACK(int) tstSupSemInterruptibleSRE(RTTHREAD hSelf, void *pvUser)
56{
57 SUPSEMEVENT hEvent = (SUPSEMEVENT)pvUser;
58 RTThreadUserSignal(hSelf);
59 return SUPSemEventWaitNoResume(g_pSession, hEvent, g_cMillies);
60}
61
62
63static DECLCALLBACK(int) tstSupSemInterruptibleMRE(RTTHREAD hSelf, void *pvUser)
64{
65 SUPSEMEVENTMULTI hEventMulti = (SUPSEMEVENTMULTI)pvUser;
66 RTThreadUserSignal(hSelf);
67 return SUPSemEventMultiWaitNoResume(g_pSession, hEventMulti, g_cMillies);
68}
69
70
71int main(int argc, char **argv)
72{
73 bool fSys = true;
74 bool fGip = false;
75#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
76 fGip = true;
77#endif
78
79 /*
80 * Init.
81 */
82 int rc = RTR3InitExe(argc, &argv, RTR3INIT_FLAGS_SUPLIB);
83 if (RT_FAILURE(rc))
84 return RTMsgInitFailure(rc);
85
86 if (argc == 2 && !strcmp(argv[1], "child"))
87 {
88 RTThreadSleep(300);
89 return 0;
90 }
91
92 RTTEST hTest;
93 rc = RTTestCreate("tstSupSem", &hTest);
94 if (RT_FAILURE(rc))
95 {
96 RTPrintf("tstSupSem: fatal error: RTTestCreate failed with rc=%Rrc\n", rc);
97 return 1;
98 }
99 g_hTest = hTest;
100
101 PSUPDRVSESSION pSession;
102 rc = SUPR3Init(&pSession);
103 if (RT_FAILURE(rc))
104 {
105 RTTestFailed(hTest, "SUPR3Init failed with rc=%Rrc\n", rc);
106 return RTTestSummaryAndDestroy(hTest);
107 }
108 g_pSession = pSession;
109 RTTestBanner(hTest);
110
111 /*
112 * Basic API checks.
113 */
114 RTTestSub(hTest, "Single Release Event (SRE) API");
115 SUPSEMEVENT hEvent = NIL_SUPSEMEVENT;
116 RTTESTI_CHECK_RC(SUPSemEventCreate(pSession, &hEvent), VINF_SUCCESS);
117 RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 0), VERR_TIMEOUT);
118 RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 1), VERR_TIMEOUT);
119 RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 2), VERR_TIMEOUT);
120 RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 8), VERR_TIMEOUT);
121 RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent,20), VERR_TIMEOUT);
122 RTTESTI_CHECK_RC(SUPSemEventSignal(pSession, hEvent), VINF_SUCCESS);
123 RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 0), VINF_SUCCESS);
124 RTTESTI_CHECK_RC(SUPSemEventSignal(pSession, hEvent), VINF_SUCCESS);
125 RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 1), VINF_SUCCESS);
126 RTTESTI_CHECK_RC(SUPSemEventSignal(pSession, hEvent), VINF_SUCCESS);
127 RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 2), VINF_SUCCESS);
128 RTTESTI_CHECK_RC(SUPSemEventSignal(pSession, hEvent), VINF_SUCCESS);
129 RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 8), VINF_SUCCESS);
130 RTTESTI_CHECK_RC(SUPSemEventSignal(pSession, hEvent), VINF_SUCCESS);
131 RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 20), VINF_SUCCESS);
132 RTTESTI_CHECK_RC(SUPSemEventSignal(pSession, hEvent), VINF_SUCCESS);
133 RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent,1000),VINF_SUCCESS);
134 RTTESTI_CHECK_RC(SUPSemEventSignal(pSession, hEvent), VINF_SUCCESS);
135 RTTESTI_CHECK_RC(SUPSemEventSignal(pSession, hEvent), VINF_SUCCESS);
136 RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 0), VINF_SUCCESS);
137 RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 0), VERR_TIMEOUT);
138 RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 1), VERR_TIMEOUT);
139 RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 2), VERR_TIMEOUT);
140 RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 8), VERR_TIMEOUT);
141 RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent,20), VERR_TIMEOUT);
142 RTTESTI_CHECK_RC(SUPSemEventClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
143 RTTESTI_CHECK_RC(SUPSemEventClose(pSession, hEvent), VERR_INVALID_HANDLE);
144 RTTESTI_CHECK_RC(SUPSemEventClose(pSession, NIL_SUPSEMEVENT), VINF_SUCCESS);
145
146 RTTestSub(hTest, "Multiple Release Event (MRE) API");
147 SUPSEMEVENTMULTI hEventMulti = NIL_SUPSEMEVENT;
148 RTTESTI_CHECK_RC(SUPSemEventMultiCreate(pSession, &hEventMulti), VINF_SUCCESS);
149 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 0), VERR_TIMEOUT);
150 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 1), VERR_TIMEOUT);
151 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 2), VERR_TIMEOUT);
152 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 8), VERR_TIMEOUT);
153 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti,20), VERR_TIMEOUT);
154 RTTESTI_CHECK_RC(SUPSemEventMultiSignal(pSession, hEventMulti), VINF_SUCCESS);
155 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 0), VINF_SUCCESS);
156 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 0), VINF_SUCCESS);
157 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 0), VINF_SUCCESS);
158 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 1), VINF_SUCCESS);
159 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 2), VINF_SUCCESS);
160 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 8), VINF_SUCCESS);
161 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti,20), VINF_SUCCESS);
162 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti,1000), VINF_SUCCESS);
163 RTTESTI_CHECK_RC(SUPSemEventMultiSignal(pSession, hEventMulti), VINF_SUCCESS);
164 RTTESTI_CHECK_RC(SUPSemEventMultiSignal(pSession, hEventMulti), VINF_SUCCESS);
165 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 0), VINF_SUCCESS);
166 RTTESTI_CHECK_RC(SUPSemEventMultiReset(pSession, hEventMulti), VINF_SUCCESS);
167 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 0), VERR_TIMEOUT);
168 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 1), VERR_TIMEOUT);
169 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 2), VERR_TIMEOUT);
170 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 8), VERR_TIMEOUT);
171 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti,20), VERR_TIMEOUT);
172 RTTESTI_CHECK_RC(SUPSemEventMultiSignal(pSession, hEventMulti), VINF_SUCCESS);
173 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 0), VINF_SUCCESS);
174 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 1), VINF_SUCCESS);
175 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 2), VINF_SUCCESS);
176 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 8), VINF_SUCCESS);
177 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 20), VINF_SUCCESS);
178 RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti,1000), VINF_SUCCESS);
179 RTTESTI_CHECK_RC(SUPSemEventMultiClose(pSession, hEventMulti), VINF_OBJECT_DESTROYED);
180 RTTESTI_CHECK_RC(SUPSemEventMultiClose(pSession, hEventMulti), VERR_INVALID_HANDLE);
181 RTTESTI_CHECK_RC(SUPSemEventMultiClose(pSession, NIL_SUPSEMEVENTMULTI), VINF_SUCCESS);
182
183#if !defined(RT_OS_OS2) && !defined(RT_OS_WINDOWS)
184 RTTestSub(hTest, "SRE Interruptibility");
185 RTTESTI_CHECK_RC(SUPSemEventCreate(pSession, &hEvent), VINF_SUCCESS);
186 g_cMillies = RT_INDEFINITE_WAIT;
187 RTTHREAD hThread = NIL_RTTHREAD;
188 RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemInterruptibleSRE, (void *)hEvent, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "IntSRE"), VINF_SUCCESS);
189 RTTESTI_CHECK_RC(RTThreadUserWait(hThread, 60*1000), VINF_SUCCESS);
190 RTThreadSleep(120);
191 RTThreadPoke(hThread);
192 int rcThread = VINF_SUCCESS;
193 RTTESTI_CHECK_RC(RTThreadWait(hThread, 60*1000, &rcThread), VINF_SUCCESS);
194 RTTESTI_CHECK_RC(rcThread, VERR_INTERRUPTED);
195 RTTESTI_CHECK_RC(SUPSemEventClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
196
197 RTTESTI_CHECK_RC(SUPSemEventCreate(pSession, &hEvent), VINF_SUCCESS);
198 g_cMillies = 120*1000;
199 hThread = NIL_RTTHREAD;
200 RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemInterruptibleSRE, (void *)hEvent, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "IntSRE"), VINF_SUCCESS);
201 RTTESTI_CHECK_RC(RTThreadUserWait(hThread, 60*1000), VINF_SUCCESS);
202 RTThreadSleep(120);
203 RTThreadPoke(hThread);
204 rcThread = VINF_SUCCESS;
205 RTTESTI_CHECK_RC(RTThreadWait(hThread, 60*1000, &rcThread), VINF_SUCCESS);
206 RTTESTI_CHECK_RC(rcThread, VERR_INTERRUPTED);
207 RTTESTI_CHECK_RC(SUPSemEventClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
208
209
210 RTTestSub(hTest, "MRE Interruptibility");
211 RTTESTI_CHECK_RC(SUPSemEventMultiCreate(pSession, &hEventMulti), VINF_SUCCESS);
212 g_cMillies = RT_INDEFINITE_WAIT;
213 hThread = NIL_RTTHREAD;
214 RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemInterruptibleMRE, (void *)hEventMulti, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "IntMRE"), VINF_SUCCESS);
215 RTTESTI_CHECK_RC(RTThreadUserWait(hThread, 60*1000), VINF_SUCCESS);
216 RTThreadSleep(120);
217 RTThreadPoke(hThread);
218 rcThread = VINF_SUCCESS;
219 RTTESTI_CHECK_RC(RTThreadWait(hThread, 60*1000, &rcThread), VINF_SUCCESS);
220 RTTESTI_CHECK_RC(rcThread, VERR_INTERRUPTED);
221 RTTESTI_CHECK_RC(SUPSemEventMultiClose(pSession, hEventMulti), VINF_OBJECT_DESTROYED);
222
223 RTTESTI_CHECK_RC(SUPSemEventMultiCreate(pSession, &hEventMulti), VINF_SUCCESS);
224 g_cMillies = 120*1000;
225 hThread = NIL_RTTHREAD;
226 RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemInterruptibleMRE, (void *)hEventMulti, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "IntMRE"), VINF_SUCCESS);
227 RTTESTI_CHECK_RC(RTThreadUserWait(hThread, 60*1000), VINF_SUCCESS);
228 RTThreadSleep(120);
229 RTThreadPoke(hThread);
230 rcThread = VINF_SUCCESS;
231 RTTESTI_CHECK_RC(RTThreadWait(hThread, 60*1000, &rcThread), VINF_SUCCESS);
232 RTTESTI_CHECK_RC(rcThread, VERR_INTERRUPTED);
233 RTTESTI_CHECK_RC(SUPSemEventMultiClose(pSession, hEventMulti), VINF_OBJECT_DESTROYED);
234
235 /*
236 * Fork test.
237 * Spawn a thread waiting for an event, then spawn a new child process (of
238 * ourselves) and make sure that this does not alter the intended behaviour
239 * of our event semaphore implementation (see @bugref{5090}).
240 */
241 RTTestSub(hTest, "SRE Process Spawn");
242 hThread = NIL_RTTHREAD;
243 g_cMillies = 120*1000;
244 RTTESTI_CHECK_RC(SUPSemEventCreate(pSession, &hEvent), VINF_SUCCESS);
245 RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemInterruptibleSRE, (void *)hEvent, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "IntSRE"), VINF_SUCCESS);
246
247 const char *apszArgs[3] = { argv[0], "child", NULL };
248 RTPROCESS Process = NIL_RTPROCESS;
249 RTThreadSleep(250);
250 RTTESTI_CHECK_RC(RTProcCreate(apszArgs[0], apszArgs, RTENV_DEFAULT, 0, &Process), VINF_SUCCESS);
251
252 RTThreadSleep(250);
253 RTTESTI_CHECK_RC(SUPSemEventSignal(pSession, hEvent), VINF_SUCCESS);
254
255 rcThread = VERR_GENERAL_FAILURE;
256 RTTESTI_CHECK_RC(RTThreadWait(hThread, 120*1000, &rcThread), VINF_SUCCESS);
257 RTTESTI_CHECK_RC(rcThread, VINF_SUCCESS);
258 RTTESTI_CHECK_RC(SUPSemEventClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
259
260
261 RTTestSub(hTest, "MRE Process Spawn");
262 hThread = NIL_RTTHREAD;
263 g_cMillies = 120*1000;
264 RTTESTI_CHECK_RC(SUPSemEventMultiCreate(pSession, &hEvent), VINF_SUCCESS);
265 RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemInterruptibleMRE, (void *)hEvent, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "IntSRE"), VINF_SUCCESS);
266
267 RTTHREAD hThread2 = NIL_RTTHREAD;
268 RTTESTI_CHECK_RC(RTThreadCreate(&hThread2, tstSupSemInterruptibleMRE, (void *)hEvent, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "IntSRE"), VINF_SUCCESS);
269
270 Process = NIL_RTPROCESS;
271 RTThreadSleep(250);
272 RTTESTI_CHECK_RC(RTProcCreate(apszArgs[0], apszArgs, RTENV_DEFAULT, 0, &Process), VINF_SUCCESS);
273
274 RTThreadSleep(250);
275 RTTESTI_CHECK_RC(SUPSemEventMultiSignal(pSession, hEvent), VINF_SUCCESS);
276
277 rcThread = VERR_GENERAL_FAILURE;
278 RTTESTI_CHECK_RC(RTThreadWait(hThread, 120*1000, &rcThread), VINF_SUCCESS);
279 RTTESTI_CHECK_RC(rcThread, VINF_SUCCESS);
280
281 int rcThread2 = VERR_GENERAL_FAILURE;
282 RTTESTI_CHECK_RC(RTThreadWait(hThread2, 120*1000, &rcThread2), VINF_SUCCESS);
283 RTTESTI_CHECK_RC(rcThread2, VINF_SUCCESS);
284
285 RTTESTI_CHECK_RC(SUPSemEventMultiClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
286
287#endif /* !OS2 && !WINDOWS */
288
289 {
290
291#define LOOP_COUNT 20
292 static unsigned const s_acMsIntervals[] = { 0, 1, 2, 3, 4, 8, 10, 16, 32 };
293 if (RTTestErrorCount(hTest) == 0)
294 {
295 RTTestSub(hTest, "SRE Timeout Accuracy (ms)");
296 RTTESTI_CHECK_RC(SUPSemEventCreate(pSession, &hEvent), VINF_SUCCESS);
297
298 uint32_t cInterrupted = 0;
299 for (unsigned i = 0; i < RT_ELEMENTS(s_acMsIntervals); i++)
300 {
301 uint64_t cMs = s_acMsIntervals[i];
302 uint64_t cNsMinSys = UINT64_MAX;
303 uint64_t cNsMin = UINT64_MAX;
304 uint64_t cNsTotalSys= 0;
305 uint64_t cNsTotal = 0;
306 unsigned cLoops = 0;
307 while (cLoops < LOOP_COUNT)
308 {
309 uint64_t u64StartSys = RTTimeSystemNanoTS();
310 uint64_t u64Start = RTTimeNanoTS();
311 int rcX = SUPSemEventWaitNoResume(pSession, hEvent, cMs);
312 uint64_t cNsElapsedSys = RTTimeSystemNanoTS() - u64StartSys;
313 uint64_t cNsElapsed = RTTimeNanoTS() - u64Start;
314
315 if (rcX == VERR_INTERRUPTED)
316 {
317 cInterrupted++;
318 continue; /* retry */
319 }
320 if (rcX != VERR_TIMEOUT)
321 RTTestFailed(hTest, "%Rrc cLoops=%u cMs=%u", rcX, cLoops, cMs);
322
323 if (cNsElapsedSys < cNsMinSys)
324 cNsMinSys = cNsElapsedSys;
325 if (cNsElapsed < cNsMin)
326 cNsMin = cNsElapsed;
327 cNsTotalSys += cNsElapsedSys;
328 cNsTotal += cNsElapsed;
329 cLoops++;
330 }
331 if (fSys)
332 {
333 RTTestValueF(hTest, cNsMinSys, RTTESTUNIT_NS, "%u ms min (clock=sys)", cMs);
334 RTTestValueF(hTest, cNsTotalSys / cLoops, RTTESTUNIT_NS, "%u ms avg (clock=sys)", cMs);
335 }
336 if (fGip)
337 {
338 RTTestValueF(hTest, cNsMin, RTTESTUNIT_NS, "%u ms min (clock=gip)", cMs);
339 RTTestValueF(hTest, cNsTotal / cLoops, RTTESTUNIT_NS, "%u ms avg (clock=gip)", cMs);
340 }
341 }
342
343 RTTESTI_CHECK_RC(SUPSemEventClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
344 RTTestValueF(hTest, cInterrupted, RTTESTUNIT_OCCURRENCES, "VERR_INTERRUPTED returned");
345 }
346
347 if (RTTestErrorCount(hTest) == 0)
348 {
349 RTTestSub(hTest, "MRE Timeout Accuracy (ms)");
350 RTTESTI_CHECK_RC(SUPSemEventMultiCreate(pSession, &hEvent), VINF_SUCCESS);
351
352 uint32_t cInterrupted = 0;
353 for (unsigned i = 0; i < RT_ELEMENTS(s_acMsIntervals); i++)
354 {
355 uint64_t cMs = s_acMsIntervals[i];
356 uint64_t cNsMinSys = UINT64_MAX;
357 uint64_t cNsMin = UINT64_MAX;
358 uint64_t cNsTotalSys= 0;
359 uint64_t cNsTotal = 0;
360 unsigned cLoops = 0;
361 while (cLoops < LOOP_COUNT)
362 {
363 uint64_t u64StartSys = RTTimeSystemNanoTS();
364 uint64_t u64Start = RTTimeNanoTS();
365 int rcX = SUPSemEventMultiWaitNoResume(pSession, hEvent, cMs);
366 uint64_t cNsElapsedSys = RTTimeSystemNanoTS() - u64StartSys;
367 uint64_t cNsElapsed = RTTimeNanoTS() - u64Start;
368
369 if (rcX == VERR_INTERRUPTED)
370 {
371 cInterrupted++;
372 continue; /* retry */
373 }
374 if (rcX != VERR_TIMEOUT)
375 RTTestFailed(hTest, "%Rrc cLoops=%u cMs=%u", rcX, cLoops, cMs);
376
377 if (cNsElapsedSys < cNsMinSys)
378 cNsMinSys = cNsElapsedSys;
379 if (cNsElapsed < cNsMin)
380 cNsMin = cNsElapsed;
381 cNsTotalSys += cNsElapsedSys;
382 cNsTotal += cNsElapsed;
383 cLoops++;
384 }
385 if (fSys)
386 {
387 RTTestValueF(hTest, cNsMinSys, RTTESTUNIT_NS, "%u ms min (clock=sys)", cMs);
388 RTTestValueF(hTest, cNsTotalSys / cLoops, RTTESTUNIT_NS, "%u ms avg (clock=sys)", cMs);
389 }
390 if (fGip)
391 {
392 RTTestValueF(hTest, cNsMin, RTTESTUNIT_NS, "%u ms min (clock=gip)", cMs);
393 RTTestValueF(hTest, cNsTotal / cLoops, RTTESTUNIT_NS, "%u ms avg (clock=gip)", cMs);
394 }
395 }
396
397 RTTESTI_CHECK_RC(SUPSemEventMultiClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
398 RTTestValueF(hTest, cInterrupted, RTTESTUNIT_OCCURRENCES, "VERR_INTERRUPTED returned");
399 }
400 }
401
402 {
403 static uint32_t const s_acNsIntervals[] =
404 {
405 0, 1000, 5000, 15000, 30000, 50000, 100000, 250000, 500000, 750000, 900000, 1500000, 2200000
406 };
407
408 if (RTTestErrorCount(hTest) == 0)
409 {
410 RTTestSub(hTest, "SUPSemEventWaitNsRelIntr Accuracy");
411 RTTestValueF(hTest, SUPSemEventGetResolution(pSession), RTTESTUNIT_NS, "SRE resolution");
412 RTTESTI_CHECK_RC(SUPSemEventCreate(pSession, &hEvent), VINF_SUCCESS);
413
414 uint32_t cInterrupted = 0;
415 for (unsigned i = 0; i < RT_ELEMENTS(s_acNsIntervals); i++)
416 {
417 uint64_t cNs = s_acNsIntervals[i];
418 uint64_t cNsMinSys = UINT64_MAX;
419 uint64_t cNsMin = UINT64_MAX;
420 uint64_t cNsTotalSys= 0;
421 uint64_t cNsTotal = 0;
422 unsigned cLoops = 0;
423 while (cLoops < LOOP_COUNT)
424 {
425 uint64_t u64StartSys = RTTimeSystemNanoTS();
426 uint64_t u64Start = RTTimeNanoTS();
427 int rcX = SUPSemEventWaitNsRelIntr(pSession, hEvent, cNs);
428 uint64_t cNsElapsedSys = RTTimeSystemNanoTS() - u64StartSys;
429 uint64_t cNsElapsed = RTTimeNanoTS() - u64Start;
430
431 if (rcX == VERR_INTERRUPTED)
432 {
433 cInterrupted++;
434 continue; /* retry */
435 }
436 if (rcX != VERR_TIMEOUT)
437 RTTestFailed(hTest, "%Rrc cLoops=%u cNs=%u", rcX, cLoops, cNs);
438
439 if (cNsElapsedSys < cNsMinSys)
440 cNsMinSys = cNsElapsedSys;
441 if (cNsElapsed < cNsMin)
442 cNsMin = cNsElapsed;
443 cNsTotalSys += cNsElapsedSys;
444 cNsTotal += cNsElapsed;
445 cLoops++;
446 }
447 if (fSys)
448 {
449 RTTestValueF(hTest, cNsMinSys, RTTESTUNIT_NS, "%'u ns min (clock=sys)", cNs);
450 RTTestValueF(hTest, cNsTotalSys / cLoops, RTTESTUNIT_NS, "%'u ns avg (clock=sys)", cNs);
451 }
452 if (fGip)
453 {
454 RTTestValueF(hTest, cNsMin, RTTESTUNIT_NS, "%'u ns min (clock=gip)", cNs);
455 RTTestValueF(hTest, cNsTotal / cLoops, RTTESTUNIT_NS, "%'u ns avg (clock=gip)", cNs);
456 }
457 }
458
459 RTTESTI_CHECK_RC(SUPSemEventClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
460 RTTestValueF(hTest, cInterrupted, RTTESTUNIT_OCCURRENCES, "VERR_INTERRUPTED returned");
461 }
462
463 if (RTTestErrorCount(hTest) == 0)
464 {
465 RTTestSub(hTest, "SUPSemEventMultiWaitNsRelIntr Accuracy");
466 RTTestValueF(hTest, SUPSemEventMultiGetResolution(pSession), RTTESTUNIT_NS, "MRE resolution");
467 RTTESTI_CHECK_RC(SUPSemEventMultiCreate(pSession, &hEvent), VINF_SUCCESS);
468
469 uint32_t cInterrupted = 0;
470 for (unsigned i = 0; i < RT_ELEMENTS(s_acNsIntervals); i++)
471 {
472 uint64_t cNs = s_acNsIntervals[i];
473 uint64_t cNsMinSys = UINT64_MAX;
474 uint64_t cNsMin = UINT64_MAX;
475 uint64_t cNsTotalSys= 0;
476 uint64_t cNsTotal = 0;
477 unsigned cLoops = 0;
478 while (cLoops < LOOP_COUNT)
479 {
480 uint64_t u64StartSys = RTTimeSystemNanoTS();
481 uint64_t u64Start = RTTimeNanoTS();
482 int rcX = SUPSemEventMultiWaitNsRelIntr(pSession, hEvent, cNs);
483 uint64_t cNsElapsedSys = RTTimeSystemNanoTS() - u64StartSys;
484 uint64_t cNsElapsed = RTTimeNanoTS() - u64Start;
485
486 if (rcX == VERR_INTERRUPTED)
487 {
488 cInterrupted++;
489 continue; /* retry */
490 }
491 if (rcX != VERR_TIMEOUT)
492 RTTestFailed(hTest, "%Rrc cLoops=%u cNs=%u", rcX, cLoops, cNs);
493
494 if (cNsElapsedSys < cNsMinSys)
495 cNsMinSys = cNsElapsedSys;
496 if (cNsElapsed < cNsMin)
497 cNsMin = cNsElapsed;
498 cNsTotalSys += cNsElapsedSys;
499 cNsTotal += cNsElapsed;
500 cLoops++;
501 }
502 if (fSys)
503 {
504 RTTestValueF(hTest, cNsMinSys, RTTESTUNIT_NS, "%'u ns min (clock=sys)", cNs);
505 RTTestValueF(hTest, cNsTotalSys / cLoops, RTTESTUNIT_NS, "%'u ns avg (clock=sys)", cNs);
506 }
507 if (fGip)
508 {
509 RTTestValueF(hTest, cNsMin, RTTESTUNIT_NS, "%'u ns min (clock=gip)", cNs);
510 RTTestValueF(hTest, cNsTotal / cLoops, RTTESTUNIT_NS, "%'u ns avg (clock=gip)", cNs);
511 }
512 }
513
514 RTTESTI_CHECK_RC(SUPSemEventMultiClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
515 RTTestValueF(hTest, cInterrupted, RTTESTUNIT_OCCURRENCES, "VERR_INTERRUPTED returned");
516 }
517
518 if (RTTestErrorCount(hTest) == 0)
519 {
520 RTTestSub(hTest, "SUPSemEventWaitNsAbsIntr Accuracy");
521 RTTestValueF(hTest, SUPSemEventGetResolution(pSession), RTTESTUNIT_NS, "MRE resolution");
522 RTTESTI_CHECK_RC(SUPSemEventCreate(pSession, &hEvent), VINF_SUCCESS);
523
524 uint32_t cInterrupted = 0;
525 for (unsigned i = 0; i < RT_ELEMENTS(s_acNsIntervals); i++)
526 {
527 uint64_t cNs = s_acNsIntervals[i];
528 uint64_t cNsMinSys = UINT64_MAX;
529 uint64_t cNsMin = UINT64_MAX;
530 uint64_t cNsTotalSys= 0;
531 uint64_t cNsTotal = 0;
532 unsigned cLoops = 0;
533 while (cLoops < LOOP_COUNT)
534 {
535 uint64_t u64StartSys = RTTimeSystemNanoTS();
536 uint64_t u64Start = RTTimeNanoTS();
537 uint64_t uAbsDeadline = (fGip ? u64Start : u64StartSys) + cNs;
538 int rcX = SUPSemEventWaitNsAbsIntr(pSession, hEvent, uAbsDeadline);
539 uint64_t cNsElapsedSys = RTTimeSystemNanoTS() - u64StartSys;
540 uint64_t cNsElapsed = RTTimeNanoTS() - u64Start;
541
542 if (rcX == VERR_INTERRUPTED)
543 {
544 cInterrupted++;
545 continue; /* retry */
546 }
547 if (rcX != VERR_TIMEOUT)
548 RTTestFailed(hTest, "%Rrc cLoops=%u cNs=%u", rcX, cLoops, cNs);
549
550 if (cNsElapsedSys < cNsMinSys)
551 cNsMinSys = cNsElapsedSys;
552 if (cNsElapsed < cNsMin)
553 cNsMin = cNsElapsed;
554 cNsTotalSys += cNsElapsedSys;
555 cNsTotal += cNsElapsed;
556 cLoops++;
557 }
558 if (fSys)
559 {
560 RTTestValueF(hTest, cNsMinSys, RTTESTUNIT_NS, "%'u ns min (clock=sys)", cNs);
561 RTTestValueF(hTest, cNsTotalSys / cLoops, RTTESTUNIT_NS, "%'u ns avg (clock=sys)", cNs);
562 }
563 if (fGip)
564 {
565 RTTestValueF(hTest, cNsMin, RTTESTUNIT_NS, "%'u ns min (clock=gip)", cNs);
566 RTTestValueF(hTest, cNsTotal / cLoops, RTTESTUNIT_NS, "%'u ns avg (clock=gip)", cNs);
567 }
568 }
569
570 RTTESTI_CHECK_RC(SUPSemEventClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
571 RTTestValueF(hTest, cInterrupted, RTTESTUNIT_OCCURRENCES, "VERR_INTERRUPTED returned");
572 }
573
574
575 if (RTTestErrorCount(hTest) == 0)
576 {
577 RTTestSub(hTest, "SUPSemEventMultiWaitNsAbsIntr Accuracy");
578 RTTestValueF(hTest, SUPSemEventMultiGetResolution(pSession), RTTESTUNIT_NS, "MRE resolution");
579 RTTESTI_CHECK_RC(SUPSemEventMultiCreate(pSession, &hEvent), VINF_SUCCESS);
580
581 uint32_t cInterrupted = 0;
582 for (unsigned i = 0; i < RT_ELEMENTS(s_acNsIntervals); i++)
583 {
584 uint64_t cNs = s_acNsIntervals[i];
585 uint64_t cNsMinSys = UINT64_MAX;
586 uint64_t cNsMin = UINT64_MAX;
587 uint64_t cNsTotalSys= 0;
588 uint64_t cNsTotal = 0;
589 unsigned cLoops = 0;
590 while (cLoops < LOOP_COUNT)
591 {
592 uint64_t u64StartSys = RTTimeSystemNanoTS();
593 uint64_t u64Start = RTTimeNanoTS();
594 uint64_t uAbsDeadline = (fGip ? u64Start : u64StartSys) + cNs;
595 int rcX = SUPSemEventMultiWaitNsAbsIntr(pSession, hEvent, uAbsDeadline);
596 uint64_t cNsElapsedSys = RTTimeSystemNanoTS() - u64StartSys;
597 uint64_t cNsElapsed = RTTimeNanoTS() - u64Start;
598
599 if (rcX == VERR_INTERRUPTED)
600 {
601 cInterrupted++;
602 continue; /* retry */
603 }
604 if (rcX != VERR_TIMEOUT)
605 RTTestFailed(hTest, "%Rrc cLoops=%u cNs=%u", rcX, cLoops, cNs);
606
607 if (cNsElapsedSys < cNsMinSys)
608 cNsMinSys = cNsElapsedSys;
609 if (cNsElapsed < cNsMin)
610 cNsMin = cNsElapsed;
611 cNsTotalSys += cNsElapsedSys;
612 cNsTotal += cNsElapsed;
613 cLoops++;
614 }
615 if (fSys)
616 {
617 RTTestValueF(hTest, cNsMinSys, RTTESTUNIT_NS, "%'u ns min (clock=sys)", cNs);
618 RTTestValueF(hTest, cNsTotalSys / cLoops, RTTESTUNIT_NS, "%'u ns avg (clock=sys)", cNs);
619 }
620 if (fGip)
621 {
622 RTTestValueF(hTest, cNsMin, RTTESTUNIT_NS, "%'u ns min (clock=gip)", cNs);
623 RTTestValueF(hTest, cNsTotal / cLoops, RTTESTUNIT_NS, "%'u ns avg (clock=gip)", cNs);
624 }
625 }
626
627 RTTESTI_CHECK_RC(SUPSemEventMultiClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
628 RTTestValueF(hTest, cInterrupted, RTTESTUNIT_OCCURRENCES, "VERR_INTERRUPTED returned");
629 }
630
631 }
632
633
634 /*
635 * Done.
636 */
637 return RTTestSummaryAndDestroy(hTest);
638}
639
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