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.1     ! misho       1: #include <zebra.h>
        !             2: #include <memory.h>
        !             3: 
        !             4: /* Memory torture tests
        !             5:  *
        !             6:  * Tests below are generic but comments are focused on interaction with
        !             7:  * Paul's proposed memory 'quick' cache, which may never be included in
        !             8:  * CVS
        !             9:  */
        !            10: 
        !            11: struct thread_master *master;
        !            12: 
        !            13: #if 0 /* set to 1 to use system alloc directly */
        !            14: #undef XMALLOC
        !            15: #undef XCALLOC
        !            16: #undef XREALLOC
        !            17: #undef XFREE
        !            18: #define XMALLOC(T,S) malloc((S))
        !            19: #define XCALLOC(T,S) calloc(1, (S))
        !            20: #define XREALLOC(T,P,S) realloc((P),(S))
        !            21: #define XFREE(T,P) free((P))
        !            22: #endif
        !            23: 
        !            24: #define TIMES 10
        !            25: 
        !            26: int
        !            27: main(int argc, char **argv)
        !            28: {
        !            29:   void *a[10];
        !            30:   int i;
        !            31: 
        !            32:   printf ("malloc x, malloc x, free, malloc x, free free\n\n");
        !            33:   /* simple case, test cache */
        !            34:   for (i = 0; i < TIMES; i++)
        !            35:     {
        !            36:       a[0] = XMALLOC (MTYPE_VTY, 1024);
        !            37:       memset (a[0], 1, 1024);
        !            38:       a[1] = XMALLOC (MTYPE_VTY, 1024);
        !            39:       memset (a[1], 1, 1024);
        !            40:       XFREE(MTYPE_VTY, a[0]); /* should go to cache */
        !            41:       a[0] = XMALLOC (MTYPE_VTY, 1024); /* should be satisfied from cache */
        !            42:       XFREE(MTYPE_VTY, a[0]);
        !            43:       XFREE(MTYPE_VTY, a[1]);
        !            44:     }
        !            45:   
        !            46:   printf ("malloc x, malloc y, free x, malloc y, free free\n\n");
        !            47:   /* cache should go invalid, valid, invalid, etc.. */
        !            48:   for (i = 0; i < TIMES; i++)
        !            49:     {
        !            50:       a[0] = XMALLOC (MTYPE_VTY, 512);
        !            51:       memset (a[0], 1, 512);
        !            52:       a[1] = XMALLOC (MTYPE_VTY, 1024); /* invalidate cache */
        !            53:       memset (a[1], 1, 1024);
        !            54:       XFREE(MTYPE_VTY, a[0]);
        !            55:       a[0] = XMALLOC (MTYPE_VTY, 1024);
        !            56:       XFREE(MTYPE_VTY, a[0]);
        !            57:       XFREE(MTYPE_VTY, a[1]);
        !            58:       /* cache should become valid again on next request */
        !            59:     }
        !            60: 
        !            61:   printf ("calloc\n\n");
        !            62:   /* test calloc */
        !            63:   for (i = 0; i < TIMES; i++)
        !            64:     {
        !            65:       a[0] = XCALLOC (MTYPE_VTY, 1024);
        !            66:       memset (a[0], 1, 1024);
        !            67:       a[1] = XCALLOC (MTYPE_VTY, 512); /* invalidate cache */
        !            68:       memset (a[1], 1, 512);
        !            69:       XFREE(MTYPE_VTY, a[1]);
        !            70:       XFREE(MTYPE_VTY, a[0]);
        !            71:       /* alloc == 0, cache can become valid again on next request */
        !            72:     }
        !            73:   
        !            74:   printf ("calloc and realloc\n\n");
        !            75:   /* check calloc + realloc */
        !            76:   for (i = 0; i < TIMES; i++)
        !            77:     {
        !            78:       printf ("calloc a0 1024\n");
        !            79:       a[0] = XCALLOC (MTYPE_VTY, 1024);
        !            80:       memset (a[0], 1, 1024/2);
        !            81:       
        !            82:       printf ("calloc 1 1024\n");
        !            83:       a[1] = XCALLOC (MTYPE_VTY, 1024);
        !            84:       memset (a[1], 1, 1024/2);
        !            85:       
        !            86:       printf ("realloc 0 1024\n");
        !            87:       a[3] = XREALLOC (MTYPE_VTY, a[0], 2048); /* invalidate cache */
        !            88:       if (a[3] != NULL)
        !            89:         a[0] = a[3];
        !            90:       memset (a[0], 1, 1024);
        !            91:       
        !            92:       printf ("calloc 2 512\n");
        !            93:       a[2] = XCALLOC (MTYPE_VTY, 512);
        !            94:       memset (a[2], 1, 512);
        !            95:       
        !            96:       printf ("free 1 0 2\n");
        !            97:       XFREE(MTYPE_VTY, a[1]);
        !            98:       XFREE(MTYPE_VTY, a[0]);
        !            99:       XFREE(MTYPE_VTY, a[2]);
        !           100:       /* alloc == 0, cache valid next request */
        !           101:     }
        !           102:   return 0;
        !           103: }