compat/xalloc.cc

   1 #include "config.h"
   2 #include "compat/xalloc.h"
   3 #include "profiler/Profiler.h"
   4
   5 #if XMALLOC_STATISTICS
   6 #define XMS_DBG_MAXSIZE   (1024*1024)
   7 #define XMS_DBG_SPLIT     (256)     /* mallocs below this value are tracked with DBG_GRAIN_SM precision instead of DBG_GRAIN */
   8 #define XMS_DBG_GRAIN     (16)
   9 #define XMS_DBG_GRAIN_SM  (4)
  10 #define XMS_DBG_OFFSET    (XMS_DBG_SPLIT/XMS_DBG_GRAIN_SM - XMS_DBG_SPLIT/XMS_DBG_GRAIN )
  11 #define XMS_DBG_MAXINDEX  (XMS_DBG_MAXSIZE/XMS_DBG_GRAIN + XMS_DBG_OFFSET)
  12 static int malloc_sizes[XMS_DBG_MAXINDEX + 1];
  13 static int malloc_histo[XMS_DBG_MAXINDEX + 1];
  14 static int dbg_stat_init = 0;
  15
  16 static int
  17 XMS_DBG_INDEX(int sz)
  18 {
  19     if (sz >= XMS_DBG_MAXSIZE)
  20         return XMS_DBG_MAXINDEX;
  21
  22     if (sz <= XMS_DBG_SPLIT)
  23         return (sz + XMS_DBG_GRAIN_SM - 1) / XMS_DBG_GRAIN_SM;
  24
  25     return (sz + XMS_DBG_GRAIN - 1) / XMS_DBG_GRAIN + XMS_DBG_OFFSET;
  26 }
  27
  28 static void
  29 stat_init(void)
  30 {
  31     for (int i = 0; i <= XMS_DBG_MAXINDEX; i++)
  32         malloc_sizes[i] = malloc_histo[i] = 0;
  33
  34     dbg_stat_init = 1;
  35 }
  36
  37 static int
  38 malloc_stat(int sz)
  39 {
  40     if (!dbg_stat_init)
  41         stat_init();
  42
  43     return malloc_sizes[XMS_DBG_INDEX(sz)] += 1;
  44 }
  45
  46 void
  47 malloc_statistics(void (*func) (int, int, int, void *), void *data)
  48 {
  49     int i = 0;
  50
  51     for (; i <= XMS_DBG_SPLIT; i += XMS_DBG_GRAIN_SM)
  52         func(i, malloc_sizes[XMS_DBG_INDEX(i)], malloc_histo[XMS_DBG_INDEX(i)], data);
  53
  54     i -= XMS_DBG_GRAIN_SM;
  55
  56     for (; i <= XMS_DBG_MAXSIZE; i += XMS_DBG_GRAIN)
  57         func(i, malloc_sizes[XMS_DBG_INDEX(i)], malloc_histo[XMS_DBG_INDEX(i)], data);
  58
  59     memcpy(&malloc_histo, &malloc_sizes, sizeof(malloc_sizes));
  60 }
  61 #endif /* XMALLOC_STATISTICS */
  62
  63 void *
  64 xcalloc(size_t n, size_t sz)
  65 {
  66     PROF_start(xcalloc);
  67
  68     if (n < 1)
  69         n = 1;
  70
  71     if (sz < 1)
  72         sz = 1;
  73
  74     PROF_start(calloc);
  75     void *p = calloc(n, sz);
  76     PROF_stop(calloc);
  77
  78     if (p == NULL) {
  79         if (failure_notify) {
  80             static char msg[128];
  81             snprintf(msg, 128, "xcalloc: Unable to allocate %Zu blocks of %Zu bytes!\n", n, sz);
  82             failure_notify(msg);
  83         } else {
  84             perror("xcalloc");
  85         }
  86         exit(1);
  87     }
  88
  89 #if XMALLOC_DEBUG
  90     check_malloc(p, sz * n);
  91 #endif
  92 #if XMALLOC_STATISTICS
  93     malloc_stat(sz * n);
  94 #endif
  95 #if XMALLOC_TRACE
  96     xmalloc_show_trace(p, 1);
  97 #endif
  98 #if MEM_GEN_TRACE
  99     if (tracefp)
 100         fprintf(tracefp, "c:%u:%u:%p\n", (unsigned int) n, (unsigned int) sz, p);
 101 #endif
 102
 103     PROF_stop(xcalloc);
 104     return p;
 105 }
 106
 107 void *
 108 xmalloc(size_t sz)
 109 {
 110     PROF_start(xmalloc);
 111
 112     if (sz < 1)
 113         sz = 1;
 114
 115     PROF_start(malloc);
 116     void *p = malloc(sz);
 117     PROF_stop(malloc);
 118
 119     if (p == NULL) {
 120         if (failure_notify) {
 121             static char msg[128];
 122             snprintf(msg, 128, "xmalloc: Unable to allocate %Zu bytes!\n", sz);
 123             failure_notify(msg);
 124         } else {
 125             perror("malloc");
 126         }
 127         exit(1);
 128     }
 129
 130 #if XMALLOC_DEBUG
 131     check_malloc(p, sz);
 132 #endif
 133 #if XMALLOC_STATISTICS
 134     malloc_stat(sz);
 135 #endif
 136 #if XMALLOC_TRACE
 137     xmalloc_show_trace(p, 1);
 138 #endif
 139 #if MEM_GEN_TRACE
 140     if (tracefp)
 141         fprintf(tracefp, "m:%d:%p\n", sz, p);
 142 #endif
 143
 144     PROF_stop(xmalloc);
 145     return (p);
 146 }
 147
 148 void *
 149 xrealloc(void *s, size_t sz)
 150 {
 151     PROF_start(xrealloc);
 152 #if XMALLOC_TRACE
 153     xmalloc_show_trace(s, -1);
 154 #endif
 155
 156     if (sz < 1)
 157         sz = 1;
 158
 159 #if XMALLOC_DEBUG
 160     if (s != NULL)
 161         check_free(s);
 162 #endif
 163     PROF_start(realloc);
 164     void *p= realloc(s, sz);
 165     PROF_stop(realloc);
 166
 167     if (p == NULL) {
 168         if (failure_notify) {
 169             static char msg[128];
 170             snprintf(msg, 128, "xrealloc: Unable to reallocate %Zu bytes!\n", sz);
 171             failure_notify(msg);
 172         } else {
 173             perror("realloc");
 174         }
 175
 176         exit(1);
 177     }
 178
 179 #if XMALLOC_DEBUG
 180     check_malloc(p, sz);
 181 #endif
 182 #if XMALLOC_STATISTICS
 183     malloc_stat(sz);
 184 #endif
 185 #if XMALLOC_TRACE
 186     xmalloc_show_trace(p, 1);
 187 #endif
 188 #if MEM_GEN_TRACE
 189     if (tracefp)                /* new ptr, old ptr, new size */
 190         fprintf(tracefp, "r:%p:%p:%d\n", p, s, sz);
 191 #endif
 192     PROF_stop(xrealloc);
 193     return (p);
 194 }
 195
 196 void
 197 xfree(void *s)
 198 {
 199     if (s == NULL)
 200         return;
 201
 202     free_const(s);
 203 }
 204
 205 void
 206 free_const(const void *s_const)
 207 {
 208     void *s = const_cast<void *>(s_const);
 209
 210     PROF_start(free_const);
 211 #if XMALLOC_TRACE
 212     xmalloc_show_trace(s, -1);
 213 #endif
 214
 215 #if XMALLOC_DEBUG
 216     check_free(s);
 217 #endif
 218
 219     PROF_start(free);
 220     free(s);
 221     PROF_stop(free);
 222
 223 #if MEM_GEN_TRACE
 224     if (tracefp)
 225         fprintf(tracefp, "f:%p\n", s);
 226 #endif
 227     PROF_stop(free_const);
 228 }