VirtualBox

source: vbox/trunk/src/VBox/Runtime/testcase/tstRTCritSectRw.cpp@ 53582

Last change on this file since 53582 was 48935, checked in by vboxsync, 11 years ago

Runtime: Whitespace and svn:keyword cleanups by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 20.7 KB
Line 
1/* $Id: tstRTCritSectRw.cpp 48935 2013-10-07 21:19:37Z vboxsync $ */
2/** @file
3 * IPRT Testcase - Reader/Writer Critical Sections.
4 */
5
6/*
7 * Copyright (C) 2009-2013 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* Header Files *
29*******************************************************************************/
30#include <iprt/critsect.h>
31
32#include <iprt/asm.h>
33#include <iprt/assert.h>
34#include <iprt/err.h>
35#include <iprt/initterm.h>
36#include <iprt/lockvalidator.h>
37#include <iprt/rand.h>
38#include <iprt/semaphore.h>
39#include <iprt/string.h>
40#include <iprt/stream.h>
41#include <iprt/test.h>
42#include <iprt/time.h>
43#include <iprt/thread.h>
44
45
46/*******************************************************************************
47* Global Variables *
48*******************************************************************************/
49static RTTEST g_hTest;
50static RTCRITSECTRW g_CritSectRw;
51static bool volatile g_fTerminate;
52static bool g_fYield;
53static bool g_fQuiet;
54static unsigned g_uWritePercent;
55static uint32_t volatile g_cConcurrentWriters;
56static uint32_t volatile g_cConcurrentReaders;
57
58
59static DECLCALLBACK(int) Test4Thread(RTTHREAD ThreadSelf, void *pvUser)
60{
61 /* Use randomization to get a little more variation of the sync pattern.
62 We use a pseudo random generator here so that we don't end up testing
63 the speed of the /dev/urandom implementation, but rather the read-write
64 semaphores. */
65 int rc;
66 RTRAND hRand;
67 RTTEST_CHECK_RC_OK_RET(g_hTest, rc = RTRandAdvCreateParkMiller(&hRand), rc);
68 RTTEST_CHECK_RC_OK_RET(g_hTest, rc = RTRandAdvSeed(hRand, (uintptr_t)ThreadSelf), rc);
69 unsigned c100 = RTRandAdvU32Ex(hRand, 0, 99);
70
71 uint64_t *pcItr = (uint64_t *)pvUser;
72 bool fWrite;
73 for (;;)
74 {
75 unsigned readrec = RTRandAdvU32Ex(hRand, 0, 3);
76 unsigned writerec = RTRandAdvU32Ex(hRand, 0, 3);
77 /* Don't overdo recursion testing. */
78 if (readrec > 1)
79 readrec--;
80 if (writerec > 1)
81 writerec--;
82
83 fWrite = (c100 < g_uWritePercent);
84 if (fWrite)
85 {
86 for (unsigned i = 0; i <= writerec; i++)
87 {
88 rc = RTCritSectRwEnterExcl(&g_CritSectRw);
89 if (RT_FAILURE(rc))
90 {
91 RTTestFailed(g_hTest, "Write recursion %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
92 break;
93 }
94 }
95 if (RT_FAILURE(rc))
96 break;
97 if (ASMAtomicIncU32(&g_cConcurrentWriters) != 1)
98 {
99 RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s after write locking it",
100 g_cConcurrentWriters, RTThreadSelfName());
101 break;
102 }
103 if (g_cConcurrentReaders != 0)
104 {
105 RTTestFailed(g_hTest, "g_cConcurrentReaders=%u on %s after write locking it",
106 g_cConcurrentReaders, RTThreadSelfName());
107 break;
108 }
109 }
110 else
111 {
112 rc = RTCritSectRwEnterShared(&g_CritSectRw);
113 if (RT_FAILURE(rc))
114 {
115 RTTestFailed(g_hTest, "Read locking on %s failed with rc=%Rrc", RTThreadSelfName(), rc);
116 break;
117 }
118 ASMAtomicIncU32(&g_cConcurrentReaders);
119 if (g_cConcurrentWriters != 0)
120 {
121 RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s after read locking it",
122 g_cConcurrentWriters, RTThreadSelfName());
123 break;
124 }
125 }
126 for (unsigned i = 0; i < readrec; i++)
127 {
128 rc = RTCritSectRwEnterShared(&g_CritSectRw);
129 if (RT_FAILURE(rc))
130 {
131 RTTestFailed(g_hTest, "Read recursion %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
132 break;
133 }
134 }
135 if (RT_FAILURE(rc))
136 break;
137
138 /*
139 * Check for fairness: The values of the threads should not differ too much
140 */
141 (*pcItr)++;
142
143 /*
144 * Check for correctness: Give other threads a chance. If the implementation is
145 * correct, no other thread will be able to enter this lock now.
146 */
147 if (g_fYield)
148 RTThreadYield();
149
150 for (unsigned i = 0; i < readrec; i++)
151 {
152 rc = RTCritSectRwLeaveShared(&g_CritSectRw);
153 if (RT_FAILURE(rc))
154 {
155 RTTestFailed(g_hTest, "Read release %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
156 break;
157 }
158 }
159 if (RT_FAILURE(rc))
160 break;
161
162 if (fWrite)
163 {
164 if (ASMAtomicDecU32(&g_cConcurrentWriters) != 0)
165 {
166 RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s before write release",
167 g_cConcurrentWriters, RTThreadSelfName());
168 break;
169 }
170 if (g_cConcurrentReaders != 0)
171 {
172 RTTestFailed(g_hTest, "g_cConcurrentReaders=%u on %s before write release",
173 g_cConcurrentReaders, RTThreadSelfName());
174 break;
175 }
176 for (unsigned i = 0; i <= writerec; i++)
177 {
178 rc = RTCritSectRwLeaveExcl(&g_CritSectRw);
179 if (RT_FAILURE(rc))
180 {
181 RTTestFailed(g_hTest, "Write release %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
182 break;
183 }
184 }
185 }
186 else
187 {
188 if (g_cConcurrentWriters != 0)
189 {
190 RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s before read release",
191 g_cConcurrentWriters, RTThreadSelfName());
192 break;
193 }
194 ASMAtomicDecU32(&g_cConcurrentReaders);
195 rc = RTCritSectRwLeaveShared(&g_CritSectRw);
196 if (RT_FAILURE(rc))
197 {
198 RTTestFailed(g_hTest, "Read release on %s failed with rc=%Rrc", RTThreadSelfName(), rc);
199 break;
200 }
201 }
202
203 if (g_fTerminate)
204 break;
205
206 c100++;
207 c100 %= 100;
208 }
209 if (!g_fQuiet)
210 RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Thread %s exited with %lld\n", RTThreadSelfName(), *pcItr);
211 RTRandAdvDestroy(hRand);
212 return VINF_SUCCESS;
213}
214
215
216static void Test4(unsigned cThreads, unsigned cSeconds, unsigned uWritePercent, bool fYield, bool fQuiet)
217{
218 unsigned i;
219 uint64_t acIterations[32];
220 RTTHREAD aThreads[RT_ELEMENTS(acIterations)];
221 AssertRelease(cThreads <= RT_ELEMENTS(acIterations));
222
223 RTTestSubF(g_hTest, "Test4 - %u threads, %u sec, %u%% writes, %syielding",
224 cThreads, cSeconds, uWritePercent, fYield ? "" : "non-");
225
226 /*
227 * Init globals.
228 */
229 g_fYield = fYield;
230 g_fQuiet = fQuiet;
231 g_fTerminate = false;
232 g_uWritePercent = uWritePercent;
233 g_cConcurrentWriters = 0;
234 g_cConcurrentReaders = 0;
235
236 RTTEST_CHECK_RC_RETV(g_hTest, RTCritSectRwInit(&g_CritSectRw), VINF_SUCCESS);
237
238 /*
239 * Create the threads and let them block on the semrw.
240 */
241 RTTEST_CHECK_RC_RETV(g_hTest, RTCritSectRwEnterExcl(&g_CritSectRw), VINF_SUCCESS);
242
243 for (i = 0; i < cThreads; i++)
244 {
245 acIterations[i] = 0;
246 RTTEST_CHECK_RC_RETV(g_hTest, RTThreadCreateF(&aThreads[i], Test4Thread, &acIterations[i], 0,
247 RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE,
248 "test-%u", i), VINF_SUCCESS);
249 }
250
251 /*
252 * Do the test run.
253 */
254 uint32_t cErrorsBefore = RTTestErrorCount(g_hTest);
255 uint64_t u64StartTS = RTTimeNanoTS();
256 RTTEST_CHECK_RC(g_hTest, RTCritSectRwLeaveExcl(&g_CritSectRw), VINF_SUCCESS);
257 RTThreadSleep(cSeconds * 1000);
258 ASMAtomicWriteBool(&g_fTerminate, true);
259 uint64_t ElapsedNS = RTTimeNanoTS() - u64StartTS;
260
261 /*
262 * Clean up the threads and semaphore.
263 */
264 for (i = 0; i < cThreads; i++)
265 RTTEST_CHECK_RC(g_hTest, RTThreadWait(aThreads[i], 5000, NULL), VINF_SUCCESS);
266
267 RTTEST_CHECK_MSG(g_hTest, g_cConcurrentWriters == 0, (g_hTest, "g_cConcurrentWriters=%u at end of test\n", g_cConcurrentWriters));
268 RTTEST_CHECK_MSG(g_hTest, g_cConcurrentReaders == 0, (g_hTest, "g_cConcurrentReaders=%u at end of test\n", g_cConcurrentReaders));
269
270 RTTEST_CHECK_RC(g_hTest, RTCritSectRwDelete(&g_CritSectRw), VINF_SUCCESS);
271
272 if (RTTestErrorCount(g_hTest) != cErrorsBefore)
273 RTThreadSleep(100);
274
275 /*
276 * Collect and display the results.
277 */
278 uint64_t cItrTotal = acIterations[0];
279 for (i = 1; i < cThreads; i++)
280 cItrTotal += acIterations[i];
281
282 uint64_t cItrNormal = cItrTotal / cThreads;
283 uint64_t cItrMinOK = cItrNormal / 20; /* 5% */
284 uint64_t cItrMaxDeviation = 0;
285 for (i = 0; i < cThreads; i++)
286 {
287 uint64_t cItrDelta = RT_ABS((int64_t)(acIterations[i] - cItrNormal));
288 if (acIterations[i] < cItrMinOK)
289 RTTestFailed(g_hTest, "Thread %u did less than 5%% of the iterations - %llu (it) vs. %llu (5%%) - %llu%%\n",
290 i, acIterations[i], cItrMinOK, cItrDelta * 100 / cItrNormal);
291 else if (cItrDelta > cItrNormal / 2)
292 RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
293 "Warning! Thread %u deviates by more than 50%% - %llu (it) vs. %llu (avg) - %llu%%\n",
294 i, acIterations[i], cItrNormal, cItrDelta * 100 / cItrNormal);
295 if (cItrDelta > cItrMaxDeviation)
296 cItrMaxDeviation = cItrDelta;
297
298 }
299
300 //RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
301 // "Threads: %u Total: %llu Per Sec: %llu Avg: %llu ns Max dev: %llu%%\n",
302 // cThreads,
303 // cItrTotal,
304 // cItrTotal / cSeconds,
305 // ElapsedNS / cItrTotal,
306 // cItrMaxDeviation * 100 / cItrNormal
307 // );
308 //
309 RTTestValue(g_hTest, "Thruput", cItrTotal * UINT32_C(1000000000) / ElapsedNS, RTTESTUNIT_CALLS_PER_SEC);
310 RTTestValue(g_hTest, "Max diviation", cItrMaxDeviation * 100 / cItrNormal, RTTESTUNIT_PCT);
311}
312
313
314static void TestNegative(void)
315{
316 RTTestSub(g_hTest, "Negative");
317 bool fSavedAssertQuiet = RTAssertSetQuiet(true);
318 bool fSavedAssertMayPanic = RTAssertSetMayPanic(false);
319 bool fSavedLckValEnabled = RTLockValidatorSetEnabled(false);
320
321 RTCRITSECTRW CritSectRw;
322 RTTEST_CHECK_RC_RETV(g_hTest, RTCritSectRwInit(&CritSectRw), VINF_SUCCESS);
323
324 RTTEST_CHECK_RC(g_hTest, RTCritSectRwLeaveShared(&CritSectRw), VERR_NOT_OWNER);
325 RTTEST_CHECK_RC(g_hTest, RTCritSectRwLeaveExcl(&CritSectRw), VERR_NOT_OWNER);
326
327 RTTEST_CHECK_RC(g_hTest, RTCritSectRwEnterExcl(&CritSectRw), VINF_SUCCESS);
328 RTTEST_CHECK_RC(g_hTest, RTCritSectRwLeaveShared(&CritSectRw), VERR_NOT_OWNER);
329
330 RTTEST_CHECK_RC(g_hTest, RTCritSectRwEnterShared(&CritSectRw), VINF_SUCCESS);
331 RTTEST_CHECK_RC(g_hTest, RTCritSectRwLeaveExcl(&CritSectRw), VERR_WRONG_ORDER); /* cannot release the final write before the reads. */
332 RTTEST_CHECK_RC(g_hTest, RTCritSectRwLeaveShared(&CritSectRw), VINF_SUCCESS);
333 RTTEST_CHECK_RC(g_hTest, RTCritSectRwLeaveExcl(&CritSectRw), VINF_SUCCESS);
334
335 RTTEST_CHECK_RC(g_hTest, RTCritSectRwDelete(&CritSectRw), VINF_SUCCESS);
336
337 RTLockValidatorSetEnabled(fSavedLckValEnabled);
338 RTAssertSetMayPanic(fSavedAssertMayPanic);
339 RTAssertSetQuiet(fSavedAssertQuiet);
340}
341
342
343static bool Test1(void)
344{
345 RTTestSub(g_hTest, "Basics");
346
347 RTCRITSECTRW CritSectRw;
348 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwInit(&CritSectRw), VINF_SUCCESS, false);
349 RTTEST_CHECK_RET(g_hTest, RTCritSectRwIsInitialized(&CritSectRw), false);
350
351 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwEnterShared(&CritSectRw), VINF_SUCCESS, false);
352 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveShared(&CritSectRw), VINF_SUCCESS, false);
353
354 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwEnterShared(&CritSectRw), VINF_SUCCESS, false);
355 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwEnterShared(&CritSectRw), VINF_SUCCESS, false);
356 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveShared(&CritSectRw), VINF_SUCCESS, false);
357 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveShared(&CritSectRw), VINF_SUCCESS, false);
358
359 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwEnterExcl(&CritSectRw), VINF_SUCCESS, false);
360 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveExcl(&CritSectRw), VINF_SUCCESS, false);
361
362 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwEnterExcl(&CritSectRw), VINF_SUCCESS, false);
363 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwEnterExcl(&CritSectRw), VINF_SUCCESS, false);
364 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveExcl(&CritSectRw), VINF_SUCCESS, false);
365 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveExcl(&CritSectRw), VINF_SUCCESS, false);
366
367 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwEnterExcl(&CritSectRw), VINF_SUCCESS, false);
368 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwEnterShared(&CritSectRw), VINF_SUCCESS, false);
369 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveShared(&CritSectRw), VINF_SUCCESS, false);
370 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveExcl(&CritSectRw), VINF_SUCCESS, false);
371
372 for (int iRun = 0; iRun < 3; iRun++)
373 {
374 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwEnterExcl(&CritSectRw), VINF_SUCCESS, false);
375 RTTEST_CHECK_RET(g_hTest, RTCritSectRwGetWriteRecursion(&CritSectRw) == 1, false);
376 RTTEST_CHECK_RET(g_hTest, RTCritSectRwGetWriterReadRecursion(&CritSectRw) == 0, false);
377 RTTEST_CHECK_RET(g_hTest, RTCritSectRwIsWriteOwner(&CritSectRw) == true, false);
378
379 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwEnterExcl(&CritSectRw), VINF_SUCCESS, false);
380 RTTEST_CHECK_RET(g_hTest, RTCritSectRwGetWriteRecursion(&CritSectRw) == 2, false);
381 RTTEST_CHECK_RET(g_hTest, RTCritSectRwGetWriterReadRecursion(&CritSectRw) == 0, false);
382 RTTEST_CHECK_RET(g_hTest, RTCritSectRwIsWriteOwner(&CritSectRw) == true, false);
383
384 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwEnterShared(&CritSectRw), VINF_SUCCESS, false);
385 RTTEST_CHECK_RET(g_hTest, RTCritSectRwGetWriteRecursion(&CritSectRw) == 2, false);
386 RTTEST_CHECK_RET(g_hTest, RTCritSectRwGetWriterReadRecursion(&CritSectRw) == 1, false);
387 RTTEST_CHECK_RET(g_hTest, RTCritSectRwIsWriteOwner(&CritSectRw) == true, false);
388
389 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwEnterExcl(&CritSectRw), VINF_SUCCESS, false);
390 RTTEST_CHECK_RET(g_hTest, RTCritSectRwGetWriteRecursion(&CritSectRw) == 3, false);
391 RTTEST_CHECK_RET(g_hTest, RTCritSectRwGetWriterReadRecursion(&CritSectRw) == 1, false);
392 RTTEST_CHECK_RET(g_hTest, RTCritSectRwIsWriteOwner(&CritSectRw) == true, false);
393
394 /* midway */
395
396 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveExcl(&CritSectRw), VINF_SUCCESS, false);
397 RTTEST_CHECK_RET(g_hTest, RTCritSectRwGetWriteRecursion(&CritSectRw) == 2, false);
398 RTTEST_CHECK_RET(g_hTest, RTCritSectRwGetWriterReadRecursion(&CritSectRw) == 1, false);
399 RTTEST_CHECK_RET(g_hTest, RTCritSectRwIsWriteOwner(&CritSectRw) == true, false);
400
401 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveShared(&CritSectRw), VINF_SUCCESS, false);
402 RTTEST_CHECK_RET(g_hTest, RTCritSectRwGetWriteRecursion(&CritSectRw) == 2, false);
403 RTTEST_CHECK_RET(g_hTest, RTCritSectRwGetWriterReadRecursion(&CritSectRw) == 0, false);
404 RTTEST_CHECK_RET(g_hTest, RTCritSectRwIsWriteOwner(&CritSectRw) == true, false);
405
406 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveExcl(&CritSectRw), VINF_SUCCESS, false);
407 RTTEST_CHECK_RET(g_hTest, RTCritSectRwGetWriteRecursion(&CritSectRw) == 1, false);
408 RTTEST_CHECK_RET(g_hTest, RTCritSectRwGetWriterReadRecursion(&CritSectRw) == 0, false);
409 RTTEST_CHECK_RET(g_hTest, RTCritSectRwIsWriteOwner(&CritSectRw) == true, false);
410
411 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveExcl(&CritSectRw), VINF_SUCCESS, false);
412 RTTEST_CHECK_RET(g_hTest, RTCritSectRwGetWriteRecursion(&CritSectRw) == 0, false);
413 RTTEST_CHECK_RET(g_hTest, RTCritSectRwGetWriterReadRecursion(&CritSectRw) == 0, false);
414 RTTEST_CHECK_RET(g_hTest, RTCritSectRwIsWriteOwner(&CritSectRw) == false, false);
415 }
416
417 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwTryEnterShared(&CritSectRw), VINF_SUCCESS, false);
418 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveShared(&CritSectRw), VINF_SUCCESS, false);
419
420 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwTryEnterShared(&CritSectRw), VINF_SUCCESS, false);
421 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwTryEnterShared(&CritSectRw), VINF_SUCCESS, false);
422 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveShared(&CritSectRw), VINF_SUCCESS, false);
423 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveShared(&CritSectRw), VINF_SUCCESS, false);
424
425 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwTryEnterExcl(&CritSectRw), VINF_SUCCESS, false);
426 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveExcl(&CritSectRw), VINF_SUCCESS, false);
427
428 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwTryEnterExcl(&CritSectRw), VINF_SUCCESS, false);
429 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwTryEnterExcl(&CritSectRw), VINF_SUCCESS, false);
430 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveExcl(&CritSectRw), VINF_SUCCESS, false);
431 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveExcl(&CritSectRw), VINF_SUCCESS, false);
432
433 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwTryEnterExcl(&CritSectRw), VINF_SUCCESS, false);
434 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwTryEnterShared(&CritSectRw), VINF_SUCCESS, false);
435 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveShared(&CritSectRw), VINF_SUCCESS, false);
436 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwLeaveExcl(&CritSectRw), VINF_SUCCESS, false);
437
438
439 RTTEST_CHECK_RET(g_hTest, RTCritSectRwIsInitialized(&CritSectRw), false);
440 RTTEST_CHECK_RC_RET(g_hTest, RTCritSectRwDelete(&CritSectRw), VINF_SUCCESS, false);
441 RTTEST_CHECK_RET(g_hTest, !RTCritSectRwIsInitialized(&CritSectRw), false);
442
443 return true;
444}
445
446int main(int argc, char **argv)
447{
448 int rc = RTTestInitAndCreate("tstRTCritSectRw", &g_hTest);
449 if (rc)
450 return 1;
451 RTTestBanner(g_hTest);
452
453 if (Test1())
454 {
455 if (argc == 1)
456 {
457 TestNegative();
458
459 /* threads, seconds, writePercent, yield, quiet */
460 Test4( 1, 1, 0, true, false);
461 Test4( 1, 1, 1, true, false);
462 Test4( 1, 1, 5, true, false);
463 Test4( 2, 1, 3, true, false);
464 Test4( 10, 1, 5, true, false);
465 Test4( 10, 10, 10, false, false);
466
467 RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "benchmarking...\n");
468 for (unsigned cThreads = 1; cThreads < 32; cThreads++)
469 Test4(cThreads, 2, 1, false, true);
470
471 /** @todo add a testcase where some stuff times out. */
472 }
473 else
474 {
475 /* threads, seconds, writePercent, yield, quiet */
476 RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "benchmarking...\n");
477 Test4( 1, 3, 1, false, true);
478 Test4( 1, 3, 1, false, true);
479 Test4( 1, 3, 1, false, true);
480 Test4( 2, 3, 1, false, true);
481 Test4( 2, 3, 1, false, true);
482 Test4( 2, 3, 1, false, true);
483 Test4( 3, 3, 1, false, true);
484 Test4( 3, 3, 1, false, true);
485 Test4( 3, 3, 1, false, true);
486 }
487 }
488
489 return RTTestSummaryAndDestroy(g_hTest);
490}
491
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