lib/bitset_stats.c

   1 /* Bitset statistics.
   2    Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
   3    Contributed by Michael Hayes (m.hayes@elec.canterbury.ac.nz).
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software Foundation,
  17    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  18
  19 /* This file is a wrapper bitset implementation for the other bitset
  20    implementations.  It provides bitset compatibility checking and
  21    statistics gathering without having to instrument the bitset
  22    implementations.  When statistics gathering is enabled, the bitset
  23    operations get vectored through here and we then call the appropriate
  24    routines.  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 # include <config.h>
  28 #endif
  29
  30 #include "bbitset.h"
  31 #include "abitset.h"
  32 #include "ebitset.h"
  33 #include "lbitset.h"
  34 #include "vbitset.h"
  35 #include "bitset_stats.h"
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <stdio.h>
  39
  40 #include "gettext.h"
  41 #define _(Msgid)  gettext (Msgid)
  42
  43 /* Configuration macros.  */
  44 #define BITSET_STATS_FILE "bitset.dat"
  45 #define BITSET_LOG_COUNT_BINS 10
  46 #define BITSET_LOG_SIZE_BINS  16
  47 #define BITSET_DENSITY_BINS  20
  48
  49
  50 /* Accessor macros.  */
  51 #define BITSET_STATS_ALLOCS_INC(TYPE)                   \
  52     bitset_stats_info->types[(TYPE)].allocs++
  53 #define BITSET_STATS_FREES_INC(BSET)                    \
  54     bitset_stats_info->types[BITSET_TYPE_ (BSET)].frees++
  55 #define BITSET_STATS_SETS_INC(BSET)                     \
  56     bitset_stats_info->types[BITSET_TYPE_ (BSET)].sets++
  57 #define BITSET_STATS_CACHE_SETS_INC(BSET)               \
  58     bitset_stats_info->types[BITSET_TYPE_ (BSET)].cache_sets++
  59 #define BITSET_STATS_RESETS_INC(BSET)                   \
  60     bitset_stats_info->types[BITSET_TYPE_ (BSET)].resets++
  61 #define BITSET_STATS_CACHE_RESETS_INC(BSET)             \
  62     bitset_stats_info->types[BITSET_TYPE_ (BSET)].cache_resets++
  63 #define BITSET_STATS_TESTS_INC(BSET)                    \
  64     bitset_stats_info->types[BITSET_TYPE_ (BSET)].tests++
  65 #define BITSET_STATS_CACHE_TESTS_INC(BSET)              \
  66     bitset_stats_info->types[BITSET_TYPE_ (BSET)].cache_tests++
  67 #define BITSET_STATS_LISTS_INC(BSET)                    \
  68     bitset_stats_info->types[BITSET_TYPE_ (BSET)].lists++
  69 #define BITSET_STATS_LIST_COUNTS_INC(BSET, I)           \
  70     bitset_stats_info->types[BITSET_TYPE_ (BSET)].list_counts[(I)]++
  71 #define BITSET_STATS_LIST_SIZES_INC(BSET, I)            \
  72     bitset_stats_info->types[BITSET_TYPE_ (BSET)].list_sizes[(I)]++
  73 #define BITSET_STATS_LIST_DENSITY_INC(BSET, I)          \
  74     bitset_stats_info->types[BITSET_TYPE_ (BSET)].list_density[(I)]++
  75
  76
  77 struct bitset_type_info_struct
  78 {
  79   unsigned int allocs;
  80   unsigned int frees;
  81   unsigned int lists;
  82   unsigned int sets;
  83   unsigned int cache_sets;
  84   unsigned int resets;
  85   unsigned int cache_resets;
  86   unsigned int tests;
  87   unsigned int cache_tests;
  88   unsigned int list_counts[BITSET_LOG_COUNT_BINS];
  89   unsigned int list_sizes[BITSET_LOG_SIZE_BINS];
  90   unsigned int list_density[BITSET_DENSITY_BINS];
  91 };
  92
  93 struct bitset_stats_info_struct
  94 {
  95   unsigned int runs;
  96   struct bitset_type_info_struct types[BITSET_TYPE_NUM];
  97 };
  98
  99
 100 struct bitset_stats_info_struct bitset_stats_info_data;
 101 struct bitset_stats_info_struct *bitset_stats_info;
 102 bool bitset_stats_enabled = false;
 103
 104
 105 /* Print a percentage histogram with message MSG to FILE.  */
 106 static void
 107 bitset_percent_histogram_print (FILE *file, const char *name, const char *msg,
 108                                 unsigned int n_bins, unsigned int *bins)
 109 {
 110   unsigned int i;
 111   unsigned int total;
 112
 113   total = 0;
 114   for (i = 0; i < n_bins; i++)
 115     total += bins[i];
 116
 117   if (!total)
 118     return;
 119
 120   fprintf (file, "%s %s", name, msg);
 121   for (i = 0; i < n_bins; i++)
 122     fprintf (file, "%.0f-%.0f%%\t%8u (%5.1f%%)\n",
 123              i * 100.0 / n_bins,
 124              (i + 1) * 100.0 / n_bins, bins[i],
 125              (100.0 * bins[i]) / total);
 126 }
 127
 128
 129 /* Print a log histogram with message MSG to FILE.  */
 130 static void
 131 bitset_log_histogram_print (FILE *file, const char *name, const char *msg,
 132                             unsigned int n_bins, unsigned int *bins)
 133 {
 134   unsigned int i;
 135   unsigned int total;
 136   unsigned int max_width;
 137
 138   total = 0;
 139   for (i = 0; i < n_bins; i++)
 140     total += bins[i];
 141
 142   if (!total)
 143     return;
 144
 145   /* Determine number of useful bins.  */
 146   for (i = n_bins; i > 3 && ! bins[i - 1]; i--)
 147      continue;
 148   n_bins = i;
 149
 150   /* 2 * ceil (log10 (2) * (N - 1)) + 1.  */
 151   max_width = 2 * (unsigned int) (0.30103 * (n_bins - 1) + 0.9999) + 1;
 152
 153   fprintf (file, "%s %s", name, msg);
 154   for (i = 0; i < 2; i++)
 155     fprintf (file, "%*d\t%8u (%5.1f%%)\n",
 156              max_width, i, bins[i], 100.0 * bins[i] / total);
 157
 158   for (; i < n_bins; i++)
 159     fprintf (file, "%*lu-%lu\t%8u (%5.1f%%)\n",
 160              max_width - ((unsigned int) (0.30103 * (i) + 0.9999) + 1),
 161              1UL << (i - 1),
 162              (1UL << i) - 1,
 163              bins[i],
 164              (100.0 * bins[i]) / total);
 165 }
 166
 167
 168 /* Print bitset statistics to FILE.  */
 169 static void
 170 bitset_stats_print_1 (FILE *file, const char *name,
 171                       struct bitset_type_info_struct *stats)
 172 {
 173   if (!stats)
 174     return;
 175
 176   fprintf (file, "%s:\n", name);
 177   fprintf (file, _("%u bitset_allocs, %u freed (%.2f%%).\n"),
 178            stats->allocs, stats->frees,
 179            stats->allocs ? 100.0 * stats->frees / stats->allocs : 0);
 180   fprintf (file, _("%u bitset_sets, %u cached (%.2f%%)\n"),
 181            stats->sets, stats->cache_sets,
 182            stats->sets ? 100.0 * stats->cache_sets / stats->sets : 0);
 183   fprintf (file, _("%u bitset_resets, %u cached (%.2f%%)\n"),
 184            stats->resets, stats->cache_resets,
 185            stats->resets ? 100.0 * stats->cache_resets / stats->resets : 0);
 186   fprintf (file, _("%u bitset_tests, %u cached (%.2f%%)\n"),
 187            stats->tests, stats->cache_tests,
 188            stats->tests ? 100.0 * stats->cache_tests / stats->tests : 0);
 189
 190   fprintf (file, _("%u bitset_lists\n"), stats->lists);
 191
 192   bitset_log_histogram_print (file, name, _("count log histogram\n"),
 193                               BITSET_LOG_COUNT_BINS, stats->list_counts);
 194
 195   bitset_log_histogram_print (file, name, _("size log histogram\n"),
 196                               BITSET_LOG_SIZE_BINS, stats->list_sizes);
 197
 198   bitset_percent_histogram_print (file, name, _("density histogram\n"),
 199                                   BITSET_DENSITY_BINS, stats->list_density);
 200 }
 201
 202
 203 /* Print all bitset statistics to FILE.  */
 204 static void
 205 bitset_stats_print (FILE *file, bool verbose ATTRIBUTE_UNUSED)
 206 {
 207   int i;
 208
 209   if (!bitset_stats_info)
 210     return;
 211
 212   fprintf (file, _("Bitset statistics:\n\n"));
 213
 214   if (bitset_stats_info->runs > 1)
 215     fprintf (file, _("Accumulated runs = %u\n"), bitset_stats_info->runs);
 216
 217   for (i = 0; i < BITSET_TYPE_NUM; i++)
 218     bitset_stats_print_1 (file, bitset_type_names[i],
 219                           &bitset_stats_info->types[i]);
 220 }
 221
 222
 223 /* Initialise bitset statistics logging.  */
 224 void
 225 bitset_stats_enable (void)
 226 {
 227   if (!bitset_stats_info)
 228     bitset_stats_info = &bitset_stats_info_data;
 229   bitset_stats_enabled = true;
 230 }
 231
 232
 233 void
 234 bitset_stats_disable (void)
 235 {
 236   bitset_stats_enabled = false;
 237 }
 238
 239
 240 /* Read bitset statistics file.  */
 241 void
 242 bitset_stats_read (const char *file_name)
 243 {
 244   FILE *file;
 245
 246   if (!bitset_stats_info)
 247     return;
 248
 249   if (!file_name)
 250     file_name = BITSET_STATS_FILE;
 251
 252   file = fopen (file_name, "r");
 253   if (file)
 254     {
 255       if (fread (&bitset_stats_info_data, sizeof (bitset_stats_info_data),
 256                  1, file) != 1)
 257         {
 258           if (ferror (file))
 259             perror (_("Could not read stats file."));
 260           else
 261             fprintf (stderr, _("Bad stats file size.\n"));
 262         }
 263       if (fclose (file) != 0)
 264         perror (_("Could not read stats file."));
 265     }
 266   bitset_stats_info_data.runs++;
 267 }
 268
 269
 270 /* Write bitset statistics file.  */
 271 void
 272 bitset_stats_write (const char *file_name)
 273 {
 274   FILE *file;
 275
 276   if (!bitset_stats_info)
 277     return;
 278
 279   if (!file_name)
 280     file_name = BITSET_STATS_FILE;
 281
 282   file = fopen (file_name, "w");
 283   if (file)
 284     {
 285       if (fwrite (&bitset_stats_info_data, sizeof (bitset_stats_info_data),
 286                   1, file) != 1)
 287         perror (_("Could not write stats file."));
 288       if (fclose (file) != 0)
 289         perror (_("Could not write stats file."));
 290     }
 291   else
 292     perror (_("Could not open stats file for writing."));
 293 }
 294
 295
 296 /* Dump bitset statistics to FILE.  */
 297 void
 298 bitset_stats_dump (FILE *file)
 299 {
 300   bitset_stats_print (file, false);
 301 }
 302
 303
 304 /* Function to be called from debugger to print bitset stats.  */
 305 void
 306 debug_bitset_stats (void)
 307 {
 308   bitset_stats_print (stderr, true);
 309 }
 310
 311
 312 static void
 313 bitset_stats_set (bitset dst, bitset_bindex bitno)
 314 {
 315   bitset bset = dst->s.bset;
 316   bitset_windex wordno = bitno / BITSET_WORD_BITS;
 317   bitset_windex offset = wordno - bset->b.cindex;
 318
 319   BITSET_STATS_SETS_INC (bset);
 320
 321   if (offset < bset->b.csize)
 322     {
 323       bset->b.cdata[offset] |= (bitset_word) 1 << (bitno % BITSET_WORD_BITS);
 324       BITSET_STATS_CACHE_SETS_INC (bset);
 325     }
 326   else
 327     BITSET_SET_ (bset, bitno);
 328 }
 329
 330
 331 static void
 332 bitset_stats_reset (bitset dst, bitset_bindex bitno)
 333 {
 334   bitset bset = dst->s.bset;
 335   bitset_windex wordno = bitno / BITSET_WORD_BITS;
 336   bitset_windex offset = wordno - bset->b.cindex;
 337
 338   BITSET_STATS_RESETS_INC (bset);
 339
 340   if (offset < bset->b.csize)
 341     {
 342       bset->b.cdata[offset] &=
 343         ~((bitset_word) 1 << (bitno % BITSET_WORD_BITS));
 344       BITSET_STATS_CACHE_RESETS_INC (bset);
 345     }
 346   else
 347     BITSET_RESET_ (bset, bitno);
 348 }
 349
 350
 351 static bool
 352 bitset_stats_toggle (bitset src, bitset_bindex bitno)
 353 {
 354     return BITSET_TOGGLE_ (src->s.bset, bitno);
 355 }
 356
 357
 358 static bool
 359 bitset_stats_test (bitset src, bitset_bindex bitno)
 360 {
 361   bitset bset = src->s.bset;
 362   bitset_windex wordno = bitno / BITSET_WORD_BITS;
 363   bitset_windex offset = wordno - bset->b.cindex;
 364
 365   BITSET_STATS_TESTS_INC (bset);
 366
 367   if (offset < bset->b.csize)
 368     {
 369       BITSET_STATS_CACHE_TESTS_INC (bset);
 370       return (bset->b.cdata[offset] >> (bitno % BITSET_WORD_BITS)) & 1;
 371     }
 372   else
 373     return BITSET_TEST_ (bset, bitno);
 374 }
 375
 376
 377 static bitset_bindex
 378 bitset_stats_resize (bitset src, bitset_bindex size)
 379 {
 380     return BITSET_RESIZE_ (src->s.bset, size);
 381 }
 382
 383
 384 static bitset_bindex
 385 bitset_stats_size (bitset src)
 386 {
 387   return BITSET_SIZE_ (src->s.bset);
 388 }
 389
 390
 391 static bitset_bindex
 392 bitset_stats_count (bitset src)
 393 {
 394   return BITSET_COUNT_ (src->s.bset);
 395 }
 396
 397
 398 static bool
 399 bitset_stats_empty_p (bitset dst)
 400 {
 401   return BITSET_EMPTY_P_ (dst->s.bset);
 402 }
 403
 404
 405 static void
 406 bitset_stats_ones (bitset dst)
 407 {
 408   BITSET_ONES_ (dst->s.bset);
 409 }
 410
 411
 412 static void
 413 bitset_stats_zero (bitset dst)
 414 {
 415   BITSET_ZERO_ (dst->s.bset);
 416 }
 417
 418
 419 static void
 420 bitset_stats_copy (bitset dst, bitset src)
 421 {
 422   BITSET_CHECK2_ (dst, src);
 423   BITSET_COPY_ (dst->s.bset, src->s.bset);
 424 }
 425
 426
 427 static bool
 428 bitset_stats_disjoint_p (bitset dst, bitset src)
 429 {
 430   BITSET_CHECK2_ (dst, src);
 431   return BITSET_DISJOINT_P_ (dst->s.bset, src->s.bset);
 432 }
 433
 434
 435 static bool
 436 bitset_stats_equal_p (bitset dst, bitset src)
 437 {
 438   BITSET_CHECK2_ (dst, src);
 439   return BITSET_EQUAL_P_ (dst->s.bset, src->s.bset);
 440 }
 441
 442
 443 static void
 444 bitset_stats_not (bitset dst, bitset src)
 445 {
 446   BITSET_CHECK2_ (dst, src);
 447   BITSET_NOT_ (dst->s.bset, src->s.bset);
 448 }
 449
 450
 451 static bool
 452 bitset_stats_subset_p (bitset dst, bitset src)
 453 {
 454   BITSET_CHECK2_ (dst, src);
 455   return BITSET_SUBSET_P_ (dst->s.bset, src->s.bset);
 456 }
 457
 458
 459 static void
 460 bitset_stats_and (bitset dst, bitset src1, bitset src2)
 461 {
 462   BITSET_CHECK3_ (dst, src1, src2);
 463   BITSET_AND_ (dst->s.bset, src1->s.bset, src2->s.bset);
 464 }
 465
 466
 467 static bool
 468 bitset_stats_and_cmp (bitset dst, bitset src1, bitset src2)
 469 {
 470   BITSET_CHECK3_ (dst, src1, src2);
 471   return BITSET_AND_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset);
 472 }
 473
 474
 475 static void
 476 bitset_stats_andn (bitset dst, bitset src1, bitset src2)
 477 {
 478   BITSET_CHECK3_ (dst, src1, src2);
 479   BITSET_ANDN_ (dst->s.bset, src1->s.bset, src2->s.bset);
 480 }
 481
 482
 483 static bool
 484 bitset_stats_andn_cmp (bitset dst, bitset src1, bitset src2)
 485 {
 486   BITSET_CHECK3_ (dst, src1, src2);
 487   return BITSET_ANDN_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset);
 488 }
 489
 490
 491 static void
 492 bitset_stats_or (bitset dst, bitset src1, bitset src2)
 493 {
 494   BITSET_CHECK3_ (dst, src1, src2);
 495   BITSET_OR_ (dst->s.bset, src1->s.bset, src2->s.bset);
 496 }
 497
 498
 499 static bool
 500 bitset_stats_or_cmp (bitset dst, bitset src1, bitset src2)
 501 {
 502   BITSET_CHECK3_ (dst, src1, src2);
 503   return BITSET_OR_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset);
 504 }
 505
 506
 507 static void
 508 bitset_stats_xor (bitset dst, bitset src1, bitset src2)
 509 {
 510   BITSET_CHECK3_ (dst, src1, src2);
 511   BITSET_XOR_ (dst->s.bset, src1->s.bset, src2->s.bset);
 512 }
 513
 514
 515 static bool
 516 bitset_stats_xor_cmp (bitset dst, bitset src1, bitset src2)
 517 {
 518   BITSET_CHECK3_ (dst, src1, src2);
 519   return BITSET_XOR_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset);
 520 }
 521
 522
 523 static void
 524 bitset_stats_and_or (bitset dst, bitset src1, bitset src2, bitset src3)
 525 {
 526   BITSET_CHECK4_ (dst, src1, src2, src3);
 527   BITSET_AND_OR_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
 528 }
 529
 530
 531 static bool
 532 bitset_stats_and_or_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
 533 {
 534   BITSET_CHECK4_ (dst, src1, src2, src3);
 535   return BITSET_AND_OR_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
 536 }
 537
 538
 539 static void
 540 bitset_stats_andn_or (bitset dst, bitset src1, bitset src2, bitset src3)
 541 {
 542   BITSET_CHECK4_ (dst, src1, src2, src3);
 543   BITSET_ANDN_OR_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
 544 }
 545
 546
 547 static bool
 548 bitset_stats_andn_or_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
 549 {
 550   BITSET_CHECK4_ (dst, src1, src2, src3);
 551   return BITSET_ANDN_OR_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
 552 }
 553
 554
 555 static void
 556 bitset_stats_or_and (bitset dst, bitset src1, bitset src2, bitset src3)
 557 {
 558   BITSET_CHECK4_ (dst, src1, src2, src3);
 559   BITSET_OR_AND_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
 560 }
 561
 562
 563 static bool
 564 bitset_stats_or_and_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
 565 {
 566   BITSET_CHECK4_ (dst, src1, src2, src3);
 567   return BITSET_OR_AND_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
 568 }
 569
 570
 571 static bitset_bindex
 572 bitset_stats_list (bitset bset, bitset_bindex *list,
 573                    bitset_bindex num, bitset_bindex *next)
 574 {
 575   bitset_bindex count;
 576   bitset_bindex tmp;
 577   bitset_bindex size;
 578   bitset_bindex i;
 579   enum bitset_type type;
 580
 581   count = BITSET_LIST_ (bset->s.bset, list, num, next);
 582
 583   type = BITSET_TYPE_ (bset->s.bset);
 584   BITSET_STATS_LISTS_INC (bset->s.bset);
 585
 586   /* Log histogram of number of set bits.  */
 587   for (i = 0, tmp = count; tmp; tmp >>= 1, i++)
 588      continue;
 589   if (i >= BITSET_LOG_COUNT_BINS)
 590      i = BITSET_LOG_COUNT_BINS - 1;
 591   BITSET_STATS_LIST_COUNTS_INC (bset->s.bset, i);
 592
 593   /* Log histogram of number of bits in set.  */
 594   size = BITSET_SIZE_ (bset->s.bset);
 595   for (i = 0, tmp = size; tmp; tmp >>= 1, i++)
 596      continue;
 597   if (i >= BITSET_LOG_SIZE_BINS)
 598      i = BITSET_LOG_SIZE_BINS - 1;
 599   BITSET_STATS_LIST_SIZES_INC (bset->s.bset, i);
 600
 601   /* Histogram of fraction of bits set.  */
 602   i = size ? (count * BITSET_DENSITY_BINS) / size : 0;
 603   if (i >= BITSET_DENSITY_BINS)
 604      i = BITSET_DENSITY_BINS - 1;
 605   BITSET_STATS_LIST_DENSITY_INC (bset->s.bset, i);
 606   return count;
 607 }
 608
 609
 610 static bitset_bindex
 611 bitset_stats_list_reverse (bitset bset, bitset_bindex *list,
 612                            bitset_bindex num, bitset_bindex *next)
 613 {
 614   return BITSET_LIST_REVERSE_ (bset->s.bset, list, num, next);
 615 }
 616
 617
 618 static void
 619 bitset_stats_free (bitset bset)
 620 {
 621   BITSET_STATS_FREES_INC (bset->s.bset);
 622   BITSET_FREE_ (bset->s.bset);
 623 }
 624
 625
 626 struct bitset_vtable bitset_stats_vtable = {
 627   bitset_stats_set,
 628   bitset_stats_reset,
 629   bitset_stats_toggle,
 630   bitset_stats_test,
 631   bitset_stats_resize,
 632   bitset_stats_size,
 633   bitset_stats_count,
 634   bitset_stats_empty_p,
 635   bitset_stats_ones,
 636   bitset_stats_zero,
 637   bitset_stats_copy,
 638   bitset_stats_disjoint_p,
 639   bitset_stats_equal_p,
 640   bitset_stats_not,
 641   bitset_stats_subset_p,
 642   bitset_stats_and,
 643   bitset_stats_and_cmp,
 644   bitset_stats_andn,
 645   bitset_stats_andn_cmp,
 646   bitset_stats_or,
 647   bitset_stats_or_cmp,
 648   bitset_stats_xor,
 649   bitset_stats_xor_cmp,
 650   bitset_stats_and_or,
 651   bitset_stats_and_or_cmp,
 652   bitset_stats_andn_or,
 653   bitset_stats_andn_or_cmp,
 654   bitset_stats_or_and,
 655   bitset_stats_or_and_cmp,
 656   bitset_stats_list,
 657   bitset_stats_list_reverse,
 658   bitset_stats_free,
 659   BITSET_STATS
 660 };
 661
 662
 663 /* Return enclosed bitset type.  */
 664 enum bitset_type
 665 bitset_stats_type_get (bitset bset)
 666 {
 667    return BITSET_TYPE_ (bset->s.bset);
 668 }
 669
 670
 671 size_t
 672 bitset_stats_bytes (void)
 673 {
 674   return sizeof (struct bitset_stats_struct);
 675 }
 676
 677
 678 bitset
 679 bitset_stats_init (bitset bset, bitset_bindex n_bits, enum bitset_type type)
 680 {
 681   size_t bytes;
 682   bitset sbset;
 683
 684   bset->b.vtable = &bitset_stats_vtable;
 685
 686   /* Disable cache.  */
 687   bset->b.cindex = 0;
 688   bset->b.csize = 0;
 689   bset->b.cdata = 0;
 690
 691   BITSET_NBITS_ (bset) = n_bits;
 692
 693   /* Set up the actual bitset implementation that
 694      we are a wrapper over.  */
 695   switch (type)
 696     {
 697     default:
 698       abort ();
 699
 700     case BITSET_ARRAY:
 701       bytes = abitset_bytes (n_bits);
 702       sbset = xcalloc (1, bytes);
 703       abitset_init (sbset, n_bits);
 704       break;
 705
 706     case BITSET_LIST:
 707       bytes = lbitset_bytes (n_bits);
 708       sbset = xcalloc (1, bytes);
 709       lbitset_init (sbset, n_bits);
 710       break;
 711
 712     case BITSET_TABLE:
 713       bytes = ebitset_bytes (n_bits);
 714       sbset = xcalloc (1, bytes);
 715       ebitset_init (sbset, n_bits);
 716       break;
 717
 718     case BITSET_VARRAY:
 719       bytes = vbitset_bytes (n_bits);
 720       sbset = xcalloc (1, bytes);
 721       vbitset_init (sbset, n_bits);
 722       break;
 723     }
 724
 725   bset->s.bset = sbset;
 726
 727   BITSET_STATS_ALLOCS_INC (type);
 728
 729   return bset;
 730 }