stat.c

   1 /*
   2  * Copyright (C) 2012, 2013
   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  * GMQCC performs tons of allocations, constructions, and crazyness
  32  * all around. When trying to optimizes systems, or just get fancy
  33  * statistics out of the compiler, it's often printf mess. This file
  34  * implements the statistics system of the compiler. I.E the allocator
  35  * we use to track allocations, and other systems of interest.
  36  */
  37 #define ST_SIZE 1024
  38
  39 typedef struct stat_mem_block_s {
  40     const char              *file;
  41     size_t                   line;
  42     size_t                   size;
  43     struct stat_mem_block_s *next;
  44     struct stat_mem_block_s *prev;
  45 } stat_mem_block_t;
  46
  47 typedef struct {
  48     size_t key;
  49     size_t value;
  50 } stat_size_entry_t, **stat_size_table_t;
  51
  52 static uint64_t          stat_mem_allocated         = 0;
  53 static uint64_t          stat_mem_deallocated       = 0;
  54 static uint64_t          stat_mem_allocated_total   = 0;
  55 static uint64_t          stat_mem_deallocated_total = 0;
  56 static uint64_t          stat_mem_high              = 0;
  57 static uint64_t          stat_mem_peak              = 0;
  58 static uint64_t          stat_mem_strdups           = 0;
  59 static uint64_t          stat_used_strdups          = 0;
  60 static uint64_t          stat_used_vectors          = 0;
  61 static uint64_t          stat_used_hashtables       = 0;
  62 static uint64_t          stat_type_vectors          = 0;
  63 static uint64_t          stat_type_hashtables       = 0;
  64 static stat_size_table_t stat_size_vectors          = NULL;
  65 static stat_size_table_t stat_size_hashtables       = NULL;
  66 static stat_mem_block_t *stat_mem_block_root        = NULL;
  67
  68 /*
  69  * A tiny size_t key-value hashtbale for tracking vector and hashtable
  70  * sizes. We can use it for other things too, if we need to. This is
  71  * very TIGHT, and efficent in terms of space though.
  72  */
  73 static stat_size_table_t stat_size_new(void) {
  74     return (stat_size_table_t)memset(
  75         mem_a(sizeof(stat_size_entry_t*) * ST_SIZE),
  76         0, ST_SIZE * sizeof(stat_size_entry_t*)
  77     );
  78 }
  79
  80 static void stat_size_del(stat_size_table_t table) {
  81     size_t i = 0;
  82     for (; i < ST_SIZE; i++) if(table[i]) mem_d(table[i]);
  83     mem_d(table);
  84 }
  85
  86 static stat_size_entry_t *stat_size_get(stat_size_table_t table, size_t key) {
  87     size_t hash = (key % ST_SIZE);
  88     while (table[hash] && table[hash]->key != key)
  89         hash = (hash + 1) % ST_SIZE;
  90     return table[hash];
  91 }
  92 static void stat_size_put(stat_size_table_t table, size_t key, size_t value) {
  93     size_t hash = (key % ST_SIZE);
  94     while (table[hash] && table[hash]->key != key)
  95         hash = (hash + 1) % ST_SIZE;
  96     table[hash]        = (stat_size_entry_t*)mem_a(sizeof(stat_size_entry_t));
  97     table[hash]->key   = key;
  98     table[hash]->value = value;
  99 }
 100
 101 /*
 102  * A basic header of information wrapper allocator. Simply stores
 103  * information as a header, returns the memory + 1 past it, can be
 104  * retrieved again with - 1. Where type is stat_mem_block_t*.
 105  */
 106 void *stat_mem_allocate(size_t size, size_t line, const char *file) {
 107     stat_mem_block_t *info = (stat_mem_block_t*)malloc(sizeof(stat_mem_block_t) + size);
 108     void             *data = (void*)(info + 1);
 109
 110     if(GMQCC_UNLIKELY(!info))
 111         return NULL;
 112
 113     info->line = line;
 114     info->size = size;
 115     info->file = file;
 116     info->prev = NULL;
 117     info->next = stat_mem_block_root;
 118
 119     /* unlikely since it only happens once */
 120     if (GMQCC_UNLIKELY(stat_mem_block_root != NULL))
 121         stat_mem_block_root->prev = info;
 122
 123     stat_mem_block_root       = info;
 124     stat_mem_allocated       += size;
 125     stat_mem_high            += size;
 126     stat_mem_allocated_total ++;
 127
 128     if (stat_mem_high > stat_mem_peak)
 129         stat_mem_peak = stat_mem_high;
 130
 131     return data;
 132 }
 133
 134 void stat_mem_deallocate(void *ptr) {
 135     stat_mem_block_t *info = NULL;
 136
 137     if (GMQCC_UNLIKELY(!ptr))
 138         return;
 139
 140     info = ((stat_mem_block_t*)ptr - 1);
 141
 142     stat_mem_deallocated       += info->size;
 143     stat_mem_high              -= info->size;
 144     stat_mem_deallocated_total ++;
 145
 146     if (info->prev) info->prev->next = info->next;
 147     if (info->next) info->next->prev = info->prev;
 148
 149     /* move ahead */
 150     if (info == stat_mem_block_root)
 151         stat_mem_block_root = info->next;
 152
 153     free(info);
 154 }
 155
 156 void *stat_mem_reallocate(void *ptr, size_t size, size_t line, const char *file) {
 157     stat_mem_block_t *oldinfo = NULL;
 158     stat_mem_block_t *newinfo;
 159
 160     if (GMQCC_UNLIKELY(!ptr))
 161         return stat_mem_allocate(size, line, file);
 162
 163     /* stay consistent with glibc */
 164     if (GMQCC_UNLIKELY(!size)) {
 165         stat_mem_deallocate(ptr);
 166         return NULL;
 167     }
 168
 169     oldinfo = ((stat_mem_block_t*)ptr - 1);
 170     newinfo = ((stat_mem_block_t*)malloc(sizeof(stat_mem_block_t) + size));
 171
 172     if (GMQCC_UNLIKELY(!newinfo)) {
 173         stat_mem_deallocate(ptr);
 174         return NULL;
 175     }
 176
 177     memcpy(newinfo+1, oldinfo+1, oldinfo->size);
 178
 179     if (oldinfo->prev) oldinfo->prev->next = oldinfo->next;
 180     if (oldinfo->next) oldinfo->next->prev = oldinfo->prev;
 181
 182     /* move ahead */
 183     if (oldinfo == stat_mem_block_root)
 184         stat_mem_block_root = oldinfo->next;
 185
 186     newinfo->line = line;
 187     newinfo->size = size;
 188     newinfo->file = file;
 189     newinfo->prev = NULL;
 190     newinfo->next = stat_mem_block_root;
 191
 192     /*
 193      * likely since the only time there is no root is when it's
 194      * being initialized first.
 195      */
 196     if (GMQCC_LIKELY(stat_mem_block_root != NULL))
 197         stat_mem_block_root->prev = newinfo;
 198
 199     stat_mem_block_root = newinfo;
 200     stat_mem_allocated -= oldinfo->size;
 201     stat_mem_high      -= oldinfo->size;
 202     stat_mem_allocated += newinfo->size;
 203     stat_mem_high      += newinfo->size;
 204
 205     if (stat_mem_high > stat_mem_peak)
 206         stat_mem_peak = stat_mem_high;
 207
 208     free(oldinfo);
 209     return newinfo + 1;
 210 }
 211
 212 /*
 213  * strdup does it's own malloc, we need to track malloc. We don't want
 214  * to overwrite malloc though, infact, we can't really hook it at all
 215  * without library specific assumptions. So we re implement strdup.
 216  */
 217 char *stat_mem_strdup(const char *src, size_t line, const char *file, bool empty) {
 218     size_t len = 0;
 219     char  *ptr = NULL;
 220
 221     if (!src)
 222         return NULL;
 223
 224     len = strlen(src);
 225     if (((!empty) ? len : true) && (ptr = (char*)stat_mem_allocate(len + 1, line, file))) {
 226         memcpy(ptr, src, len);
 227         ptr[len] = '\0';
 228     }
 229
 230     stat_used_strdups ++;
 231     stat_mem_strdups  += len;
 232     return ptr;
 233 }
 234
 235 /*
 236  * The reallocate function for resizing vectors.
 237  */
 238 void _util_vec_grow(void **a, size_t i, size_t s) {
 239     vector_t          *d = vec_meta(*a);
 240     size_t             m = 0;
 241     stat_size_entry_t *e = NULL;
 242     void              *p = NULL;
 243
 244     if (*a) {
 245         m = 2 * d->allocated + i;
 246         p = mem_r(d, s * m + sizeof(vector_t));
 247     } else {
 248         m = i + 1;
 249         p = mem_a(s * m + sizeof(vector_t));
 250         ((vector_t*)p)->used = 0;
 251         stat_used_vectors++;
 252     }
 253
 254     if (!stat_size_vectors)
 255         stat_size_vectors = stat_size_new();
 256
 257     if ((e = stat_size_get(stat_size_vectors, s))) {
 258         e->value ++;
 259     } else {
 260         stat_size_put(stat_size_vectors, s, 1); /* start off with 1 */
 261         stat_type_vectors++;
 262     }
 263
 264     *a = (vector_t*)p + 1;
 265     vec_meta(*a)->allocated = m;
 266 }
 267
 268 /*
 269  * Hash table for generic data, based on dynamic memory allocations
 270  * all around.  This is the internal interface, please look for
 271  * EXPOSED INTERFACE comment below
 272  */
 273 typedef struct hash_node_t {
 274     char               *key;   /* the key for this node in table */
 275     void               *value; /* pointer to the data as void*   */
 276     struct hash_node_t *next;  /* next node (linked list)        */
 277 } hash_node_t;
 278
 279 /*
 280  * This is a patched version of the Murmur2 hashing function to use
 281  * a proper pre-mix and post-mix setup. Infact this is Murmur3 for
 282  * the most part just reinvented.
 283  *
 284  * Murmur 2 contains an inner loop such as:
 285  * while (l >= 4) {
 286  *      u32 k = *(u32*)d;
 287  *      k *= m;
 288  *      k ^= k >> r;
 289  *      k *= m;
 290  *
 291  *      h *= m;
 292  *      h ^= k;
 293  *      d += 4;
 294  *      l -= 4;
 295  * }
 296  *
 297  * The two u32s that form the key are the same value x (pulled from data)
 298  * this premix stage will perform the same results for both values. Unrolled
 299  * this produces just:
 300  *  x *= m;
 301  *  x ^= x >> r;
 302  *  x *= m;
 303  *
 304  *  h *= m;
 305  *  h ^= x;
 306  *  h *= m;
 307  *  h ^= x;
 308  *
 309  * This appears to be fine, except what happens when m == 1? well x
 310  * cancels out entierly, leaving just:
 311  *  x ^= x >> r;
 312  *  h ^= x;
 313  *  h ^= x;
 314  *
 315  * So all keys hash to the same value, but how often does m == 1?
 316  * well, it turns out testing x for all possible values yeilds only
 317  * 172,013,942 unique results instead of 2^32. So nearly ~4.6 bits
 318  * are cancelled out on average!
 319  *
 320  * This means we have a 14.5% (rounded) chance of colliding more, which
 321  * results in another bucket/chain for the hashtable.
 322  *
 323  * We fix it buy upgrading the pre and post mix ssystems to align with murmur
 324  * hash 3.
 325  */
 326 #if 1
 327 #define GMQCC_ROTL32(X, R) (((X) << (R)) | ((X) >> (32 - (R))))
 328 GMQCC_INLINE size_t util_hthash(hash_table_t *ht, const char *key) {
 329     const unsigned char *data   = (const unsigned char *)key;
 330     const size_t         len    = strlen(key);
 331     const size_t         block  = len / 4;
 332     const uint32_t       mask1  = 0xCC9E2D51;
 333     const uint32_t       mask2  = 0x1B873593;
 334     const uint32_t      *blocks = (const uint32_t*)(data + block * 4);
 335     const unsigned char *tail   = (const unsigned char *)(data + block * 4);
 336
 337     size_t   i;
 338     uint32_t k;
 339     uint32_t h = 0x1EF0 ^ len;
 340
 341     for (i = -block; i; i++) {
 342         k  = blocks[i];
 343         k *= mask1;
 344         k  = GMQCC_ROTL32(k, 15);
 345         k *= mask2;
 346         h ^= k;
 347         h  = GMQCC_ROTL32(h, 13);
 348         h  = h * 5 + 0xE6546B64;
 349     }
 350
 351     k = 0;
 352     switch (len & 3) {
 353         case 3:
 354             k ^= tail[2] << 16;
 355         case 2:
 356             k ^= tail[1] << 8;
 357         case 1:
 358             k ^= tail[0];
 359             k *= mask1;
 360             k  = GMQCC_ROTL32(k, 15);
 361             k *= mask2;
 362             h ^= k;
 363     }
 364
 365     h ^= len;
 366     h ^= h >> 16;
 367     h *= 0x85EBCA6B;
 368     h ^= h >> 13;
 369     h *= 0xC2B2AE35;
 370     h ^= h >> 16;
 371
 372     return (size_t) (h % ht->size);
 373 }
 374 #undef GMQCC_ROTL32
 375 #else
 376 /* We keep the old for reference */
 377 GMQCC_INLINE size_t util_hthash(hash_table_t *ht, const char *key) {
 378     const uint32_t       mix   = 0x5BD1E995;
 379     const uint32_t       rot   = 24;
 380     size_t               size  = strlen(key);
 381     uint32_t             hash  = 0x1EF0 /* LICRC TAB */  ^ size;
 382     uint32_t             alias = 0;
 383     const unsigned char *data  = (const unsigned char*)key;
 384
 385     while (size >= 4) {
 386         alias  = (data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24));
 387         alias *= mix;
 388         alias ^= alias >> rot;
 389         alias *= mix;
 390
 391         hash  *= mix;
 392         hash  ^= alias;
 393
 394         data += 4;
 395         size -= 4;
 396     }
 397
 398     switch (size) {
 399         case 3: hash ^= data[2] << 16;
 400         case 2: hash ^= data[1] << 8;
 401         case 1: hash ^= data[0];
 402                 hash *= mix;
 403     }
 404
 405     hash ^= hash >> 13;
 406     hash *= mix;
 407     hash ^= hash >> 15;
 408
 409     return (size_t) (hash % ht->size);
 410 }
 411 #endif
 412
 413 static hash_node_t *_util_htnewpair(const char *key, void *value) {
 414     hash_node_t *node;
 415     if (!(node = (hash_node_t*)mem_a(sizeof(hash_node_t))))
 416         return NULL;
 417
 418     if (!(node->key = util_strdupe(key))) {
 419         mem_d(node);
 420         return NULL;
 421     }
 422
 423     node->value = value;
 424     node->next  = NULL;
 425
 426     return node;
 427 }
 428
 429 /*
 430  * EXPOSED INTERFACE for the hashtable implementation
 431  * util_htnew(size)                             -- to make a new hashtable
 432  * util_htset(table, key, value, sizeof(value)) -- to set something in the table
 433  * util_htget(table, key)                       -- to get something from the table
 434  * util_htdel(table)                            -- to delete the table
 435  */
 436 hash_table_t *util_htnew(size_t size) {
 437     hash_table_t      *hashtable = NULL;
 438     stat_size_entry_t *find      = NULL;
 439
 440     if (size < 1)
 441         return NULL;
 442
 443     if (!stat_size_hashtables)
 444         stat_size_hashtables = stat_size_new();
 445
 446     if (!(hashtable = (hash_table_t*)mem_a(sizeof(hash_table_t))))
 447         return NULL;
 448
 449     if (!(hashtable->table = (hash_node_t**)mem_a(sizeof(hash_node_t*) * size))) {
 450         mem_d(hashtable);
 451         return NULL;
 452     }
 453
 454     if ((find = stat_size_get(stat_size_hashtables, size)))
 455         find->value++;
 456     else {
 457         stat_type_hashtables++;
 458         stat_size_put(stat_size_hashtables, size, 1);
 459     }
 460
 461     hashtable->size = size;
 462     memset(hashtable->table, 0, sizeof(hash_node_t*) * size);
 463
 464     stat_used_hashtables++;
 465     return hashtable;
 466 }
 467
 468 void util_htseth(hash_table_t *ht, const char *key, size_t bin, void *value) {
 469     hash_node_t *newnode = NULL;
 470     hash_node_t *next    = NULL;
 471     hash_node_t *last    = NULL;
 472
 473     next = ht->table[bin];
 474
 475     while (next && next->key && strcmp(key, next->key) > 0)
 476         last = next, next = next->next;
 477
 478     /* already in table, do a replace */
 479     if (next && next->key && strcmp(key, next->key) == 0) {
 480         next->value = value;
 481     } else {
 482         /* not found, grow a pair man :P */
 483         newnode = _util_htnewpair(key, value);
 484         if (next == ht->table[bin]) {
 485             newnode->next  = next;
 486             ht->table[bin] = newnode;
 487         } else if (!next) {
 488             last->next = newnode;
 489         } else {
 490             newnode->next = next;
 491             last->next = newnode;
 492         }
 493     }
 494 }
 495
 496 void util_htset(hash_table_t *ht, const char *key, void *value) {
 497     util_htseth(ht, key, util_hthash(ht, key), value);
 498 }
 499
 500 void *util_htgeth(hash_table_t *ht, const char *key, size_t bin) {
 501     hash_node_t *pair = ht->table[bin];
 502
 503     while (pair && pair->key && strcmp(key, pair->key) > 0)
 504         pair = pair->next;
 505
 506     if (!pair || !pair->key || strcmp(key, pair->key) != 0)
 507         return NULL;
 508
 509     return pair->value;
 510 }
 511
 512 void *util_htget(hash_table_t *ht, const char *key) {
 513     return util_htgeth(ht, key, util_hthash(ht, key));
 514 }
 515
 516 void *code_util_str_htgeth(hash_table_t *ht, const char *key, size_t bin);
 517 void *code_util_str_htgeth(hash_table_t *ht, const char *key, size_t bin) {
 518     hash_node_t *pair;
 519     size_t len, keylen;
 520     int cmp;
 521
 522     keylen = strlen(key);
 523
 524     pair = ht->table[bin];
 525     while (pair && pair->key) {
 526         len = strlen(pair->key);
 527         if (len < keylen) {
 528             pair = pair->next;
 529             continue;
 530         }
 531         if (keylen == len) {
 532             cmp = strcmp(key, pair->key);
 533             if (cmp == 0)
 534                 return pair->value;
 535             if (cmp < 0)
 536                 return NULL;
 537             pair = pair->next;
 538             continue;
 539         }
 540         cmp = strcmp(key, pair->key + len - keylen);
 541         if (cmp == 0) {
 542             uintptr_t up = (uintptr_t)pair->value;
 543             up += len - keylen;
 544             return (void*)up;
 545         }
 546         pair = pair->next;
 547     }
 548     return NULL;
 549 }
 550
 551 /*
 552  * Free all allocated data in a hashtable, this is quite the amount
 553  * of work.
 554  */
 555 void util_htrem(hash_table_t *ht, void (*callback)(void *data)) {
 556     size_t i = 0;
 557
 558     for (; i < ht->size; ++i) {
 559         hash_node_t *n = ht->table[i];
 560         hash_node_t *p;
 561
 562         /* free in list */
 563         while (n) {
 564             if (n->key)
 565                 mem_d(n->key);
 566             if (callback)
 567                 callback(n->value);
 568             p = n;
 569             n = p->next;
 570             mem_d(p);
 571         }
 572
 573     }
 574     /* free table */
 575     mem_d(ht->table);
 576     mem_d(ht);
 577 }
 578
 579 void util_htrmh(hash_table_t *ht, const char *key, size_t bin, void (*cb)(void*)) {
 580     hash_node_t **pair = &ht->table[bin];
 581     hash_node_t *tmp;
 582
 583     while (*pair && (*pair)->key && strcmp(key, (*pair)->key) > 0)
 584         pair = &(*pair)->next;
 585
 586     tmp = *pair;
 587     if (!tmp || !tmp->key || strcmp(key, tmp->key) != 0)
 588         return;
 589
 590     if (cb)
 591         (*cb)(tmp->value);
 592
 593     *pair = tmp->next;
 594     mem_d(tmp->key);
 595     mem_d(tmp);
 596 }
 597
 598 void util_htrm(hash_table_t *ht, const char *key, void (*cb)(void*)) {
 599     util_htrmh(ht, key, util_hthash(ht, key), cb);
 600 }
 601
 602 void util_htdel(hash_table_t *ht) {
 603     util_htrem(ht, NULL);
 604 }
 605
 606 /*
 607  * The following functions below implement printing / dumping of statistical
 608  * information.
 609  */
 610 static void stat_dump_mem_contents(stat_mem_block_t *memory, uint16_t cols) {
 611     uint32_t i, j;
 612     for (i = 0; i < memory->size + ((memory->size % cols) ? (cols - memory->size % cols) : 0); i++) {
 613         if (i % cols == 0)    con_out(" 0x%06X: ", i);
 614         if (i < memory->size) con_out("%02X " , 0xFF & ((unsigned char*)(memory + 1))[i]);
 615         else                  con_out(" ");
 616
 617         if ((uint16_t)(i % cols) == (cols - 1)) {
 618             for (j = i - (cols - 1); j <= i; j++) {
 619                 con_out("%c",
 620                     (j >= memory->size)
 621                         ? ' '
 622                         : (util_isprint(((unsigned char*)(memory + 1))[j]))
 623                             ? 0xFF & ((unsigned char*)(memory + 1)) [j]
 624                             : '.'
 625                 );
 626             }
 627             con_out("\n");
 628         }
 629     }
 630 }
 631
 632 static void stat_dump_mem_leaks(void) {
 633     stat_mem_block_t *info;
 634     for (info = stat_mem_block_root; info; info = info->next) {
 635         con_out("lost: %u (bytes) at %s:%u\n",
 636             info->size,
 637             info->file,
 638             info->line
 639         );
 640
 641         stat_dump_mem_contents(info, OPTS_OPTION_U16(OPTION_MEMDUMPCOLS));
 642     }
 643 }
 644
 645 static void stat_dump_mem_info(void) {
 646     con_out("Memory Information:\n\
 647     Total allocations:   %llu\n\
 648     Total deallocations: %llu\n\
 649     Total allocated:     %f (MB)\n\
 650     Total deallocated:   %f (MB)\n\
 651     Total peak memory:   %f (MB)\n\
 652     Total leaked memory: %f (MB) in %llu allocations\n",
 653         stat_mem_allocated_total,
 654         stat_mem_deallocated_total,
 655         (float)(stat_mem_allocated)                        / 1048576.0f,
 656         (float)(stat_mem_deallocated)                      / 1048576.0f,
 657         (float)(stat_mem_peak)                             / 1048576.0f,
 658         (float)(stat_mem_allocated - stat_mem_deallocated) / 1048576.0f,
 659         stat_mem_allocated_total - stat_mem_deallocated_total
 660     );
 661 }
 662
 663 static void stat_dump_stats_table(stat_size_table_t table, const char *string, uint64_t *size) {
 664     size_t i,j;
 665
 666     if (!table)
 667         return;
 668
 669     for (i = 0, j = 1; i < ST_SIZE; i++) {
 670         stat_size_entry_t *entry;
 671
 672         if (!(entry = table[i]))
 673             continue;
 674
 675         con_out(string, (unsigned)j, (unsigned)entry->key, (unsigned)entry->value);
 676         j++;
 677
 678         if (size)
 679             *size += entry->key * entry->value;
 680     }
 681 }
 682
 683 void stat_info() {
 684     if (OPTS_OPTION_BOOL(OPTION_MEMCHK) ||
 685         OPTS_OPTION_BOOL(OPTION_STATISTICS)) {
 686         uint64_t mem = 0;
 687
 688         con_out("Memory Statistics:\n\
 689     Total vectors allocated:       %llu\n\
 690     Total string duplicates:       %llu\n\
 691     Total string duplicate memory: %f (MB)\n\
 692     Total hashtables allocated:    %llu\n\
 693     Total unique vector sizes:     %llu\n",
 694             stat_used_vectors,
 695             stat_used_strdups,
 696             (float)(stat_mem_strdups) / 1048576.0f,
 697             stat_used_hashtables,
 698             stat_type_vectors
 699         );
 700
 701         stat_dump_stats_table (
 702             stat_size_vectors,
 703             "        %2u| # of %5u byte vectors: %u\n",
 704             &mem
 705         );
 706
 707         con_out (
 708             "    Total unique hashtable sizes: %llu\n",
 709             stat_type_hashtables
 710         );
 711
 712         stat_dump_stats_table (
 713             stat_size_hashtables,
 714             "        %2u| # of %5u element hashtables: %u\n",
 715             NULL
 716         );
 717
 718         con_out (
 719             "    Total vector memory:          %f (MB)\n\n",
 720             (float)(mem) / 1048576.0f
 721         );
 722     }
 723
 724     if (stat_size_vectors)
 725         stat_size_del(stat_size_vectors);
 726     if (stat_size_hashtables)
 727         stat_size_del(stat_size_hashtables);
 728
 729     if (OPTS_OPTION_BOOL(OPTION_DEBUG) ||
 730         OPTS_OPTION_BOOL(OPTION_MEMCHK))
 731         stat_dump_mem_info();
 732
 733     if (OPTS_OPTION_BOOL(OPTION_DEBUG))
 734         stat_dump_mem_leaks();
 735 }
 736 #undef ST_SIZE