tstRTHeapOffset.cpp@ 49329

Last change on this file since 49329 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: 11.9 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: