VirtualBox

source: vbox/trunk/src/VBox/Runtime/testcase/tstRTMemPool.cpp@ 71435

Last change on this file since 71435 was 69111, checked in by vboxsync, 7 years ago

(C) year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 12.4 KB
Line 
1/* $Id: tstRTMemPool.cpp 69111 2017-10-17 14:26:02Z vboxsync $ */
2/** @file
3 * IPRT Testcase - MemPool.
4 */
5
6/*
7 * Copyright (C) 2009-2017 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 <iprt/mempool.h>
32
33#include <iprt/asm.h>
34#include <iprt/err.h>
35#include <iprt/initterm.h>
36#include <iprt/string.h>
37#include <iprt/test.h>
38#include <iprt/thread.h>
39#include <iprt/rand.h>
40
41
42/*********************************************************************************************************************************
43* Global Variables *
44*********************************************************************************************************************************/
45/** The test handle */
46static RTTEST g_hTest;
47/** Memory pool for tst4. */
48static RTMEMPOOL g_hMemPool4;
49
50
51/**
52 * Basic API checks.
53 * We'll return if any of these fails.
54 */
55static void tst1(RTMEMPOOL hMemPool)
56{
57 void *pv;
58
59 /* Normal alloc. */
60 RTTESTI_CHECK_RETV(pv = RTMemPoolAlloc(hMemPool, 1));
61 RTTESTI_CHECK_RETV(RTMemPoolRelease(hMemPool, pv) == 0);
62
63 RTTESTI_CHECK_RETV(pv = RTMemPoolAlloc(hMemPool, 0));
64 RTTESTI_CHECK_RETV(RTMemPoolRelease(hMemPool, pv) == 0);
65
66 /* Zeroed allocation. */
67 for (uint32_t i = 0; i < 512; i++)
68 {
69 RTTESTI_CHECK_RETV(pv = RTMemPoolAllocZ(hMemPool, 1024));
70 RTTESTI_CHECK(ASMMemFirstMismatchingU32(pv, 1024, 0) == NULL);
71 memset(pv, 'a', 1024);
72 RTTESTI_CHECK_RETV(RTMemPoolRefCount(pv) == 1);
73 RTTESTI_CHECK_RETV(RTMemPoolRelease(hMemPool, pv) == 0);
74 }
75
76 RTTESTI_CHECK_RETV(pv = RTMemPoolAllocZ(hMemPool, 0));
77 RTTESTI_CHECK_RETV(RTMemPoolRelease(hMemPool, pv) == 0);
78
79 /* Duped allocation. */
80 static const char szTest[] = "test string abcdef";
81 RTTESTI_CHECK_RETV(pv = RTMemPoolDup(hMemPool, szTest, sizeof(szTest)));
82 RTTESTI_CHECK(memcmp(pv, szTest, sizeof(szTest)) == 0);
83 RTTESTI_CHECK_RETV(RTMemPoolRelease(hMemPool, pv) == 0);
84
85 for (uint32_t i = 0; i < 512; i++)
86 {
87 size_t const cb = 256 - sizeof(szTest);
88 RTTESTI_CHECK_RETV(pv = RTMemPoolDupEx(hMemPool, szTest, sizeof(szTest), cb));
89 RTTESTI_CHECK(memcmp(pv, szTest, sizeof(szTest)) == 0);
90 RTTESTI_CHECK(ASMMemIsZero((uint8_t *)pv + sizeof(szTest), cb));
91 memset(pv, 'b', sizeof(szTest) + cb);
92 RTTESTI_CHECK_RETV(RTMemPoolRefCount(pv) == 1);
93 RTTESTI_CHECK_RETV(RTMemPoolRelease(hMemPool, pv) == 0);
94 }
95
96 /* Reallocation */
97 RTTESTI_CHECK_RETV(pv = RTMemPoolRealloc(hMemPool, NULL, 1));
98 RTTESTI_CHECK_RETV(pv = RTMemPoolRealloc(hMemPool, pv, 2));
99 RTTESTI_CHECK_RETV(RTMemPoolRelease(hMemPool, pv) == 0);
100
101 RTTESTI_CHECK_RETV(pv = RTMemPoolAlloc(hMemPool, 42));
102 RTTESTI_CHECK_RETV(pv = RTMemPoolRealloc(hMemPool, pv, 32));
103 RTTESTI_CHECK_RETV(RTMemPoolRelease(hMemPool, pv) == 0);
104
105 RTTESTI_CHECK_RETV(pv = RTMemPoolRealloc(hMemPool, NULL, 128));
106 RTTESTI_CHECK_RETV(pv = RTMemPoolRealloc(hMemPool, pv, 256));
107 RTTESTI_CHECK_RETV(RTMemPoolRealloc(hMemPool, pv, 0) == NULL);
108
109 /* Free (a bit hard to test) */
110 RTMemPoolFree(hMemPool, NULL);
111 RTMemPoolFree(hMemPool, RTMemPoolAlloc(hMemPool, 42));
112
113 /* Memory referencing. */
114 for (uint32_t i = 1; i <= 4096; i *= 3)
115 {
116 void *pv2;
117 RTTESTI_CHECK_RETV(pv = RTMemPoolAlloc(hMemPool, i));
118 RTTESTI_CHECK(RTMemPoolRefCount(pv) == 1);
119 memset(pv, 'a', i);
120 RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemFirstMismatchingU8(pv, i, 'a')) == NULL, ("i=%#x pv=%p off=%#x\n", i, pv,(uintptr_t)pv2 - (uintptr_t)pv));
121 RTTESTI_CHECK(RTMemPoolRetain(pv) == 2);
122 RTTESTI_CHECK(RTMemPoolRefCount(pv) == 2);
123 RTTESTI_CHECK(RTMemPoolRetain(pv) == 3);
124 RTTESTI_CHECK(RTMemPoolRefCount(pv) == 3);
125 RTTESTI_CHECK(RTMemPoolRetain(pv) == 4);
126 RTTESTI_CHECK(RTMemPoolRefCount(pv) == 4);
127 RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemFirstMismatchingU8(pv, i, 'a')) == NULL, ("i=%#x pv=%p off=%#x\n", i, pv, (uintptr_t)pv2 - (uintptr_t)pv));
128 RTTESTI_CHECK(RTMemPoolRelease(hMemPool, pv) == 3);
129 RTTESTI_CHECK(RTMemPoolRefCount(pv) == 3);
130 RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemFirstMismatchingU8(pv, i, 'a')) == NULL, ("i=%#x pv=%p off=%#x\n", i, pv, (uintptr_t)pv2 - (uintptr_t)pv));
131 RTTESTI_CHECK(RTMemPoolRetain(pv) == 4);
132 RTTESTI_CHECK(RTMemPoolRefCount(pv) == 4);
133 RTTESTI_CHECK(RTMemPoolRetain(pv) == 5);
134 RTTESTI_CHECK(RTMemPoolRefCount(pv) == 5);
135 RTTESTI_CHECK(RTMemPoolRetain(pv) == 6);
136 RTTESTI_CHECK(RTMemPoolRefCount(pv) == 6);
137 RTTESTI_CHECK(RTMemPoolRelease(NIL_RTMEMPOOL, pv) == 5);
138 RTTESTI_CHECK(RTMemPoolRelease(NIL_RTMEMPOOL, pv) == 4);
139 RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemFirstMismatchingU8(pv, i, 'a')) == NULL, ("i=%#x pv=%p off=%#x\n", i, pv, (uintptr_t)pv2 - (uintptr_t)pv));
140
141 for (uint32_t cRefs = 3;; cRefs--)
142 {
143 RTTESTI_CHECK(RTMemPoolRelease(hMemPool, pv) == cRefs);
144 if (cRefs == 0)
145 break;
146 RTTESTI_CHECK(RTMemPoolRefCount(pv) == cRefs);
147 RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemFirstMismatchingU8(pv, i, 'a')) == NULL, ("i=%#x pv=%p off=%#x cRefs=%d\n", i, pv, (uintptr_t)pv2 - (uintptr_t)pv, cRefs));
148 for (uint32_t j = 0; j < 42; j++)
149 {
150 RTTESTI_CHECK_RETV(pv2 = RTMemPoolAlloc(hMemPool, i));
151 RTTESTI_CHECK_RETV(pv2 != pv);
152 memset(pv2, 'f', i);
153 RTTESTI_CHECK(RTMemPoolRelease(hMemPool, pv2) == 0);
154 RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemFirstMismatchingU8(pv, i, 'a')) == NULL, ("i=%#x pv=%p off=%#x cRefs=%d\n", i, pv, (uintptr_t)pv2 - (uintptr_t)pv, cRefs));
155 }
156 }
157 }
158}
159
160
161/**
162 * Test automatic cleanup upon destruction.
163 */
164static void tst3(void)
165{
166 RTTestISub("Destroy non-empty pool");
167
168 /*
169 * Nothing freed.
170 */
171 RTMEMPOOL hMemPool;
172 RTTESTI_CHECK_RC_RETV(RTMemPoolCreate(&hMemPool, "test 3a"), VINF_SUCCESS);
173 RTTESTI_CHECK_RETV(RTMemPoolAlloc(hMemPool, 10));
174 RTTESTI_CHECK_RETV(RTMemPoolAlloc(hMemPool, 20));
175 RTTESTI_CHECK_RETV(RTMemPoolAlloc(hMemPool, 40));
176 RTTESTI_CHECK_RETV(RTMemPoolAlloc(hMemPool, 80));
177 RTTESTI_CHECK_RC_RETV(RTMemPoolDestroy(hMemPool), VINF_SUCCESS);
178
179 /*
180 * Pseudo random freeing to test list maintenance.
181 */
182 RTRAND hRand;
183 RTTESTI_CHECK_RC_OK_RETV(RTRandAdvCreateParkMiller(&hRand));
184
185 for (uint32_t i = 0; i < 10; i++)
186 {
187 RTTESTI_CHECK_RC_RETV(RTMemPoolCreate(&hMemPool, "test 3b"), VINF_SUCCESS);
188
189 void *apvHistory[256];
190 RT_ZERO(apvHistory);
191
192 uint32_t cBlocks = 0;
193 uint32_t j;
194 for (j = 0; j < RT_ELEMENTS(apvHistory) - i * 7; j++)
195 {
196 RTTESTI_CHECK_RETV(apvHistory[j] = RTMemPoolAlloc(hMemPool, j));
197 memset(apvHistory[j], 'a', j);
198 cBlocks++;
199
200 if (RTRandAdvU32Ex(hRand, 0, 4) == 4)
201 {
202 uint32_t iFree = RTRandAdvU32Ex(hRand, 0, j);
203 cBlocks -= apvHistory[iFree] != NULL;
204 RTTESTI_CHECK_RETV(RTMemPoolRelease(hMemPool, apvHistory[iFree]) == 0);
205 apvHistory[iFree] = NULL;
206 }
207 }
208
209 RTTESTI_CHECK_RC_RETV(RTMemPoolDestroy(hMemPool), VINF_SUCCESS);
210 RTTestIPrintf(RTTESTLVL_INFO, "cBlocks=%u j=%u\n", cBlocks, j);
211 }
212
213 RTRandAdvDestroy(hRand);
214}
215
216
217/** Thread function for tst4. */
218static DECLCALLBACK(int) tst4Thread(RTTHREAD hSelf, void *pvArg)
219{
220// uint32_t iThread = (uint32_t)(uintptr_t)pvArg;
221 RTMEMPOOL hMemPool = g_hMemPool4;
222 RT_NOREF_PV(pvArg);
223
224
225 /* setup. */
226 RTTestSetDefault(g_hTest, NULL);
227
228 /* wait for the kick-off */
229 RTThreadUserWait(hSelf, RT_INDEFINITE_WAIT);
230
231 /* do the work. */
232 for (uint32_t i = 0; i < 1024; i++)
233 {
234 void *apvHistory[256];
235 RT_ZERO(apvHistory);
236 uint32_t j;
237 for (j = 0; j < RT_ELEMENTS(apvHistory) - (i % 200); j++)
238 RTTESTI_CHECK_RET(apvHistory[j] = RTMemPoolAlloc(hMemPool, (i & 15) + (j & 63)), VERR_NO_MEMORY);
239 for (uint32_t k = i & 7; k < j; k += 3)
240 {
241 RTTESTI_CHECK_RET(RTMemPoolRelease(hMemPool, apvHistory[k]) == 0, VERR_INTERNAL_ERROR);
242 apvHistory[k] = NULL;
243 }
244 while (j-- > 0)
245 RTTESTI_CHECK_RET(RTMemPoolRelease(hMemPool, apvHistory[j]) == 0, VERR_INTERNAL_ERROR);
246 }
247
248 return VINF_SUCCESS;
249}
250
251/** sub test */
252static void tst4Sub(uint32_t cThreads)
253{
254 RTTestISubF("Serialization - %u threads", cThreads);
255 RTMEMPOOL hMemPool;
256 RTTESTI_CHECK_RC_RETV(RTMemPoolCreate(&hMemPool, "test 2a"), VINF_SUCCESS);
257 g_hMemPool4 = hMemPool;
258
259 PRTTHREAD pahThreads = (PRTTHREAD)RTMemPoolAlloc(hMemPool, cThreads * sizeof(RTTHREAD));
260 RTTESTI_CHECK(pahThreads);
261 if (pahThreads)
262 {
263 /* start them. */
264 for (uint32_t i = 0; i < cThreads; i++)
265 {
266 int rc = RTThreadCreateF(&pahThreads[i], tst4Thread, (void *)(uintptr_t)i, 0,
267 RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "tst4-%u/%u", i, cThreads);
268 RTTESTI_CHECK_RC_OK(rc);
269 if (RT_FAILURE(rc))
270 pahThreads[i] = NIL_RTTHREAD;
271 }
272 RTThreadYield();
273
274 /* kick them off. */
275 for (uint32_t i = 0; i < cThreads; i++)
276 if (pahThreads[i] != NIL_RTTHREAD)
277 RTTESTI_CHECK_RC_OK(RTThreadUserSignal(pahThreads[i]));
278
279 /* wait for them. */
280 for (uint32_t i = 0; i < cThreads; i++)
281 if (pahThreads[i] != NIL_RTTHREAD)
282 {
283 int rc = RTThreadWait(pahThreads[i], 2*60*1000, NULL);
284 RTTESTI_CHECK_RC_OK(rc);
285 }
286 }
287
288 RTTESTI_CHECK_RC(RTMemPoolDestroy(hMemPool), VINF_SUCCESS);
289}
290
291
292/**
293 * Starts a bunch of threads beating on a pool to test serialization.
294 */
295static void tst4(void)
296{
297 /*
298 * Test it with a few different thread counts.
299 */
300 tst4Sub(1);
301 tst4Sub(2);
302 tst4Sub(3);
303 tst4Sub(4);
304 tst4Sub(8);
305 tst4Sub(16);
306}
307
308
309int main()
310{
311 RTTEST hTest;
312 int rc = RTTestInitAndCreate("tstRTMemPool", &hTest);
313 if (rc)
314 return rc;
315 RTTestBanner(hTest);
316 g_hTest = hTest;
317
318 /*
319 * Smoke tests using first the default and then a custom pool.
320 */
321 RTTestSub(hTest, "Smoke test on default pool");
322 tst1(RTMEMPOOL_DEFAULT);
323
324 RTTestSub(hTest, "Smoke test on custom pool");
325 RTMEMPOOL hMemPool;
326 RTTESTI_CHECK_RC(rc = RTMemPoolCreate(&hMemPool, "test 2a"), VINF_SUCCESS);
327 if (RT_SUCCESS(rc))
328 RTTESTI_CHECK_RC(rc = RTMemPoolDestroy(hMemPool), VINF_SUCCESS);
329 RTTESTI_CHECK_RC(rc = RTMemPoolDestroy(NIL_RTMEMPOOL), VINF_SUCCESS);
330 RTTESTI_CHECK_RC(rc = RTMemPoolDestroy(RTMEMPOOL_DEFAULT), VINF_SUCCESS);
331 RTTESTI_CHECK_RC(rc = RTMemPoolDestroy(RTMEMPOOL_DEFAULT), VINF_SUCCESS);
332
333 RTTESTI_CHECK_RC(rc = RTMemPoolCreate(&hMemPool, "test 2b"), VINF_SUCCESS);
334 if (RT_SUCCESS(rc))
335 {
336 tst1(hMemPool);
337 RTTESTI_CHECK_RC(rc = RTMemPoolDestroy(hMemPool), VINF_SUCCESS);
338 }
339
340 /*
341 * Further tests.
342 */
343 tst3();
344 tst4();
345
346 /*
347 * Summary.
348 */
349 return RTTestSummaryAndDestroy(hTest);
350}
351
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