VirtualBox

source: vbox/trunk/src/VBox/Runtime/testcase/tstRTHeapOffset.cpp@ 83743

Last change on this file since 83743 was 82968, checked in by vboxsync, 5 years ago

Copyright year updates by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 12.1 KB
Line 
1/* $Id: tstRTHeapOffset.cpp 82968 2020-02-04 10:35:17Z vboxsync $ */
2/** @file
3 * IPRT Testcase - Offset Based Heap.
4 */
5
6/*
7 * Copyright (C) 2006-2020 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/heap.h>
32
33#include <iprt/assert.h>
34#include <iprt/errcore.h>
35#include <iprt/initterm.h>
36#include <iprt/log.h>
37#include <iprt/rand.h>
38#include <iprt/stream.h>
39#include <iprt/string.h>
40#include <iprt/param.h>
41#include <iprt/test.h>
42#include <iprt/time.h>
43
44
45int main(int argc, char **argv)
46{
47 RT_NOREF_PV(argc); RT_NOREF_PV(argv);
48
49 /*
50 * Init runtime.
51 */
52 RTTEST hTest;
53 int rc = RTTestInitAndCreate("tstRTHeapOffset", &hTest);
54 if (rc)
55 return rc;
56 RTTestBanner(hTest);
57
58 /*
59 * Create a heap.
60 */
61 RTTestSub(hTest, "Basics");
62 static uint8_t s_abMem[128*1024];
63 RTHEAPOFFSET Heap;
64 RTTESTI_CHECK_RC(rc = RTHeapOffsetInit(&Heap, &s_abMem[1], sizeof(s_abMem) - 1), VINF_SUCCESS);
65 if (RT_FAILURE(rc))
66 return RTTestSummaryAndDestroy(hTest);
67
68 /*
69 * Try allocate.
70 */
71 static struct TstHeapOffsetOps
72 {
73 size_t cb;
74 unsigned uAlignment;
75 void *pvAlloc;
76 unsigned iFreeOrder;
77 } s_aOps[] =
78 {
79 { 16, 0, NULL, 0 }, // 0
80 { 16, 4, NULL, 1 },
81 { 16, 8, NULL, 2 },
82 { 16, 16, NULL, 5 },
83 { 16, 32, NULL, 4 },
84 { 32, 0, NULL, 3 }, // 5
85 { 31, 0, NULL, 6 },
86 { 1024, 0, NULL, 8 },
87 { 1024, 32, NULL, 10 },
88 { 1024, 32, NULL, 12 },
89 { PAGE_SIZE, PAGE_SIZE, NULL, 13 }, // 10
90 { 1024, 32, NULL, 9 },
91 { PAGE_SIZE, 32, NULL, 11 },
92 { PAGE_SIZE, PAGE_SIZE, NULL, 14 },
93 { 16, 0, NULL, 15 },
94 { 9, 0, NULL, 7 }, // 15
95 { 16, 0, NULL, 7 },
96 { 36, 0, NULL, 7 },
97 { 16, 0, NULL, 7 },
98 { 12344, 0, NULL, 7 },
99 { 50, 0, NULL, 7 }, // 20
100 { 16, 0, NULL, 7 },
101 };
102 uint32_t i;
103 RTHeapOffsetDump(Heap, (PFNRTHEAPOFFSETPRINTF)(uintptr_t)RTPrintf); /** @todo Add some detail info output with a signature identical to RTPrintf. */
104 size_t cbBefore = RTHeapOffsetGetFreeSize(Heap);
105 static char const s_szFill[] = "01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
106
107 /* allocate */
108 for (i = 0; i < RT_ELEMENTS(s_aOps); i++)
109 {
110 s_aOps[i].pvAlloc = RTHeapOffsetAlloc(Heap, s_aOps[i].cb, s_aOps[i].uAlignment);
111 RTTESTI_CHECK_MSG(s_aOps[i].pvAlloc, ("RTHeapOffsetAlloc(%p, %#x, %#x,) -> NULL i=%d\n", (void *)Heap, s_aOps[i].cb, s_aOps[i].uAlignment, i));
112 if (!s_aOps[i].pvAlloc)
113 return RTTestSummaryAndDestroy(hTest);
114
115 memset(s_aOps[i].pvAlloc, s_szFill[i], s_aOps[i].cb);
116 RTTESTI_CHECK_MSG(RT_ALIGN_P(s_aOps[i].pvAlloc, (s_aOps[i].uAlignment ? s_aOps[i].uAlignment : 8)) == s_aOps[i].pvAlloc,
117 ("RTHeapOffsetAlloc(%p, %#x, %#x,) -> %p\n", (void *)Heap, s_aOps[i].cb, s_aOps[i].uAlignment, i));
118 if (!s_aOps[i].pvAlloc)
119 return RTTestSummaryAndDestroy(hTest);
120 }
121
122 /* free and allocate the same node again. */
123 for (i = 0; i < RT_ELEMENTS(s_aOps); i++)
124 {
125 if (!s_aOps[i].pvAlloc)
126 continue;
127 //RTPrintf("debug: i=%d pv=%#x cb=%#zx align=%#zx cbReal=%#zx\n", i, s_aOps[i].pvAlloc,
128 // s_aOps[i].cb, s_aOps[i].uAlignment, RTHeapOffsetSize(Heap, s_aOps[i].pvAlloc));
129 size_t cbBeforeSub = RTHeapOffsetGetFreeSize(Heap);
130 RTHeapOffsetFree(Heap, s_aOps[i].pvAlloc);
131 size_t cbAfterSubFree = RTHeapOffsetGetFreeSize(Heap);
132
133 void *pv;
134 pv = RTHeapOffsetAlloc(Heap, s_aOps[i].cb, s_aOps[i].uAlignment);
135 RTTESTI_CHECK_MSG(pv, ("RTHeapOffsetAlloc(%p, %#x, %#x,) -> NULL i=%d\n", (void *)Heap, s_aOps[i].cb, s_aOps[i].uAlignment, i));
136 if (!pv)
137 return RTTestSummaryAndDestroy(hTest);
138 //RTPrintf("debug: i=%d pv=%p cbReal=%#zx cbBeforeSub=%#zx cbAfterSubFree=%#zx cbAfterSubAlloc=%#zx \n", i, pv, RTHeapOffsetSize(Heap, pv),
139 // cbBeforeSub, cbAfterSubFree, RTHeapOffsetGetFreeSize(Heap));
140
141 if (pv != s_aOps[i].pvAlloc)
142 RTTestIPrintf(RTTESTLVL_ALWAYS, "Warning: Free+Alloc returned different address. new=%p old=%p i=%d\n", pv, s_aOps[i].pvAlloc, i);
143 s_aOps[i].pvAlloc = pv;
144 size_t cbAfterSubAlloc = RTHeapOffsetGetFreeSize(Heap);
145 if (cbBeforeSub != cbAfterSubAlloc)
146 {
147 RTTestIPrintf(RTTESTLVL_ALWAYS, "Warning: cbBeforeSub=%#zx cbAfterSubFree=%#zx cbAfterSubAlloc=%#zx. i=%d\n",
148 cbBeforeSub, cbAfterSubFree, cbAfterSubAlloc, i);
149 //return 1; - won't work correctly until we start creating free block instead of donating memory on alignment.
150 }
151 }
152
153 /* make a copy of the heap and the to-be-freed list. */
154 static uint8_t s_abMemCopy[sizeof(s_abMem)];
155 memcpy(s_abMemCopy, s_abMem, sizeof(s_abMem));
156 uintptr_t offDelta = (uintptr_t)&s_abMemCopy[0] - (uintptr_t)&s_abMem[0];
157 RTHEAPOFFSET hHeapCopy = (RTHEAPOFFSET)((uintptr_t)Heap + offDelta);
158 static struct TstHeapOffsetOps s_aOpsCopy[RT_ELEMENTS(s_aOps)];
159 memcpy(&s_aOpsCopy[0], &s_aOps[0], sizeof(s_aOps));
160
161 /* free it in a specific order. */
162 int cFreed = 0;
163 for (i = 0; i < RT_ELEMENTS(s_aOps); i++)
164 {
165 unsigned j;
166 for (j = 0; j < RT_ELEMENTS(s_aOps); j++)
167 {
168 if ( s_aOps[j].iFreeOrder != i
169 || !s_aOps[j].pvAlloc)
170 continue;
171 //RTPrintf("j=%d i=%d free=%d cb=%d pv=%p\n", j, i, RTHeapOffsetGetFreeSize(Heap), s_aOps[j].cb, s_aOps[j].pvAlloc);
172 RTHeapOffsetFree(Heap, s_aOps[j].pvAlloc);
173 s_aOps[j].pvAlloc = NULL;
174 cFreed++;
175 }
176 }
177 RTTESTI_CHECK(cFreed == RT_ELEMENTS(s_aOps));
178 RTTestIPrintf(RTTESTLVL_ALWAYS, "i=done free=%d\n", RTHeapOffsetGetFreeSize(Heap));
179
180 /* check that we're back at the right amount of free memory. */
181 size_t cbAfter = RTHeapOffsetGetFreeSize(Heap);
182 if (cbBefore != cbAfter)
183 {
184 RTTestIPrintf(RTTESTLVL_ALWAYS,
185 "Warning: Either we've split out an alignment chunk at the start, or we've got\n"
186 " an alloc/free accounting bug: cbBefore=%d cbAfter=%d\n", cbBefore, cbAfter);
187 RTHeapOffsetDump(Heap, (PFNRTHEAPOFFSETPRINTF)(uintptr_t)RTPrintf);
188 }
189
190 /* relocate and free the bits in heap2 now. */
191 RTTestSub(hTest, "Relocated Heap");
192 /* free it in a specific order. */
193 int cFreed2 = 0;
194 for (i = 0; i < RT_ELEMENTS(s_aOpsCopy); i++)
195 {
196 unsigned j;
197 for (j = 0; j < RT_ELEMENTS(s_aOpsCopy); j++)
198 {
199 if ( s_aOpsCopy[j].iFreeOrder != i
200 || !s_aOpsCopy[j].pvAlloc)
201 continue;
202 //RTPrintf("j=%d i=%d free=%d cb=%d pv=%p\n", j, i, RTHeapOffsetGetFreeSize(hHeapCopy), s_aOpsCopy[j].cb, s_aOpsCopy[j].pvAlloc);
203 RTHeapOffsetFree(hHeapCopy, (uint8_t *)s_aOpsCopy[j].pvAlloc + offDelta);
204 s_aOpsCopy[j].pvAlloc = NULL;
205 cFreed2++;
206 }
207 }
208 RTTESTI_CHECK(cFreed2 == RT_ELEMENTS(s_aOpsCopy));
209
210 /* check that we're back at the right amount of free memory. */
211 size_t cbAfterCopy = RTHeapOffsetGetFreeSize(hHeapCopy);
212 RTTESTI_CHECK_MSG(cbAfterCopy == cbAfter, ("cbAfterCopy=%zu cbAfter=%zu\n", cbAfterCopy, cbAfter));
213
214 /*
215 * Use random allocation pattern
216 */
217 RTTestSub(hTest, "Random Test");
218 RTTESTI_CHECK_RC(rc = RTHeapOffsetInit(&Heap, &s_abMem[1], sizeof(s_abMem) - 1), VINF_SUCCESS);
219 if (RT_FAILURE(rc))
220 return RTTestSummaryAndDestroy(hTest);
221
222 RTRAND hRand;
223 RTTESTI_CHECK_RC(rc = RTRandAdvCreateParkMiller(&hRand), VINF_SUCCESS);
224 if (RT_FAILURE(rc))
225 return RTTestSummaryAndDestroy(hTest);
226#if 0
227 RTRandAdvSeed(hRand, 42);
228#else
229 RTRandAdvSeed(hRand, RTTimeNanoTS());
230#endif
231
232 static struct
233 {
234 size_t cb;
235 void *pv;
236 } s_aHistory[1536];
237 RT_ZERO(s_aHistory);
238
239 for (unsigned iTest = 0; iTest < 131072; iTest++)
240 {
241 i = RTRandAdvU32Ex(hRand, 0, RT_ELEMENTS(s_aHistory) - 1);
242 if (!s_aHistory[i].pv)
243 {
244 uint32_t uAlignment = 1 << RTRandAdvU32Ex(hRand, 0, 7);
245 s_aHistory[i].cb = RTRandAdvU32Ex(hRand, 9, 1024);
246 s_aHistory[i].pv = RTHeapOffsetAlloc(Heap, s_aHistory[i].cb, uAlignment);
247 if (!s_aHistory[i].pv)
248 {
249 s_aHistory[i].cb = 9;
250 s_aHistory[i].pv = RTHeapOffsetAlloc(Heap, s_aHistory[i].cb, 0);
251 }
252 if (s_aHistory[i].pv)
253 memset(s_aHistory[i].pv, 0xbb, s_aHistory[i].cb);
254 }
255 else
256 {
257 RTHeapOffsetFree(Heap, s_aHistory[i].pv);
258 s_aHistory[i].pv = NULL;
259 }
260
261 if ((iTest % 7777) == 7776)
262 {
263 /* exhaust the heap */
264 for (i = 0; i < RT_ELEMENTS(s_aHistory) && RTHeapOffsetGetFreeSize(Heap) >= 256; i++)
265 if (!s_aHistory[i].pv)
266 {
267 s_aHistory[i].cb = RTRandAdvU32Ex(hRand, 256, 16384);
268 s_aHistory[i].pv = RTHeapOffsetAlloc(Heap, s_aHistory[i].cb, 0);
269 }
270 for (i = 0; i < RT_ELEMENTS(s_aHistory) && RTHeapOffsetGetFreeSize(Heap); i++)
271 {
272 if (!s_aHistory[i].pv)
273 {
274 s_aHistory[i].cb = 1;
275 s_aHistory[i].pv = RTHeapOffsetAlloc(Heap, s_aHistory[i].cb, 1);
276 }
277 if (s_aHistory[i].pv)
278 memset(s_aHistory[i].pv, 0x55, s_aHistory[i].cb);
279 }
280 RTTESTI_CHECK_MSG(RTHeapOffsetGetFreeSize(Heap) == 0, ("%zu\n", RTHeapOffsetGetFreeSize(Heap)));
281 }
282 else if ((iTest % 7777) == 1111)
283 {
284 /* free all */
285 for (i = 0; i < RT_ELEMENTS(s_aHistory); i++)
286 {
287 RTHeapOffsetFree(Heap, s_aHistory[i].pv);
288 s_aHistory[i].pv = NULL;
289 }
290 size_t cbAfterRand = RTHeapOffsetGetFreeSize(Heap);
291 RTTESTI_CHECK_MSG(cbAfterRand == cbAfter, ("cbAfterRand=%zu cbAfter=%zu\n", cbAfterRand, cbAfter));
292 }
293 }
294
295 /* free the rest. */
296 for (i = 0; i < RT_ELEMENTS(s_aHistory); i++)
297 {
298 RTHeapOffsetFree(Heap, s_aHistory[i].pv);
299 s_aHistory[i].pv = NULL;
300 }
301
302 /* check that we're back at the right amount of free memory. */
303 size_t cbAfterRand = RTHeapOffsetGetFreeSize(Heap);
304 RTTESTI_CHECK_MSG(cbAfterRand == cbAfter, ("cbAfterRand=%zu cbAfter=%zu\n", cbAfterRand, cbAfter));
305
306 return RTTestSummaryAndDestroy(hTest);
307}
308
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