wrfv2_fire/external/RSL/RSL/debug.c

   1 /***********************************************************************
   2
   3                               COPYRIGHT
   4
   5      The following is a notice of limited availability of the code and
   6      Government license and disclaimer which must be included in the
   7      prologue of the code and in all source listings of the code.
   8
   9      Copyright notice
  10        (c) 1977  University of Chicago
  11
  12      Permission is hereby granted to use, reproduce, prepare
  13      derivative works, and to redistribute to others at no charge.  If
  14      you distribute a copy or copies of the Software, or you modify a
  15      copy or copies of the Software or any portion of it, thus forming
  16      a work based on the Software and make and/or distribute copies of
  17      such work, you must meet the following conditions:
  18
  19           a) If you make a copy of the Software (modified or verbatim)
  20              it must include the copyright notice and Government
  21              license and disclaimer.
  22
  23           b) You must cause the modified Software to carry prominent
  24              notices stating that you changed specified portions of
  25              the Software.
  26
  27      This software was authored by:
  28
  29      Argonne National Laboratory
  30      J. Michalakes: (630) 252-6646; email: michalak@mcs.anl.gov
  31      Mathematics and Computer Science Division
  32      Argonne National Laboratory, Argonne, IL  60439
  33
  34      ARGONNE NATIONAL LABORATORY (ANL), WITH FACILITIES IN THE STATES
  35      OF ILLINOIS AND IDAHO, IS OWNED BY THE UNITED STATES GOVERNMENT,
  36      AND OPERATED BY THE UNIVERSITY OF CHICAGO UNDER PROVISION OF A
  37      CONTRACT WITH THE DEPARTMENT OF ENERGY.
  38
  39                       GOVERNMENT LICENSE AND DISCLAIMER
  40
  41      This computer code material was prepared, in part, as an account
  42      of work sponsored by an agency of the United States Government.
  43      The Government is granted for itself and others acting on its
  44      behalf a paid-up, nonexclusive, irrevocable worldwide license in
  45      this data to reproduce, prepare derivative works, distribute
  46      copies to the public, perform publicly and display publicly, and
  47      to permit others to do so.  NEITHER THE UNITED STATES GOVERNMENT
  48      NOR ANY AGENCY THEREOF, NOR THE UNIVERSITY OF CHICAGO, NOR ANY OF
  49      THEIR EMPLOYEES, MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR
  50      ASSUMES ANY LEGAL LIABILITY OR RESPONSIBILITY FOR THE ACCURACY,
  51      COMPLETENESS, OR USEFULNESS OF ANY INFORMATION, APPARATUS,
  52      PRODUCT, OR PROCESS DISCLOSED, OR REPRESENTS THAT ITS USE WOULD
  53      NOT INFRINGE PRIVATELY OWNED RIGHTS.
  54
  55 ***************************************************************************/
  56
  57 /*
  58  * debug.c
  59  *
  60  * Various debugging things, including malloc debugging stuff
  61  */
  62
  63 dumdebug(j)
  64 {
  65   return ;
  66 }
  67
  68 /* #define NEXUS_MALLOC_DEBUG */
  69 #ifdef NEXUS_MALLOC_DEBUG
  70
  71 #include <stdio.h>
  72 #include <ctype.h>
  73 #include <errno.h>
  74 #include <sys/param.h>
  75 #include <sys/access.h>
  76
  77 /*
  78  * Memory allocation debugging and diagnostics code.
  79  */
  80
  81 #define NEXUS_MALLOC_PAD 512
  82 #define NEXUS_N_MALLOC_RECS 20000
  83
  84 typedef struct _malloc_rec_t
  85 {
  86     char *addr;
  87     char *file;
  88     char *free_file;
  89     int size;
  90 #ifdef crayx1
  91     int line;
  92     int free_line;
  93     int freed;
  94 #else
  95     short line;
  96     short free_line;
  97     short freed;
  98 #endif
  99 } *malloc_rec_t;
 100
 101 static struct _malloc_rec_t malloc_recs[NEXUS_N_MALLOC_RECS];
 102 static int next_malloc_rec = 0;
 103
 104 static char last_successful_file[1024];
 105 static int last_successful_line;
 106
 107 static int initialized = 0;
 108
 109
 110 #define START_MAGIC 0xf00dface
 111 #define END_MAGIC 0xeeaaddff
 112
 113 /*
 114  * nexus_debug_malloc()
 115  *
 116  * Malloc wrapper that can print out the size and location
 117  * of allocations when the -Dmalloc argument has been given.
 118  *
 119  * The intent is to define a macro of the form
 120  *
 121  *      #ifdef NEXUS_DEBUG
 122  *      #define malloc(size) nexus_debug_malloc(size, __FILE__, __LINE__)
 123  *      #endif
 124  *
 125  * in order to trace memory allocation in detail.
 126  *
 127  */
 128 void *nexus_debug_malloc(int size, char *file, int line)
 129 {
 130     void *rc, *addr;
 131     malloc_rec_t rec;
 132     int *p;
 133
 134         nexus_debug_malloc_check(file, line);
 135
 136         while ((size & 0x07) != 0)
 137             size++;
 138
 139         if (next_malloc_rec >= NEXUS_N_MALLOC_RECS)
 140         {
 141             fprintf(stderr,"Too many malloc recs\n");
 142             rc = malloc(size);
 143         }
 144         else
 145         {
 146             rec = &malloc_recs[next_malloc_rec];
 147
 148             addr = malloc(size + 2 * NEXUS_MALLOC_PAD);
 149             rc = (char *) addr + NEXUS_MALLOC_PAD;
 150             bzero( rc, size ) ;         /* zero storage */
 151             if (0 )
 152             {
 153                 printf("malloc(%d) at %s:%d returns %x idx=%d\n",
 154                             size, file, line, rc, next_malloc_rec);
 155             }
 156
 157             rec->addr = addr;
 158             rec->file = file;
 159             rec->line = line;
 160             rec->size = size;
 161             rec->free_file = (char *) NULL;
 162             rec->free_line = -1;
 163             rec->freed = 0;
 164
 165             if (NEXUS_MALLOC_PAD >= 4)
 166             {
 167                 *((int *) addr) = next_malloc_rec;
 168
 169                 for (p = (int *) addr + 1; p < (int *) rc; p++)
 170                 {
 171                     *p = START_MAGIC;
 172                 }
 173                 for (p = (int *) ((char *) addr + size + NEXUS_MALLOC_PAD);
 174                      p < (int *) ((char *) addr + size + 2 * NEXUS_MALLOC_PAD); p++)
 175                 {
 176                     *p = END_MAGIC;
 177                 }
 178             }
 179
 180             next_malloc_rec++;
 181         }
 182
 183     return rc;
 184 } /* nexus_debug_malloc() */
 185
 186
 187 /*
 188  * nexus_debug_malloc_check()
 189  *
 190  * Walk the list of allocated blocks looking for munged memory.
 191  */
 192 nexus_debug_malloc_check(char *file, int line)
 193 {
 194     int i;
 195     malloc_rec_t rec;
 196     int *p;
 197
 198     if (NEXUS_MALLOC_PAD < 4)
 199         return;
 200
 201     for (i = 0; i < next_malloc_rec; i++)
 202     {
 203         rec = &malloc_recs[i];
 204
 205         if (rec->freed)
 206             continue;
 207
 208         if (*((int *) rec->addr) != i)
 209         {
 210             fprintf(stderr,"Malloc check (start) failed for idx %d at %s:%d for allocation at %s:%d of size %d. Last successful check was %s:%d\n",
 211                         i,
 212                         file, line,
 213                         rec->file, rec->line,
 214                         rec->size,
 215                         last_successful_file,
 216                         last_successful_line);
 217             exit(2) ;
 218         }
 219
 220         for (p = (int *) rec->addr + 1; p < (int *) ((char *) rec->addr + NEXUS_MALLOC_PAD); p++)
 221         {
 222             if (*p != START_MAGIC)
 223             {
 224             fprintf(stderr,"Malloc check (start) failed for idx %d at %s:%d for allocation at %s:%d of size %d Last successful check was %s:%d\n",
 225                             i,
 226                             file, line,
 227                             rec->file, rec->line,
 228                             rec->size,
 229                             last_successful_file,
 230                             last_successful_line);
 231             exit(2) ;
 232             }
 233         }
 234
 235         for (p = (int *) ((char *) rec->addr + rec->size + NEXUS_MALLOC_PAD);
 236              p < (int *) ((char *) rec->addr + rec->size + 2 * NEXUS_MALLOC_PAD); p++)
 237         {
 238             if (*p != END_MAGIC)
 239             {
 240             fprintf(stderr,"Malloc check (end) failed for idx %d at %s:%d for allocation at %s:%d of size %d Last successful check was %s:%d\n",
 241                             i,
 242                             file, line,
 243                             rec->file, rec->line,
 244                             rec->size,
 245                             last_successful_file,
 246                             last_successful_line);
 247             exit(2) ;
 248             }
 249         }
 250     }
 251     strcpy(last_successful_file, file);
 252     last_successful_line = line;
 253 } /* nexus_debug_malloc_check() */
 254
 255 void nexus_debug_mem_check(int size, void *address)
 256 {
 257     int i;
 258     malloc_rec_t rec;
 259     char *pad1_start, *pad1_end, *pad2_start, *pad2_end, *a_start, *a_end;
 260
 261     for (i = 0; i < next_malloc_rec; i++)
 262     {
 263         rec = &malloc_recs[i];
 264
 265         if (rec->freed)
 266             continue;
 267
 268         pad1_start = rec->addr;
 269         pad1_end = pad1_start + NEXUS_MALLOC_PAD;
 270
 271         pad2_start = rec->addr + rec->size + NEXUS_MALLOC_PAD;
 272         pad2_end = pad2_start + NEXUS_MALLOC_PAD;
 273
 274         a_start = address;
 275         a_end = a_start + size - 1;
 276
 277         if ((a_start >= pad1_start && a_start < pad1_end) ||
 278             (a_end >= pad1_start && a_end < pad1_end) ||
 279             (a_start >= pad2_start && a_start < pad2_end) ||
 280             (a_end >= pad2_start && a_end < pad2_end) ||
 281             (a_start < pad1_start && a_end > pad1_end) ||
 282             (a_start < pad2_start && a_end > pad2_end))
 283         {
 284             fprintf(stderr,"Malloc memory check for address %x length %s failed for idx %d for allocation at %s:%d of size %d.\n",
 285                         address,
 286                         size,
 287                         i,
 288                         rec->file, rec->line,
 289                         rec->size);
 290             exit(2) ;
 291         }
 292     }
 293 } /* nexus_debug_mem_check() */
 294
 295
 296 /*
 297  * nexus_debug_show_freed_blocks()
 298  *
 299  * Walk the list of allocated blocks looking blocks that
 300  * were never freed.
 301  */
 302 void nexus_debug_show_freed_blocks()
 303 {
 304     int i;
 305     malloc_rec_t rec;
 306
 307     for (i = 0; i < next_malloc_rec; i++)
 308     {
 309         rec = &malloc_recs[i];
 310
 311         if (!rec->freed)
 312         {
 313             fprintf(stderr,"Unfreed block %d size=%5d at %s:%d\n",
 314                         i, rec->size, rec->file, rec->line);
 315         }
 316     }
 317 } /* nexus_debug_show_freed_blocks() */
 318
 319
 320 /*
 321  * nexus_debug_show_malloc_stats()
 322  *
 323  * Print a summary of memory allocation statistics.
 324  */
 325 void nexus_debug_show_malloc_stats()
 326 {
 327     int i;
 328     malloc_rec_t rec;
 329     int bytes, bytes_freed;
 330     int n_blocks_freed;
 331
 332     bytes = bytes_freed = n_blocks_freed = 0;
 333
 334     for (i = 0; i < next_malloc_rec; i++)
 335     {
 336         rec = &malloc_recs[i];
 337
 338         bytes += rec->size;
 339
 340         if (rec->freed)
 341         {
 342             bytes_freed += rec->size;
 343             n_blocks_freed++;
 344         }
 345     }
 346
 347     fprintf(stderr,"Malloc statistics:\n");
 348     fprintf(stderr,"\tbytes allocated:  %d\n", bytes);
 349     fprintf(stderr,"\tbytes freed:      %d\n", bytes_freed);
 350     fprintf(stderr,"\tbytes unfreed:    %d\n", bytes - bytes_freed);
 351     fprintf(stderr,"\tblocks allocated: %d\n", next_malloc_rec);
 352     fprintf(stderr,"\tblocks freed:     %d\n", n_blocks_freed);
 353     fprintf(stderr,"\tblocks unfreed:   %d\n", next_malloc_rec - n_blocks_freed);
 354 } /* nexus_debug_show_malloc_stats() */
 355
 356
 357 /*
 358  * nexus_debug_free()
 359  */
 360 void nexus_debug_free(void *ptr, char *file, int line)
 361 {
 362     void *addr;
 363     int idx;
 364
 365         malloc_rec_t rec;
 366
 367         if (NEXUS_MALLOC_PAD >= 4)
 368         {
 369             addr = (char *) ptr - NEXUS_MALLOC_PAD;
 370
 371             idx = *((int *) addr);
 372
 373             if ( idx < 0 || idx >= NEXUS_N_MALLOC_RECS )
 374             {
 375 fprintf(stderr,"nexus_debug_free(): bad idx = %d; \n  possibly corrupt ptr %08x at %s line %d\n",
 376 idx, ptr, file, line ) ;
 377             }
 378
 379             rec = &(malloc_recs[idx]);
 380
 381             if (rec->freed == 1 )
 382             {
 383                 fprintf(stderr,"nexus_debug_free(): block %x idx %d allocated at %s:%d was freed twice at %s:%d and %s:%d\n",
 384                             ptr, idx,
 385                             rec->file, rec->line,
 386                             rec->free_file, rec->free_line,
 387                             file, line);
 388                 exit(2) ;
 389             }
 390
 391             rec->freed = 1;
 392             rec->free_file = file;
 393             rec->free_line = line;
 394             free(addr);
 395         }
 396         else
 397         {
 398             idx = -1;
 399             free(ptr);
 400         }
 401         if (0)
 402         {
 403             nexus_printf("free(%x) at %s:%d index=%d\n",
 404                         ptr, file, line, idx);
 405         }
 406 } /* nexus_debug_free() */
 407
 408
 409
 410 #endif /* NEXUS_DEBUG */
 411