stat.c

   1 /*
   2  * Copyright (C) 2012, 2013, 2014
   3  *     Dale Weiler
   4  *     Wolfgang Bumiller
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy of
   7  * this software and associated documentation files (the "Software"), to deal in
   8  * the Software without restriction, including without limitation the rights to
   9  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
  10  * of the Software, and to permit persons to whom the Software is furnished to do
  11  * so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in all
  14  * copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  */
  24
  25 #include <string.h>
  26 #include <stdlib.h>
  27
  28 #include "gmqcc.h"
  29
  30 /*
  31  * For the valgrind integration of our allocator. This allows us to have
  32  * more `accurate` valgrind output for our allocator, and also secures the
  33  * possible underflows (where one could obtain access to the redzone that
  34  * represents info about that allocation).
  35  */
  36 #ifndef NVALGRIND
  37 #   include <valgrind/valgrind.h>
  38 #   include <valgrind/memcheck.h>
  39 #else
  40 #   define VALGRIND_MALLOCLIKE_BLOCK(PTR, ALLOC_SIZE, REDZONE_SIZE, ZEROED)
  41 #   define VALGRIND_FREELIKE_BLOCK(PTR, REDZONE_SIZE)
  42 #   define VALGRIND_MAKE_MEM_DEFINED(PTR, REDZONE_SIZE)
  43 #   define VALGRIND_MAKE_MEM_NOACCESS(PTR, REDZONE_SIZE)
  44 #endif
  45
  46 /*
  47  * GMQCC performs tons of allocations, constructions, and crazyness
  48  * all around. When trying to optimizes systems, or just get fancy
  49  * statistics out of the compiler, it's often printf mess. This file
  50  * implements the statistics system of the compiler. I.E the allocator
  51  * we use to track allocations, and other systems of interest.
  52  */
  53 #define ST_SIZE 1024
  54
  55 typedef struct stat_mem_block_s {
  56     const char              *file;
  57     size_t                   line;
  58     size_t                   size;
  59     const char              *expr;
  60     struct stat_mem_block_s *next;
  61     struct stat_mem_block_s *prev;
  62 } stat_mem_block_t;
  63
  64 typedef struct {
  65     size_t key;
  66     size_t value;
  67 } stat_size_entry_t, **stat_size_table_t;
  68
  69 static uint64_t          stat_mem_allocated         = 0;
  70 static uint64_t          stat_mem_deallocated       = 0;
  71 static uint64_t          stat_mem_allocated_total   = 0;
  72 static uint64_t          stat_mem_deallocated_total = 0;
  73 static uint64_t          stat_mem_high              = 0;
  74 static uint64_t          stat_mem_peak              = 0;
  75 static uint64_t          stat_mem_strdups           = 0;
  76 static uint64_t          stat_used_strdups          = 0;
  77 static uint64_t          stat_used_vectors          = 0;
  78 static uint64_t          stat_used_hashtables       = 0;
  79 static uint64_t          stat_type_vectors          = 0;
  80 static uint64_t          stat_type_hashtables       = 0;
  81 static stat_size_table_t stat_size_vectors          = NULL;
  82 static stat_size_table_t stat_size_hashtables       = NULL;
  83 static stat_mem_block_t *stat_mem_block_root        = NULL;
  84
  85 /*
  86  * A tiny size_t key-value hashtbale for tracking vector and hashtable
  87  * sizes. We can use it for other things too, if we need to. This is
  88  * very TIGHT, and efficent in terms of space though.
  89  */
  90 static stat_size_table_t stat_size_new(void) {
  91     return (stat_size_table_t)memset(
  92         mem_a(sizeof(stat_size_entry_t*) * ST_SIZE),
  93         0, ST_SIZE * sizeof(stat_size_entry_t*)
  94     );
  95 }
  96
  97 static void stat_size_del(stat_size_table_t table) {
  98     size_t i = 0;
  99     for (; i < ST_SIZE; i++) if(table[i]) mem_d(table[i]);
 100     mem_d(table);
 101 }
 102
 103 static stat_size_entry_t *stat_size_get(stat_size_table_t table, size_t key) {
 104     size_t hash = (key % ST_SIZE);
 105     while (table[hash] && table[hash]->key != key)
 106         hash = (hash + 1) % ST_SIZE;
 107     return table[hash];
 108 }
 109 static void stat_size_put(stat_size_table_t table, size_t key, size_t value) {
 110     size_t hash = (key % ST_SIZE);
 111     while (table[hash] && table[hash]->key != key)
 112         hash = (hash + 1) % ST_SIZE;
 113     table[hash]        = (stat_size_entry_t*)mem_a(sizeof(stat_size_entry_t));
 114     table[hash]->key   = key;
 115     table[hash]->value = value;
 116 }
 117
 118 /*
 119  * A basic header of information wrapper allocator. Simply stores
 120  * information as a header, returns the memory + 1 past it, can be
 121  * retrieved again with - 1. Where type is stat_mem_block_t*.
 122  */
 123 void *stat_mem_allocate(size_t size, size_t line, const char *file, const char *expr) {
 124     stat_mem_block_t *info = (stat_mem_block_t*)malloc(sizeof(stat_mem_block_t) + size);
 125     void             *data = (void*)(info + 1);
 126
 127     if(GMQCC_UNLIKELY(!info))
 128         return NULL;
 129
 130     info->line = line;
 131     info->size = size;
 132     info->file = file;
 133     info->expr = expr;
 134     info->prev = NULL;
 135     info->next = stat_mem_block_root;
 136
 137     /* likely since it only happens once */
 138     if (GMQCC_LIKELY(stat_mem_block_root != NULL)) {
 139         VALGRIND_MAKE_MEM_DEFINED(stat_mem_block_root, sizeof(stat_mem_block_t));
 140         stat_mem_block_root->prev = info;
 141         VALGRIND_MAKE_MEM_NOACCESS(stat_mem_block_root, sizeof(stat_mem_block_t));
 142     }
 143
 144     stat_mem_block_root       = info;
 145     stat_mem_allocated       += size;
 146     stat_mem_high            += size;
 147     stat_mem_allocated_total ++;
 148
 149     if (stat_mem_high > stat_mem_peak)
 150         stat_mem_peak = stat_mem_high;
 151
 152     VALGRIND_MALLOCLIKE_BLOCK(data, size, sizeof(stat_mem_block_t), 0);
 153     return data;
 154 }
 155
 156 void stat_mem_deallocate(void *ptr) {
 157     stat_mem_block_t *info = NULL;
 158
 159     if (GMQCC_UNLIKELY(!ptr))
 160         return;
 161
 162     info = ((stat_mem_block_t*)ptr - 1);
 163
 164     /*
 165      * we need access to the redzone that represents the info block
 166      * so lets do that.
 167      */
 168     VALGRIND_MAKE_MEM_DEFINED(info, sizeof(stat_mem_block_t));
 169
 170     stat_mem_deallocated       += info->size;
 171     stat_mem_high              -= info->size;
 172     stat_mem_deallocated_total ++;
 173
 174     if (info->prev) {
 175         /* just need access for a short period */
 176         VALGRIND_MAKE_MEM_DEFINED(info->prev, sizeof(stat_mem_block_t));
 177         info->prev->next = info->next;
 178         /* don't need access anymore */
 179         VALGRIND_MAKE_MEM_NOACCESS(info->prev, sizeof(stat_mem_block_t));
 180     }
 181     if (info->next) {
 182         /* just need access for a short period */
 183         VALGRIND_MAKE_MEM_DEFINED(info->next, sizeof(stat_mem_block_t));
 184         info->next->prev = info->prev;
 185         /* don't need access anymore */
 186         VALGRIND_MAKE_MEM_NOACCESS(info->next, sizeof(stat_mem_block_t));
 187     }
 188
 189     /* move ahead */
 190     if (info == stat_mem_block_root)
 191         stat_mem_block_root = info->next;
 192
 193     free(info);
 194     VALGRIND_MAKE_MEM_NOACCESS(info, sizeof(stat_mem_block_t));
 195     VALGRIND_FREELIKE_BLOCK(ptr, sizeof(stat_mem_block_t));
 196 }
 197
 198 void *stat_mem_reallocate(void *ptr, size_t size, size_t line, const char *file, const char *expr) {
 199     stat_mem_block_t *oldinfo = NULL;
 200     stat_mem_block_t *newinfo;
 201
 202     if (GMQCC_UNLIKELY(!ptr))
 203         return stat_mem_allocate(size, line, file, expr);
 204
 205     /* stay consistent with glibc */
 206     if (GMQCC_UNLIKELY(!size)) {
 207         stat_mem_deallocate(ptr);
 208         return NULL;
 209     }
 210
 211     oldinfo = ((stat_mem_block_t*)ptr - 1);
 212     newinfo = ((stat_mem_block_t*)malloc(sizeof(stat_mem_block_t) + size));
 213
 214     if (GMQCC_UNLIKELY(!newinfo)) {
 215         stat_mem_deallocate(ptr);
 216         return NULL;
 217     }
 218
 219     VALGRIND_MALLOCLIKE_BLOCK(newinfo + 1, size, sizeof(stat_mem_block_t), 0);
 220
 221     /* we need access to the old info redzone */
 222     VALGRIND_MAKE_MEM_DEFINED(oldinfo, sizeof(stat_mem_block_t));
 223
 224     memcpy(newinfo+1, oldinfo+1, oldinfo->size);
 225
 226     if (oldinfo->prev) {
 227         /* just need access for a short period */
 228         VALGRIND_MAKE_MEM_DEFINED(oldinfo->prev, sizeof(stat_mem_block_t));
 229         oldinfo->prev->next = oldinfo->next;
 230         /* don't need access anymore */
 231         VALGRIND_MAKE_MEM_NOACCESS(oldinfo->prev, sizeof(stat_mem_block_t));
 232     }
 233
 234     if (oldinfo->next) {
 235         /* just need access for a short period */
 236         VALGRIND_MAKE_MEM_DEFINED(oldinfo->next, sizeof(stat_mem_block_t));
 237         oldinfo->next->prev = oldinfo->prev;
 238         /* don't need access anymore */
 239         VALGRIND_MAKE_MEM_NOACCESS(oldinfo->next, sizeof(stat_mem_block_t));
 240     }
 241
 242     /* move ahead */
 243     if (oldinfo == stat_mem_block_root)
 244         stat_mem_block_root = oldinfo->next;
 245
 246     /* we need access to the redzone for the newinfo block */
 247     VALGRIND_MAKE_MEM_DEFINED(newinfo, sizeof(stat_mem_block_t));
 248
 249     newinfo->line = line;
 250     newinfo->size = size;
 251     newinfo->file = file;
 252     newinfo->expr = expr;
 253     newinfo->prev = NULL;
 254     newinfo->next = stat_mem_block_root;
 255
 256     /*
 257      * likely since the only time there is no root is when it's
 258      * being initialized first.
 259      */
 260     if (GMQCC_LIKELY(stat_mem_block_root != NULL)) {
 261         /* we need access to the root */
 262         VALGRIND_MAKE_MEM_DEFINED(stat_mem_block_root, sizeof(stat_mem_block_t));
 263         stat_mem_block_root->prev = newinfo;
 264         /* kill access */
 265         VALGRIND_MAKE_MEM_NOACCESS(stat_mem_block_root, sizeof(stat_mem_block_t));
 266     }
 267
 268     stat_mem_block_root = newinfo;
 269     stat_mem_allocated -= oldinfo->size;
 270     stat_mem_high      -= oldinfo->size;
 271     stat_mem_allocated += newinfo->size;
 272     stat_mem_high      += newinfo->size;
 273
 274     /*
 275      * we're finished with the redzones, lets kill the access
 276      * to them.
 277      */
 278     VALGRIND_MAKE_MEM_NOACCESS(newinfo, sizeof(stat_mem_block_t));
 279     VALGRIND_MAKE_MEM_NOACCESS(oldinfo, sizeof(stat_mem_block_t));
 280
 281     if (stat_mem_high > stat_mem_peak)
 282         stat_mem_peak = stat_mem_high;
 283
 284     free(oldinfo);
 285     VALGRIND_FREELIKE_BLOCK(ptr, sizeof(stat_mem_block_t));
 286     return newinfo + 1;
 287 }
 288
 289 /*
 290  * strdup does it's own malloc, we need to track malloc. We don't want
 291  * to overwrite malloc though, infact, we can't really hook it at all
 292  * without library specific assumptions. So we re implement strdup.
 293  */
 294 char *stat_mem_strdup(const char *src, size_t line, const char *file, bool empty) {
 295     size_t len = 0;
 296     char  *ptr = NULL;
 297
 298     if (!src)
 299         return NULL;
 300
 301     len = strlen(src);
 302     if (((!empty) ? len : true) && (ptr = (char*)stat_mem_allocate(len + 1, line, file, "strdup"))) {
 303         memcpy(ptr, src, len);
 304         ptr[len] = '\0';
 305     }
 306
 307     stat_used_strdups ++;
 308     stat_mem_strdups  += len;
 309     return ptr;
 310 }
 311
 312 /*
 313  * The reallocate function for resizing vectors.
 314  */
 315 void _util_vec_grow(void **a, size_t i, size_t s) {
 316     vector_t          *d = vec_meta(*a);
 317     size_t             m = 0;
 318     stat_size_entry_t *e = NULL;
 319     void              *p = NULL;
 320
 321     if (*a) {
 322         m = 2 * d->allocated + i;
 323         p = mem_r(d, s * m + sizeof(vector_t));
 324     } else {
 325         m = i + 1;
 326         p = mem_a(s * m + sizeof(vector_t));
 327         ((vector_t*)p)->used = 0;
 328         stat_used_vectors++;
 329     }
 330
 331     if (!stat_size_vectors)
 332         stat_size_vectors = stat_size_new();
 333
 334     if ((e = stat_size_get(stat_size_vectors, s))) {
 335         e->value ++;
 336     } else {
 337         stat_size_put(stat_size_vectors, s, 1); /* start off with 1 */
 338         stat_type_vectors++;
 339     }
 340
 341     *a = (vector_t*)p + 1;
 342     vec_meta(*a)->allocated = m;
 343 }
 344
 345 /*
 346  * Hash table for generic data, based on dynamic memory allocations
 347  * all around.  This is the internal interface, please look for
 348  * EXPOSED INTERFACE comment below
 349  */
 350 typedef struct hash_node_t {
 351     char               *key;   /* the key for this node in table */
 352     void               *value; /* pointer to the data as void*   */
 353     struct hash_node_t *next;  /* next node (linked list)        */
 354 } hash_node_t;
 355
 356
 357 size_t hash(const char *key);
 358 size_t util_hthash(hash_table_t *ht, const char *key) {
 359     return hash(key) % ht->size;
 360 }
 361
 362 static hash_node_t *_util_htnewpair(const char *key, void *value) {
 363     hash_node_t *node;
 364     if (!(node = (hash_node_t*)mem_a(sizeof(hash_node_t))))
 365         return NULL;
 366
 367     if (!(node->key = util_strdupe(key))) {
 368         mem_d(node);
 369         return NULL;
 370     }
 371
 372     node->value = value;
 373     node->next  = NULL;
 374
 375     return node;
 376 }
 377
 378 /*
 379  * EXPOSED INTERFACE for the hashtable implementation
 380  * util_htnew(size)                             -- to make a new hashtable
 381  * util_htset(table, key, value, sizeof(value)) -- to set something in the table
 382  * util_htget(table, key)                       -- to get something from the table
 383  * util_htdel(table)                            -- to delete the table
 384  */
 385 hash_table_t *util_htnew(size_t size) {
 386     hash_table_t      *hashtable = NULL;
 387     stat_size_entry_t *find      = NULL;
 388
 389     if (size < 1)
 390         return NULL;
 391
 392     if (!stat_size_hashtables)
 393         stat_size_hashtables = stat_size_new();
 394
 395     if (!(hashtable = (hash_table_t*)mem_a(sizeof(hash_table_t))))
 396         return NULL;
 397
 398     if (!(hashtable->table = (hash_node_t**)mem_a(sizeof(hash_node_t*) * size))) {
 399         mem_d(hashtable);
 400         return NULL;
 401     }
 402
 403     if ((find = stat_size_get(stat_size_hashtables, size)))
 404         find->value++;
 405     else {
 406         stat_type_hashtables++;
 407         stat_size_put(stat_size_hashtables, size, 1);
 408     }
 409
 410     hashtable->size = size;
 411     memset(hashtable->table, 0, sizeof(hash_node_t*) * size);
 412
 413     stat_used_hashtables++;
 414     return hashtable;
 415 }
 416
 417 void util_htseth(hash_table_t *ht, const char *key, size_t bin, void *value) {
 418     hash_node_t *newnode = NULL;
 419     hash_node_t *next    = NULL;
 420     hash_node_t *last    = NULL;
 421
 422     next = ht->table[bin];
 423
 424     while (next && next->key && strcmp(key, next->key) > 0)
 425         last = next, next = next->next;
 426
 427     /* already in table, do a replace */
 428     if (next && next->key && strcmp(key, next->key) == 0) {
 429         next->value = value;
 430     } else {
 431         /* not found, grow a pair man :P */
 432         newnode = _util_htnewpair(key, value);
 433         if (next == ht->table[bin]) {
 434             newnode->next  = next;
 435             ht->table[bin] = newnode;
 436         } else if (!next) {
 437             last->next = newnode;
 438         } else {
 439             newnode->next = next;
 440             last->next = newnode;
 441         }
 442     }
 443 }
 444
 445 void util_htset(hash_table_t *ht, const char *key, void *value) {
 446     util_htseth(ht, key, util_hthash(ht, key), value);
 447 }
 448
 449 void *util_htgeth(hash_table_t *ht, const char *key, size_t bin) {
 450     hash_node_t *pair = ht->table[bin];
 451
 452     while (pair && pair->key && strcmp(key, pair->key) > 0)
 453         pair = pair->next;
 454
 455     if (!pair || !pair->key || strcmp(key, pair->key) != 0)
 456         return NULL;
 457
 458     return pair->value;
 459 }
 460
 461 void *util_htget(hash_table_t *ht, const char *key) {
 462     return util_htgeth(ht, key, util_hthash(ht, key));
 463 }
 464
 465 void *code_util_str_htgeth(hash_table_t *ht, const char *key, size_t bin);
 466 void *code_util_str_htgeth(hash_table_t *ht, const char *key, size_t bin) {
 467     hash_node_t *pair;
 468     size_t len, keylen;
 469     int cmp;
 470
 471     keylen = strlen(key);
 472
 473     pair = ht->table[bin];
 474     while (pair && pair->key) {
 475         len = strlen(pair->key);
 476         if (len < keylen) {
 477             pair = pair->next;
 478             continue;
 479         }
 480         if (keylen == len) {
 481             cmp = strcmp(key, pair->key);
 482             if (cmp == 0)
 483                 return pair->value;
 484             if (cmp < 0)
 485                 return NULL;
 486             pair = pair->next;
 487             continue;
 488         }
 489         cmp = strcmp(key, pair->key + len - keylen);
 490         if (cmp == 0) {
 491             uintptr_t up = (uintptr_t)pair->value;
 492             up += len - keylen;
 493             return (void*)up;
 494         }
 495         pair = pair->next;
 496     }
 497     return NULL;
 498 }
 499
 500 /*
 501  * Free all allocated data in a hashtable, this is quite the amount
 502  * of work.
 503  */
 504 void util_htrem(hash_table_t *ht, void (*callback)(void *data)) {
 505     size_t i = 0;
 506
 507     for (; i < ht->size; ++i) {
 508         hash_node_t *n = ht->table[i];
 509         hash_node_t *p;
 510
 511         /* free in list */
 512         while (n) {
 513             if (n->key)
 514                 mem_d(n->key);
 515             if (callback)
 516                 callback(n->value);
 517             p = n;
 518             n = p->next;
 519             mem_d(p);
 520         }
 521
 522     }
 523     /* free table */
 524     mem_d(ht->table);
 525     mem_d(ht);
 526 }
 527
 528 void util_htrmh(hash_table_t *ht, const char *key, size_t bin, void (*cb)(void*)) {
 529     hash_node_t **pair = &ht->table[bin];
 530     hash_node_t *tmp;
 531
 532     while (*pair && (*pair)->key && strcmp(key, (*pair)->key) > 0)
 533         pair = &(*pair)->next;
 534
 535     tmp = *pair;
 536     if (!tmp || !tmp->key || strcmp(key, tmp->key) != 0)
 537         return;
 538
 539     if (cb)
 540         (*cb)(tmp->value);
 541
 542     *pair = tmp->next;
 543     mem_d(tmp->key);
 544     mem_d(tmp);
 545 }
 546
 547 void util_htrm(hash_table_t *ht, const char *key, void (*cb)(void*)) {
 548     util_htrmh(ht, key, util_hthash(ht, key), cb);
 549 }
 550
 551 void util_htdel(hash_table_t *ht) {
 552     util_htrem(ht, NULL);
 553 }
 554
 555 /*
 556  * The following functions below implement printing / dumping of statistical
 557  * information.
 558  */
 559 static void stat_dump_mem_contents(stat_mem_block_t *block, uint16_t cols) {
 560     unsigned char *buffer = (unsigned char *)mem_a(cols);
 561     unsigned char *memory = (unsigned char *)(block + 1);
 562     size_t         i;
 563
 564     for (i = 0; i < block->size; i++) {
 565         if (!(i % 16)) {
 566             if (i != 0)
 567                 con_out(" %s\n", buffer);
 568             con_out(" 0x%08X: ", i);
 569         }
 570
 571         con_out(" %02X", memory[i]);
 572
 573         buffer[i % cols] = ((memory[i] < 0x20) || (memory[i] > 0x7E))
 574                             ? '.'
 575                             : memory[i];
 576
 577         buffer[(i % cols) + 1] = '\0';
 578     }
 579
 580     while ((i % cols) != 0) {
 581         con_out("   ");
 582         i++;
 583     }
 584
 585     con_out(" %s\n", buffer);
 586     mem_d(buffer);
 587 }
 588
 589 static void stat_dump_mem_leaks(void) {
 590     stat_mem_block_t *info;
 591     /* we need access to the root for this */
 592     VALGRIND_MAKE_MEM_DEFINED(stat_mem_block_root, sizeof(stat_mem_block_t));
 593     for (info = stat_mem_block_root; info; info = info->next) {
 594         /* we need access to the block */
 595         VALGRIND_MAKE_MEM_DEFINED(info, sizeof(stat_mem_block_t));
 596         con_out("lost: %u (bytes) at %s:%u from expression `%s`\n",
 597             info->size,
 598             info->file,
 599             info->line,
 600             info->expr
 601         );
 602
 603         stat_dump_mem_contents(info, OPTS_OPTION_U16(OPTION_MEMDUMPCOLS));
 604
 605         /*
 606          * we're finished with the access, the redzone should be marked
 607          * inaccesible so that invalid read/writes that could 'step-into'
 608          * those redzones will show up as invalid read/writes in valgrind.
 609          */
 610         VALGRIND_MAKE_MEM_NOACCESS(info, sizeof(stat_mem_block_t));
 611     }
 612     VALGRIND_MAKE_MEM_NOACCESS(stat_mem_block_root, sizeof(stat_mem_block_t));
 613 }
 614
 615 static void stat_dump_mem_info(void) {
 616     con_out("Memory Information:\n\
 617     Total allocations:   %llu\n\
 618     Total deallocations: %llu\n\
 619     Total allocated:     %f (MB)\n\
 620     Total deallocated:   %f (MB)\n\
 621     Total peak memory:   %f (MB)\n\
 622     Total leaked memory: %f (MB) in %llu allocations\n",
 623         stat_mem_allocated_total,
 624         stat_mem_deallocated_total,
 625         (float)(stat_mem_allocated)                        / 1048576.0f,
 626         (float)(stat_mem_deallocated)                      / 1048576.0f,
 627         (float)(stat_mem_peak)                             / 1048576.0f,
 628         (float)(stat_mem_allocated - stat_mem_deallocated) / 1048576.0f,
 629         stat_mem_allocated_total - stat_mem_deallocated_total
 630     );
 631 }
 632
 633 static void stat_dump_stats_table(stat_size_table_t table, const char *string, uint64_t *size) {
 634     size_t i,j;
 635
 636     if (!table)
 637         return;
 638
 639     for (i = 0, j = 1; i < ST_SIZE; i++) {
 640         stat_size_entry_t *entry;
 641
 642         if (!(entry = table[i]))
 643             continue;
 644
 645         con_out(string, (unsigned)j, (unsigned)entry->key, (unsigned)entry->value);
 646         j++;
 647
 648         if (size)
 649             *size += entry->key * entry->value;
 650     }
 651 }
 652
 653 void stat_info() {
 654     if (OPTS_OPTION_BOOL(OPTION_MEMCHK) ||
 655         OPTS_OPTION_BOOL(OPTION_STATISTICS)) {
 656         uint64_t mem = 0;
 657
 658         con_out("Memory Statistics:\n\
 659     Total vectors allocated:       %llu\n\
 660     Total string duplicates:       %llu\n\
 661     Total string duplicate memory: %f (MB)\n\
 662     Total hashtables allocated:    %llu\n\
 663     Total unique vector sizes:     %llu\n",
 664             stat_used_vectors,
 665             stat_used_strdups,
 666             (float)(stat_mem_strdups) / 1048576.0f,
 667             stat_used_hashtables,
 668             stat_type_vectors
 669         );
 670
 671         stat_dump_stats_table (
 672             stat_size_vectors,
 673             "        %2u| # of %5u byte vectors: %u\n",
 674             &mem
 675         );
 676
 677         con_out (
 678             "    Total unique hashtable sizes: %llu\n",
 679             stat_type_hashtables
 680         );
 681
 682         stat_dump_stats_table (
 683             stat_size_hashtables,
 684             "        %2u| # of %5u element hashtables: %u\n",
 685             NULL
 686         );
 687
 688         con_out (
 689             "    Total vector memory:          %f (MB)\n\n",
 690             (float)(mem) / 1048576.0f
 691         );
 692     }
 693
 694     if (stat_size_vectors)
 695         stat_size_del(stat_size_vectors);
 696     if (stat_size_hashtables)
 697         stat_size_del(stat_size_hashtables);
 698
 699     if (OPTS_OPTION_BOOL(OPTION_DEBUG) ||
 700         OPTS_OPTION_BOOL(OPTION_MEMCHK))
 701         stat_dump_mem_info();
 702
 703     if (OPTS_OPTION_BOOL(OPTION_DEBUG))
 704         stat_dump_mem_leaks();
 705 }
 706 #undef ST_SIZE