VirtualBox

source: vbox/trunk/src/VBox/Runtime/testcase/tstSemRW.cpp@ 25514

Last change on this file since 25514 was 25514, checked in by vboxsync, 15 years ago

tstSemRW: Converted to RTTest and added basic API tests.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 17.7 KB
Line 
1/* $Id: tstSemRW.cpp 25514 2009-12-20 14:43:55Z vboxsync $ */
2/** @file
3 * IPRT Testcase - Reader/Writer Semaphore Test.
4 */
5
6/*
7 * Copyright (C) 2009 Sun Microsystems, Inc.
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.215389.xyz. 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/semaphore.h>
35
36#include <iprt/asm.h>
37#include <iprt/assert.h>
38#include <iprt/err.h>
39#include <iprt/initterm.h>
40#include <iprt/rand.h>
41#include <iprt/string.h>
42#include <iprt/stream.h>
43#include <iprt/test.h>
44#include <iprt/time.h>
45#include <iprt/thread.h>
46
47
48/*******************************************************************************
49* Global Variables *
50*******************************************************************************/
51static RTTEST g_hTest;
52static RTSEMRW g_hSemRW = NIL_RTSEMRW;
53static bool volatile g_fTerminate;
54static bool g_fYield;
55static bool g_fQuiet;
56static unsigned g_uWritePercent;
57static uint32_t volatile g_cConcurrentWriters;
58static uint32_t volatile g_cConcurrentReaders;
59static uint32_t volatile g_cErrors;
60
61
62int ThreadTest1(RTTHREAD ThreadSelf, void *pvUser)
63{
64 // Use randomization to get a little more variation of the sync pattern
65 unsigned c100 = RTRandU32Ex(0, 99);
66 uint64_t *pu64 = (uint64_t *)pvUser;
67 bool fWrite;
68 for (;;)
69 {
70 int rc;
71 unsigned readrec = RTRandU32Ex(0, 3);
72 unsigned writerec = RTRandU32Ex(0, 3);
73 /* Don't overdo recursion testing. */
74 if (readrec > 1)
75 readrec--;
76 if (writerec > 1)
77 writerec--;
78
79 fWrite = (c100 < g_uWritePercent);
80 if (fWrite)
81 {
82 for (unsigned i = 0; i <= writerec; i++)
83 {
84 rc = RTSemRWRequestWriteNoResume(g_hSemRW, RT_INDEFINITE_WAIT);
85 if (RT_FAILURE(rc))
86 {
87 RTTestFailed(g_hTest, "Write recursion %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
88 break;
89 }
90 }
91 if (RT_FAILURE(rc))
92 break;
93 if (ASMAtomicIncU32(&g_cConcurrentWriters) != 1)
94 {
95 RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s after write locking it",
96 g_cConcurrentWriters, RTThreadSelfName());
97 break;
98 }
99 if (g_cConcurrentReaders != 0)
100 {
101 RTTestFailed(g_hTest, "g_cConcurrentReaders=%u on %s after write locking it",
102 g_cConcurrentReaders, RTThreadSelfName());
103 break;
104 }
105 }
106 else
107 {
108 rc = RTSemRWRequestReadNoResume(g_hSemRW, RT_INDEFINITE_WAIT);
109 if (RT_FAILURE(rc))
110 {
111 RTTestFailed(g_hTest, "Read locking on %s failed with rc=%Rrc", RTThreadSelfName(), rc);
112 break;
113 }
114 ASMAtomicIncU32(&g_cConcurrentReaders);
115 if (g_cConcurrentWriters != 0)
116 {
117 RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s after read locking it",
118 g_cConcurrentWriters, RTThreadSelfName());
119 break;
120 }
121 }
122 for (unsigned i = 0; i < readrec; i++)
123 {
124 rc = RTSemRWRequestReadNoResume(g_hSemRW, RT_INDEFINITE_WAIT);
125 if (RT_FAILURE(rc))
126 {
127 RTTestFailed(g_hTest, "Read recursion %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
128 break;
129 }
130 }
131 if (RT_FAILURE(rc))
132 break;
133
134 /*
135 * Check for fairness: The values of the threads should not differ too much
136 */
137 (*pu64)++;
138
139 /*
140 * Check for correctness: Give other threads a chance. If the implementation is
141 * correct, no other thread will be able to enter this lock now.
142 */
143 if (g_fYield)
144 RTThreadYield();
145
146 for (unsigned i = 0; i < readrec; i++)
147 {
148 rc = RTSemRWReleaseRead(g_hSemRW);
149 if (RT_FAILURE(rc))
150 {
151 RTTestFailed(g_hTest, "Read release %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
152 break;
153 }
154 }
155 if (RT_FAILURE(rc))
156 break;
157
158 if (fWrite)
159 {
160 if (ASMAtomicDecU32(&g_cConcurrentWriters) != 0)
161 {
162 RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s before write release",
163 g_cConcurrentWriters, RTThreadSelfName());
164 break;
165 }
166 if (g_cConcurrentReaders != 0)
167 {
168 RTTestFailed(g_hTest, "g_cConcurrentReaders=%u on %s before write release",
169 g_cConcurrentReaders, RTThreadSelfName());
170 break;
171 }
172 for (unsigned i = 0; i <= writerec; i++)
173 {
174 rc = RTSemRWReleaseWrite(g_hSemRW);
175 if (RT_FAILURE(rc))
176 {
177 RTTestFailed(g_hTest, "Write release %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
178 break;
179 }
180 }
181 }
182 else
183 {
184 if (g_cConcurrentWriters != 0)
185 {
186 RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s before read release",
187 g_cConcurrentWriters, RTThreadSelfName());
188 break;
189 }
190 ASMAtomicDecU32(&g_cConcurrentReaders);
191 rc = RTSemRWReleaseRead(g_hSemRW);
192 if (RT_FAILURE(rc))
193 {
194 RTTestFailed(g_hTest, "Read release on %s failed with rc=%Rrc", RTThreadSelfName(), rc);
195 break;
196 }
197 }
198
199 if (g_fTerminate)
200 break;
201
202 c100++;
203 c100 %= 100;
204 }
205 if (!g_fQuiet)
206 RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Thread %s exited with %lld\n", RTThreadSelfName(), *pu64);
207 return VINF_SUCCESS;
208}
209
210
211static void Test3(unsigned cThreads, unsigned cSeconds, unsigned uWritePercent, bool fYield, bool fQuiet)
212{
213 int rc;
214 unsigned i;
215 uint64_t au64[32];
216 RTTHREAD aThreads[RT_ELEMENTS(au64)];
217 AssertRelease(cThreads <= RT_ELEMENTS(au64));
218
219 RTTestSubF(g_hTest, "Test3 - %u threads, %u sec, %u%% writes, %syielding",
220 cThreads, cSeconds, uWritePercent, fYield ? "" : "non-");
221
222 /*
223 * Init globals.
224 */
225 g_fYield = fYield;
226 g_fQuiet = fQuiet;
227 g_fTerminate = false;
228 g_uWritePercent = uWritePercent;
229 g_cConcurrentWriters = 0;
230 g_cConcurrentReaders = 0;
231
232 RTTEST_CHECK_RC_RETV(g_hTest, RTSemRWCreate(&g_hSemRW), VINF_SUCCESS);
233
234 /*
235 * Create the threads and let them block on the semrw.
236 */
237 RTTEST_CHECK_RC_RETV(g_hTest, RTSemRWRequestWrite(g_hSemRW, RT_INDEFINITE_WAIT), VINF_SUCCESS);
238
239 for (i = 0; i < cThreads; i++)
240 {
241 au64[i] = 0;
242 RTTEST_CHECK_RC_RETV(g_hTest, RTThreadCreateF(&aThreads[i], ThreadTest1, &au64[i], 0,
243 RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE,
244 "test-%u", i), VINF_SUCCESS);
245 }
246
247 /*
248 * Do the test run.
249 */
250 uint64_t u64StartTS = RTTimeNanoTS();
251 RTTEST_CHECK_RC(g_hTest, RTSemRWReleaseWrite(g_hSemRW), VINF_SUCCESS);
252 RTThreadSleep(cSeconds * 1000);
253 ASMAtomicWriteBool(&g_fTerminate, true);
254 uint64_t ElapsedNS = RTTimeNanoTS() - u64StartTS;
255
256 /*
257 * Clean up the threads and semaphore.
258 */
259 for (i = 0; i < cThreads; i++)
260 RTTEST_CHECK_RC(g_hTest, RTThreadWait(aThreads[i], 5000, NULL), VINF_SUCCESS);
261
262 RTTEST_CHECK_MSG(g_hTest, g_cConcurrentWriters == 0, (g_hTest, "g_cConcurrentWriters=%u at end of test\n", g_cConcurrentWriters));
263 RTTEST_CHECK_MSG(g_hTest, g_cConcurrentReaders == 0, (g_hTest, "g_cConcurrentReaders=%u at end of test\n", g_cConcurrentReaders));
264
265 RTTEST_CHECK_RC(g_hTest, RTSemRWDestroy(g_hSemRW), VINF_SUCCESS);
266 g_hSemRW = NIL_RTSEMRW;
267
268// if (g_cErrors)
269// RTThreadSleep(100);
270
271 /*
272 * Collect and display the results.
273 */
274 uint64_t Total = au64[0];
275 for (i = 1; i < cThreads; i++)
276 Total += au64[i];
277
278 uint64_t Normal = Total / cThreads;
279 uint64_t MaxDeviation = 0;
280 for (i = 0; i < cThreads; i++)
281 {
282 uint64_t Delta = RT_ABS((int64_t)(au64[i] - Normal));
283 if (Delta > Normal / 2)
284 RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
285 "Warning! Thread %u deviates by more than 50%% - %llu (it) vs. %llu (avg) - %llu%%\n",
286 i, au64[i], Normal, Delta * 100 / Normal);
287 if (Delta > MaxDeviation)
288 MaxDeviation = Delta;
289
290 }
291
292 RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
293 "Threads: %u Total: %llu Per Sec: %llu Avg: %llu ns Max dev: %llu%%\n",
294 cThreads,
295 Total,
296 Total / cSeconds,
297 ElapsedNS / Total,
298 MaxDeviation * 100 / Normal
299 );
300}
301
302
303static DECLCALLBACK(int) Test2Thread(RTTHREAD hThreadSelf, void *pvUser)
304{
305 RTSEMRW hSemRW = (RTSEMRW)pvUser;
306
307 RTTEST_CHECK_RC(g_hTest, RTSemRWRequestRead(hSemRW, 0), VERR_TIMEOUT);
308 RTTEST_CHECK_RC(g_hTest, RTSemRWRequestWrite(hSemRW, 0), VERR_TIMEOUT);
309
310 RTTEST_CHECK_RC(g_hTest, RTSemRWRequestRead(hSemRW, 1), VERR_TIMEOUT);
311 RTTEST_CHECK_RC(g_hTest, RTSemRWRequestWrite(hSemRW, 1), VERR_TIMEOUT);
312
313 RTTEST_CHECK_RC(g_hTest, RTSemRWRequestRead(hSemRW, 50), VERR_TIMEOUT);
314 RTTEST_CHECK_RC(g_hTest, RTSemRWRequestWrite(hSemRW, 50), VERR_TIMEOUT);
315
316 return VINF_SUCCESS;
317}
318
319
320static void Test2(void)
321{
322 RTTestSub(g_hTest, "Timeout");
323
324 RTSEMRW hSemRW = NIL_RTSEMRW;
325 RTTEST_CHECK_RC_RETV(g_hTest, RTSemRWCreate(&hSemRW), VINF_SUCCESS);
326
327 /* Lock it for writing and let the thread do the remainder of the test. */
328 RTTEST_CHECK_RC_RETV(g_hTest, RTSemRWRequestWrite(hSemRW, RT_INDEFINITE_WAIT), VINF_SUCCESS);
329
330 RTTHREAD hThread;
331 RTTEST_CHECK_RC_RETV(g_hTest, RTThreadCreate(&hThread, Test2Thread, hSemRW, 0,
332 RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "test2"),
333 VINF_SUCCESS);
334 RTTEST_CHECK_RC(g_hTest, RTThreadWait(hThread, 15000, NULL), VINF_SUCCESS);
335 RTTEST_CHECK_RC(g_hTest, RTSemRWReleaseWrite(hSemRW), VINF_SUCCESS);
336
337 RTTEST_CHECK_RC(g_hTest, RTSemRWDestroy(hSemRW), VINF_SUCCESS);
338}
339
340
341static bool Test1(void)
342{
343 RTTestSub(g_hTest, "Basics");
344
345 RTSEMRW hSemRW = NIL_RTSEMRW;
346 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWCreate(&hSemRW), VINF_SUCCESS, false);
347 RTTEST_CHECK_RET(g_hTest, hSemRW != NIL_RTSEMRW, false);
348
349 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestRead(hSemRW, RT_INDEFINITE_WAIT), VINF_SUCCESS, false);
350 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseRead(hSemRW), VINF_SUCCESS, false);
351
352 for (unsigned cMs = 0; cMs < 50; cMs++)
353 {
354 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestRead(hSemRW, cMs), VINF_SUCCESS, false);
355 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestRead(hSemRW, cMs), VINF_SUCCESS, false);
356 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseRead(hSemRW), VINF_SUCCESS, false);
357 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseRead(hSemRW), VINF_SUCCESS, false);
358 }
359
360 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestWrite(hSemRW, RT_INDEFINITE_WAIT), VINF_SUCCESS, false);
361 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseWrite(hSemRW), VINF_SUCCESS, false);
362
363 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestWrite(hSemRW, RT_INDEFINITE_WAIT), VINF_SUCCESS, false);
364 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestRead(hSemRW, RT_INDEFINITE_WAIT), VINF_SUCCESS, false);
365 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseRead(hSemRW), VINF_SUCCESS, false);
366 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseWrite(hSemRW), VINF_SUCCESS, false);
367
368 for (unsigned cMs = 0; cMs < 50; cMs++)
369 {
370 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestWrite(hSemRW, cMs), VINF_SUCCESS, false);
371 RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriteRecursion(hSemRW) == 1, false);
372 RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriterReadRecursion(hSemRW) == 0, false);
373 RTTEST_CHECK_RET(g_hTest, RTSemRWIsWriteOwner(hSemRW) == true, false);
374
375 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestWrite(hSemRW, cMs), VINF_SUCCESS, false);
376 RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriteRecursion(hSemRW) == 2, false);
377 RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriterReadRecursion(hSemRW) == 0, false);
378 RTTEST_CHECK_RET(g_hTest, RTSemRWIsWriteOwner(hSemRW) == true, false);
379
380 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestRead(hSemRW, cMs), VINF_SUCCESS, false);
381 RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriteRecursion(hSemRW) == 2, false);
382 RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriterReadRecursion(hSemRW) == 1, false);
383 RTTEST_CHECK_RET(g_hTest, RTSemRWIsWriteOwner(hSemRW) == true, false);
384
385 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestWrite(hSemRW, cMs), VINF_SUCCESS, false);
386 RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriteRecursion(hSemRW) == 3, false);
387 RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriterReadRecursion(hSemRW) == 1, false);
388 RTTEST_CHECK_RET(g_hTest, RTSemRWIsWriteOwner(hSemRW) == true, false);
389
390 /* midway */
391
392 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseWrite(hSemRW), VINF_SUCCESS, false);
393 RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriteRecursion(hSemRW) == 2, false);
394 RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriterReadRecursion(hSemRW) == 1, false);
395 RTTEST_CHECK_RET(g_hTest, RTSemRWIsWriteOwner(hSemRW) == true, false);
396
397 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseRead(hSemRW), VINF_SUCCESS, false);
398 RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriteRecursion(hSemRW) == 2, false);
399 RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriterReadRecursion(hSemRW) == 0, false);
400 RTTEST_CHECK_RET(g_hTest, RTSemRWIsWriteOwner(hSemRW) == true, false);
401
402 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseWrite(hSemRW), VINF_SUCCESS, false);
403 RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriteRecursion(hSemRW) == 1, false);
404 RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriterReadRecursion(hSemRW) == 0, false);
405 RTTEST_CHECK_RET(g_hTest, RTSemRWIsWriteOwner(hSemRW) == true, false);
406
407 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseWrite(hSemRW), VINF_SUCCESS, false);
408 RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriteRecursion(hSemRW) == 0, false);
409 RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriterReadRecursion(hSemRW) == 0, false);
410 RTTEST_CHECK_RET(g_hTest, RTSemRWIsWriteOwner(hSemRW) == false, false);
411 }
412
413 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWDestroy(hSemRW), VINF_SUCCESS, false);
414 RTTEST_CHECK_RC_RET(g_hTest, RTSemRWDestroy(NIL_RTSEMRW), VINF_SUCCESS, false);
415 return true;
416}
417
418int main(int argc, char **argv)
419{
420 int rc = RTTestInitAndCreate("tstRTSemRW", &g_hTest);
421 if (rc)
422 return 1;
423 RTTestBanner(g_hTest);
424
425 if (Test1())
426 {
427 if (argc == 1)
428 {
429 Test2();
430
431 /* threads, seconds, writePercent, yield, quiet */
432 Test3( 1, 1, 0, true, false);
433 Test3( 1, 1, 1, true, false);
434 Test3( 1, 1, 5, true, false);
435 Test3( 2, 1, 3, true, false);
436 Test3( 10, 1, 5, true, false);
437 Test3( 10, 10, 10, false, false);
438
439 RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "benchmarking...\n");
440 for (unsigned cThreads = 1; cThreads < 32; cThreads++)
441 Test3(cThreads, 2, 1, false, true);
442
443 /** @todo add a testcase where some stuff times out. */
444 }
445 else
446 {
447 /* threads, seconds, writePercent, yield, quiet */
448 RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "benchmarking...\n");
449 Test3( 1, 3, 1, false, true);
450 Test3( 1, 3, 1, false, true);
451 Test3( 1, 3, 1, false, true);
452 Test3( 2, 3, 1, false, true);
453 Test3( 2, 3, 1, false, true);
454 Test3( 2, 3, 1, false, true);
455 Test3( 3, 3, 1, false, true);
456 Test3( 3, 3, 1, false, true);
457 Test3( 3, 3, 1, false, true);
458 }
459 }
460
461 return RTTestSummaryAndDestroy(g_hTest);
462}
463
Note: See TracBrowser for help on using the repository browser.

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