Return to test-memory.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / tests

Annotation of embedaddon/quagga/tests/test-memory.c, revision 1.1.1.2

1.1.1.2 ! misho       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: 
1.1       misho      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: }