]> git.sommitrealweird.co.uk Git - quagga-debian.git/blob - tests/test-memory.c
New upstream version 1.2.4
[quagga-debian.git] / tests / test-memory.c
1 /* 
2  * This file is part of Quagga.
3  *
4  * Quagga is free software; you can redistribute it and/or modify it
5  * under the terms of the GNU General Public License as published by the
6  * Free Software Foundation; either version 2, or (at your option) any
7  * later version.
8  *
9  * Quagga is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with Quagga; see the file COPYING.  If not, write to the Free
16  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
17  * 02111-1307, USA.  
18  */
19
20 #include <zebra.h>
21 #include <memory.h>
22
23 /* Memory torture tests
24  *
25  * Tests below are generic but comments are focused on interaction with
26  * Paul's proposed memory 'quick' cache, which may never be included in
27  * CVS
28  */
29
30 struct thread_master *master;
31
32 #if 0 /* set to 1 to use system alloc directly */
33 #undef XMALLOC
34 #undef XCALLOC
35 #undef XREALLOC
36 #undef XFREE
37 #define XMALLOC(T,S) malloc((S))
38 #define XCALLOC(T,S) calloc(1, (S))
39 #define XREALLOC(T,P,S) realloc((P),(S))
40 #define XFREE(T,P) free((P))
41 #endif
42
43 #define TIMES 10
44
45 int
46 main(int argc, char **argv)
47 {
48   void *a[10];
49   int i;
50
51   printf ("malloc x, malloc x, free, malloc x, free free\n\n");
52   /* simple case, test cache */
53   for (i = 0; i < TIMES; i++)
54     {
55       a[0] = XMALLOC (MTYPE_VTY, 1024);
56       memset (a[0], 1, 1024);
57       a[1] = XMALLOC (MTYPE_VTY, 1024);
58       memset (a[1], 1, 1024);
59       XFREE(MTYPE_VTY, a[0]); /* should go to cache */
60       a[0] = XMALLOC (MTYPE_VTY, 1024); /* should be satisfied from cache */
61       XFREE(MTYPE_VTY, a[0]);
62       XFREE(MTYPE_VTY, a[1]);
63     }
64   
65   printf ("malloc x, malloc y, free x, malloc y, free free\n\n");
66   /* cache should go invalid, valid, invalid, etc.. */
67   for (i = 0; i < TIMES; i++)
68     {
69       a[0] = XMALLOC (MTYPE_VTY, 512);
70       memset (a[0], 1, 512);
71       a[1] = XMALLOC (MTYPE_VTY, 1024); /* invalidate cache */
72       memset (a[1], 1, 1024);
73       XFREE(MTYPE_VTY, a[0]);
74       a[0] = XMALLOC (MTYPE_VTY, 1024);
75       XFREE(MTYPE_VTY, a[0]);
76       XFREE(MTYPE_VTY, a[1]);
77       /* cache should become valid again on next request */
78     }
79
80   printf ("calloc\n\n");
81   /* test calloc */
82   for (i = 0; i < TIMES; i++)
83     {
84       a[0] = XCALLOC (MTYPE_VTY, 1024);
85       memset (a[0], 1, 1024);
86       a[1] = XCALLOC (MTYPE_VTY, 512); /* invalidate cache */
87       memset (a[1], 1, 512);
88       XFREE(MTYPE_VTY, a[1]);
89       XFREE(MTYPE_VTY, a[0]);
90       /* alloc == 0, cache can become valid again on next request */
91     }
92   
93   printf ("calloc and realloc\n\n");
94   /* check calloc + realloc */
95   for (i = 0; i < TIMES; i++)
96     {
97       printf ("calloc a0 1024\n");
98       a[0] = XCALLOC (MTYPE_VTY, 1024);
99       memset (a[0], 1, 1024/2);
100       
101       printf ("calloc 1 1024\n");
102       a[1] = XCALLOC (MTYPE_VTY, 1024);
103       memset (a[1], 1, 1024/2);
104       
105       printf ("realloc 0 1024\n");
106       a[3] = XREALLOC (MTYPE_VTY, a[0], 2048); /* invalidate cache */
107       if (a[3] != NULL)
108         a[0] = a[3];
109       memset (a[0], 1, 1024);
110       
111       printf ("calloc 2 512\n");
112       a[2] = XCALLOC (MTYPE_VTY, 512);
113       memset (a[2], 1, 512);
114       
115       printf ("free 1 0 2\n");
116       XFREE(MTYPE_VTY, a[1]);
117       XFREE(MTYPE_VTY, a[0]);
118       XFREE(MTYPE_VTY, a[2]);
119       /* alloc == 0, cache valid next request */
120     }
121   return 0;
122 }