VirtualBox

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

Last change on this file since 98103 was 98103, checked in by vboxsync, 2 years ago

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