tstRTHeapOffset.cpp@ 98032

Last change on this file since 98032 was 96407, checked in by vboxsync, 2 years ago
scm copyright and license note update
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 12.5 KB

Line
1	/* $Id: tstRTHeapOffset.cpp 96407 2022-08-22 17:43:14Z vboxsync $ */
2	/** @file
3	* IPRT Testcase - Offset Based Heap.
4	*/
5
6	/*
7	* Copyright (C) 2006-2022 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
55	int 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.

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

Download in other formats: