Context Navigation

bmem_test.c

Last change on this file was 76, checked in by megakiss, 10 years ago
1W 대기전력을 만족시키기 위하여 POWEROFF시 튜너를 Standby 상태로 함
Property svn:executable set to ``*
File size: 11.4 KB

Line
1	/***************************************************************************
2	* Copyright (c) 2003-2009, Broadcom Corporation
3	* All Rights Reserved
4	* Confidential Property of Broadcom Corporation
5	*
6	* THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
7	* AGREEMENT BETWEEN THE USER AND BROADCOM. YOU HAVE NO RIGHT TO USE OR
8	* EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
9	*
10	* $brcm_Workfile: bmem_test.c $
11	* $brcm_Revision: Hydra_Software_Devel/11 $
12	* $brcm_Date: 5/26/09 4:24p $
13	*
14	* Module Description:
15	*
16	* Revision History:
17	*
18	* $brcm_Log: /magnum/basemodules/mem/test/bmem_test.c $
19	*
20	* Hydra_Software_Devel/11 5/26/09 4:24p albertl
21	* PR55389: Replaced uintptr_t with uint32_t.
22	*
23	* Hydra_Software_Devel/10 4/27/05 6:04p jasonh
24	* PR 15059: Changed debug application to remove newlines and add some
25	* more information.
26	*
27	* Hydra_Software_Devel/9 5/28/04 11:37a hongtaoz
28	* PR10059: added alignment test; took heap error counts into test result
29	* judgement;
30	*
31	* Hydra_Software_Devel/8 5/27/04 7:38p hongtaoz
32	* PR10059: added more debug messages; enhanced with random free/alloc
33	* loops to test complex scenarioes.
34	*
35	* Hydra_Software_Devel/7 5/26/04 6:59p hongtaoz
36	* PR10059: sorted the freed heap in size ascending order; fixed compile
37	* error for bmem test; dump heap map before destroying the heap for bmem
38	* test;
39	*
40	* Hydra_Software_Devel/6 12/31/03 12:02p jasonh
41	* PR 8940: Changed return type of destroyheap to void. Removed use of
42	* DEBUG macro and printf.
43	*
44	* Hydra_Software_Devel/5 11/11/03 11:19a jasonh
45	* PR 8589: removed leaked resource check and added offset to sample heap.
46	*
47	* Hydra_Software_Devel/4 9/15/03 5:25p jasonh
48	* Re-wrote test from scratch.
49	*
50	* Hydra_Software_Devel/3 3/21/03 6:03p erickson
51	* added printInfo for debug
52	*
53	* Hydra_Software_Devel/2 3/20/03 3:51p erickson
54	* renamed all MEM_ to BMEM_
55	*
56	* Hydra_Software_Devel/1 3/20/03 3:24p erickson
57	* initial bmem work, taken from SetTop/memorylib
58	*
59	***************************************************************************/
60	#include "bstd.h"
61	#include "bkni.h"
62	#include "bkni_multi.h"
63	#include "bdbg.h"
64
65	BDBG_MODULE(memorymanagertest);
66
67	#include "bmem.h"
68	#include "bmem_debug.h"
69	#include "bmem_config.h"
70	#include "bmem_test.h"
71
72	static uint8_t s_aBytes[1024 * 1024];
73
74	static BERR_Code BMEM_Test_CheckAlloc(
75	BMEM_Handle heap,
76	unsigned int uiHeapAlignment,
77	void *pAddr,
78	size_t ulAddrSize,
79	unsigned int uiAddrAlignment,
80	unsigned int uiAddrBoundary
81	)
82	{
83	BERR_Code err = BERR_SUCCESS;
84	uint32_t ulAddr = (uint32_t)pAddr;
85	uint32_t ulConvertedOffset;
86	void *pConvertedAddr;
87
88	/* fill allocated block with non-guardbanding value */
89	BKNI_Memset(pAddr, 0xFF, ulAddrSize);
90
91	/* doesn't match heap alignment? */
92	if ((((UINT32_C(1) << uiHeapAlignment) - 1) & ulAddr) != 0)
93	{
94	/* failed to match heap alignment */
95	err = BERR_TRACE(BERR_UNKNOWN);
96	BDBG_ERR(("BMEM_Test_CheckAlloc: Failed heap alignment"));
97	goto done;
98	}
99
100	/* doesn't match address alignment? */
101	if ((((UINT32_C(1) << uiAddrAlignment) - 1) & ulAddr) != 0)
102	{
103	/* failed to match address alignment */
104	err = BERR_TRACE(BERR_UNKNOWN);
105	BDBG_ERR(("BMEM_Test_CheckAlloc: Failed address alignment"));
106	goto done;
107	}
108
109	/* check boundary */
110
111	/* convert address -> offset */
112	err = BERR_TRACE(BMEM_ConvertAddressToOffset(heap, pAddr,
113	&ulConvertedOffset));
114
115	if (err != BERR_SUCCESS)
116	{
117	/* unable to convert address -> offset */
118	BDBG_ERR(("BMEM_Test_CheckAlloc: Failed address -> offset conversion"));
119	goto done;
120	}
121
122	/* convert offset -> address */
123	err = BERR_TRACE(BMEM_ConvertOffsetToAddress(heap, ulConvertedOffset,
124	&pConvertedAddr));
125	if (err != BERR_SUCCESS)
126	{
127	/* unable to convert address -> offset */
128	BDBG_ERR(("BMEM_Test_CheckAlloc: Failed offset -> address conversion"));
129	goto done;
130	}
131
132	/* insure that addresses are the same */
133	if (pAddr != pConvertedAddr)
134	{
135	/* addresses did not match */
136	err = BERR_TRACE(BERR_UNKNOWN);
137	BDBG_ERR(("BMEM_Test_CheckAlloc: Failed address match"));
138	goto done;
139	}
140
141	/* validate heap */
142	err = BERR_TRACE(BMEM_ValidateHeap(heap));
143	if (err != BERR_SUCCESS)
144	{
145	/* invalid heap */
146	BDBG_ERR(("BMEM_Test_CheckAlloc: Invalid heap"));
147	goto done;
148	}
149
150	done:
151	/* return status */
152	return err;
153	}
154
155	void BMEM_Test_DisplayConfig(
156	void )
157	{
158	/* header */
159	BKNI_Printf("BMEM compile-time configuration:\n\n");
160
161	/* safety config */
162	BKNI_Printf("BMEM_SAFETY_CONFIG = ");
163	#if (BMEM_SAFETY_CONFIG == BMEM_CONFIG_FASTEST)
164	BKNI_Printf("BMEM_CONFIG_FASTEST\n");
165	#elif (BMEM_SAFETY_CONFIG == BMEM_CONFIG_NORMAL)
166	BKNI_Printf("BMEM_CONFIG_NORMAL\n");
167	#elif (BMEM_SAFETY_CONFIG == BMEM_CONFIG_TRACK)
168	BKNI_Printf("BMEM_CONFIG_TRACK\n");
169	#elif (BMEM_SAFETY_CONFIG == BMEM_CONFIG_SAFE)
170	BKNI_Printf("BMEM_CONFIG_SAFE\n");
171	#elif (BMEM_SAFETY_CONFIG == BMEM_CONFIG_SAFEST)
172	BKNI_Printf("BMEM_CONFIG_SAFEST\n");
173	#else
174	BKNI_Printf("*UNKNOWN*\n");
175	#endif
176
177	/* bookkeeping config */
178	BKNI_Printf("BMEM_BOOKKEEPING_CONFIG = ");
179	#if (BMEM_BOOKKEEPING_CONFIG == BMEM_BOOKKEEPING_LOCAL)
180	BKNI_Printf("BMEM_BOOKKEEPING_LOCAL\n");
181	#elif (BMEM_BOOKKEEPING_CONFIG == BMEM_BOOKKEEPING_SYSTEM)
182	BKNI_Printf("BMEM_BOOKKEEPING_SYSTEM\n");
183	#else
184	BKNI_Printf("*UNKNOWN*\n");
185	#endif
186
187	/* reentrant config */
188	BKNI_Printf("BMEM_REENTRANT = ");
189	#if (BMEM_REENTRANT_CONFIG == BMEM_REENTRANT)
190	BKNI_Printf("BMEM_REENTRANT\n");
191	#elif (BMEM_REENTRANT_CONFIG == BMEM_NOT_REENTRANT)
192	BKNI_Printf("BMEM_NOT_REENTRANT\n");
193	#else
194	BKNI_Printf("*UNKNOWN*\n");
195	#endif
196
197	/* test header */
198	BKNI_Printf("------------------------------------------------\n");
199	}
200
201	BERR_Code BMEM_Test_DoTest1(
202	void )
203	{
204	BERR_Code err = BERR_SUCCESS;
205	BMEM_Handle heap;
206	void apvAlloced[1024 128];
207	unsigned int uiNumAlloc = 0;
208	size_t zSize;
209	unsigned int i;
210	uint32_t ulConvertOffset;
211	uint32_t ulErrCnt;
212
213	/* set global debug level */
214	BDBG_SetLevel(BDBG_eWrn);
215
216	#ifdef BMEM_TEST_DEBUG
217	BDBG_SetModuleLevel("memorymanagertest", BDBG_eMsg);
218	BDBG_SetModuleLevel("BMEM", BDBG_eMsg);
219	#else
220	BDBG_SetModuleLevel("BMEM", BDBG_eWrn);
221	#endif
222
223	/* Create heap */
224	BKNI_Printf("Allocate 1024x1024 bytes at offset 0x2000000 as the heap.\n");
225	err = BERR_TRACE(BMEM_CreateHeap(&heap, (void *)s_aBytes,
226	0x2000000, 1024*1024, 0));
227	if (err != BERR_SUCCESS)
228	{
229	/* error creating heap */
230	BDBG_ERR(("BMEM_Test_DoTest1: Failed heap create"));
231	goto done;
232	}
233
234	do {
235	/* allocate various sizes until failure */
236	while (uiNumAlloc + 3 < 1024 * 128)
237	{
238	/* allocate tiny */
239	apvAlloced[uiNumAlloc] = BMEM_Alloc(heap, 4);
240	if (!apvAlloced[uiNumAlloc])
241	{
242	/* unable to allocate any more of this size */
243	break;
244	}
245
246	/* check tiny */
247	err = BERR_TRACE(BMEM_Test_CheckAlloc(heap, 0,
248	apvAlloced[uiNumAlloc], 4, 0, 0));
249	if (err != BERR_SUCCESS)
250	{
251	/* error */
252	goto done;
253	}
254	BDBG_MSG(("---- tiny alloc(4-byte) #%d.", uiNumAlloc));
255	uiNumAlloc++;
256
257	/* allocate small */
258	apvAlloced[uiNumAlloc] = BMEM_AllocAligned(heap, 64, 2, 0);
259	if (!apvAlloced[uiNumAlloc])
260	{
261	/* unable to allocate any more of this size */
262	break;
263	}
264
265	/* check small */
266	err = BERR_TRACE(BMEM_Test_CheckAlloc(heap, 0,
267	apvAlloced[uiNumAlloc], 64, 2, 0));
268	if (err != BERR_SUCCESS)
269	{
270	/* error */
271	goto done;
272	}
273	BDBG_MSG(("---- small alloc(64-byte) #%d.", uiNumAlloc));
274	uiNumAlloc++;
275
276	/* allocate medium */
277	apvAlloced[uiNumAlloc] = BMEM_AllocAligned(heap, 1024, 4, 0);
278	if (!apvAlloced[uiNumAlloc])
279	{
280	/* unable to allocate any more of this size */
281	break;
282	}
283
284	/* check medium */
285	err = BERR_TRACE(BMEM_Test_CheckAlloc(heap, 0,
286	apvAlloced[uiNumAlloc], 1024, 4, 0));
287	if (err != BERR_SUCCESS)
288	{
289	/* error */
290	goto done;
291	}
292	BDBG_MSG(("---- medium alloc(1024-byte) #%d.", uiNumAlloc));
293	uiNumAlloc++;
294
295	/* allocate large */
296	apvAlloced[uiNumAlloc] = BMEM_AllocAligned(heap, 16 * 1024, 5, 0);
297	if (!apvAlloced[uiNumAlloc])
298	{
299	/* unable to allocate any more of this size */
300	break;
301	}
302
303	/* check large */
304	err = BERR_TRACE(BMEM_Test_CheckAlloc(heap, 0,
305	apvAlloced[uiNumAlloc], 16 * 1024, 5, 0));
306	if (err != BERR_SUCCESS)
307	{
308	/* error */
309	goto done;
310	}
311	BDBG_MSG(("---- large alloc(16kbyte) #%d.", uiNumAlloc));
312	uiNumAlloc++;
313
314	/* allocate huge */
315	apvAlloced[uiNumAlloc] = BMEM_AllocAligned(heap, 64 * 1024, 8, 0);
316	if (!apvAlloced[uiNumAlloc])
317	{
318	/* unable to allocate any more of this size */
319	break;
320	}
321
322	/* check huge */
323	err = BERR_TRACE(BMEM_Test_CheckAlloc(heap, 0,
324	apvAlloced[uiNumAlloc], 64 * 1024, 8, 0));
325	if (err != BERR_SUCCESS)
326	{
327	/* error */
328	goto done;
329	}
330	BDBG_MSG(("---- huge alloc(64kbyte) #%d.", uiNumAlloc));
331	uiNumAlloc++;
332
333	BMEM_ConvertAddressToOffset(heap, apvAlloced[uiNumAlloc - 4], &ulConvertOffset);
334	BDBG_MSG(("==== free #%d at 0x%x.", uiNumAlloc-4, ulConvertOffset));
335	BMEM_Free(heap, apvAlloced[uiNumAlloc - 4]);
336	apvAlloced[uiNumAlloc - 4] = NULL;
337
338	BMEM_ConvertAddressToOffset(heap, apvAlloced[uiNumAlloc - 2], &ulConvertOffset);
339	BDBG_MSG(("==== free #%d at 0x%x.\n", uiNumAlloc-2, ulConvertOffset));
340	BMEM_Free(heap, apvAlloced[uiNumAlloc - 2]);
341	apvAlloced[uiNumAlloc - 2] = NULL;
342	}
343
344	/* allocate remaining slots */
345	while (uiNumAlloc < 1024 * 128)
346	{
347	/* get largest available block */
348	zSize = BMEM_GetLargestAvailableBlockSize(heap);
349
350	/* no blocks to allocate? */
351	if (zSize == 0)
352	{
353	/* no more blocks to allocate */
354	BDBG_MSG(("No more blocks to allocate"));
355	break;
356	}
357
358	/* allocate block */
359	apvAlloced[uiNumAlloc] = BMEM_Alloc(heap, zSize);
360	if (!apvAlloced[uiNumAlloc])
361	{
362	/* unable to allocate (should have) */
363	err = BERR_TRACE(BERR_UNKNOWN);
364	BDBG_ERR(("BMEM_Test_DoTest1: Failed largest block alloc"));
365	goto done;
366	}
367
368	/* check allocation */
369	err = BERR_TRACE(BMEM_Test_CheckAlloc(heap, 0,
370	apvAlloced[uiNumAlloc], zSize, 0, 0));
371	if (err != BERR_SUCCESS)
372	{
373	/* error */
374	goto done;
375	}
376	BDBG_MSG(("---- remaining block alloc (%d-byte) #%d.", zSize, uiNumAlloc));
377	uiNumAlloc++;
378	}
379
380	/* free random allocations */
381	for (i=0; i<uiNumAlloc; ++i)
382	{
383	/* free random allocation */
384	if((rand() % 2) && apvAlloced[i])
385	{
386	BMEM_ConvertAddressToOffset(heap, apvAlloced[i], &ulConvertOffset);
387	BDBG_MSG(("==== free #%d at 0x%x.", i, ulConvertOffset));
388	BMEM_Free(heap, apvAlloced[i]);
389	apvAlloced[i] = NULL;
390	}
391	}
392
393	BMEM_ValidateHeap(heap);
394	BMEM_Dbg_DumpHeap(heap);
395	BKNI_Printf("\nNumber of heap errors: %d.\n", BMEM_Dbg_GetErrorCount(heap));
396
397	BKNI_Printf("Press any key to continue; press'q' to exit.\n");
398	}while((getchar() != 'q') && (uiNumAlloc < 1024*128));
399
400	/* free all allocations */
401	for (i=0; i<uiNumAlloc; ++i)
402	{
403	/* free allocation */
404	if(apvAlloced[i])
405	{
406	BMEM_ConvertAddressToOffset(heap, apvAlloced[i], &ulConvertOffset);
407	BDBG_MSG(("==== free #%d at 0x%x.", i, ulConvertOffset));
408	BMEM_Free(heap, apvAlloced[i]);
409	}
410	}
411	/* dump heap map */
412	BMEM_ValidateHeap(heap);
413	BDBG_SetModuleLevel("BMEM", BDBG_eMsg);
414	BMEM_Dbg_DumpHeap(heap);
415	BDBG_SetModuleLevel("BMEM", BDBG_eWrn);
416	ulErrCnt = BMEM_Dbg_GetErrorCount(heap);
417	BKNI_Printf("Number of heap errors: %d.", ulErrCnt);
418	/* Destroy heap */
419	BMEM_DestroyHeap(heap);
420
421	done:
422	/* display status */
423	if ((err == BERR_SUCCESS) && (ulErrCnt == 0))
424	BKNI_Printf("Test 1: SUCCESS");
425	else
426	BKNI_Printf("Test 1: FAILED (%ul)", err);
427
428	/* return status */
429	return err;
430	}
431
432	/* End of File */

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

Context Navigation

source: svn/newcon3bcm2_21bu/magnum/basemodules/mem/test/bmem_test.c

Download in other formats: