Return to test-memory.c CVS log

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

quagga 1.0.20160315

    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: }