[bison.git] / lib / bitset_stats.c

/* Bitset statistics.
   Copyright (C) 2002, 2003 Free Software Foundation, Inc.
   Contributed by Michael Hayes (m.hayes@elec.canterbury.ac.nz).

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/

/* This file is a wrapper bitset implementation for the other bitset
   implementations.  It provides bitset compatibility checking and
   statistics gathering without having to instrument the bitset
   implementations.  When statistics gathering is enabled, the bitset
   operations get vectored through here and we then call the appropriate
   routines.
*/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "bbitset.h"
#include "abitset.h"
#include "ebitset.h"
#include "lbitset.h"
#include "bitset_stats.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include "gettext.h"
#define _(Msgid)  gettext (Msgid)

/* Configuration macros.  */
#define BITSET_STATS_FILE "bitset.dat"
#define BITSET_LOG_COUNT_BINS 10
#define BITSET_LOG_SIZE_BINS  16
#define BITSET_DENSITY_BINS  20


/* Accessor macros.  */
#define BITSET_STATS_ALLOCS_INC(TYPE)	 		\
    bitset_stats_info->types[(TYPE)].allocs++
#define BITSET_STATS_FREES_INC(BSET) 			\
    bitset_stats_info->types[BITSET_TYPE_ (BSET)].frees++
#define BITSET_STATS_SETS_INC(BSET) 			\
    bitset_stats_info->types[BITSET_TYPE_ (BSET)].sets++
#define BITSET_STATS_CACHE_SETS_INC(BSET) 		\
    bitset_stats_info->types[BITSET_TYPE_ (BSET)].cache_sets++
#define BITSET_STATS_RESETS_INC(BSET) 			\
    bitset_stats_info->types[BITSET_TYPE_ (BSET)].resets++
#define BITSET_STATS_CACHE_RESETS_INC(BSET) 		\
    bitset_stats_info->types[BITSET_TYPE_ (BSET)].cache_resets++
#define BITSET_STATS_TESTS_INC(BSET) 			\
    bitset_stats_info->types[BITSET_TYPE_ (BSET)].tests++
#define BITSET_STATS_CACHE_TESTS_INC(BSET) 		\
    bitset_stats_info->types[BITSET_TYPE_ (BSET)].cache_tests++
#define BITSET_STATS_LISTS_INC(BSET) 			\
    bitset_stats_info->types[BITSET_TYPE_ (BSET)].lists++
#define BITSET_STATS_LIST_COUNTS_INC(BSET, I) 		\
    bitset_stats_info->types[BITSET_TYPE_ (BSET)].list_counts[(I)]++
#define BITSET_STATS_LIST_SIZES_INC(BSET, I) 		\
    bitset_stats_info->types[BITSET_TYPE_ (BSET)].list_sizes[(I)]++
#define BITSET_STATS_LIST_DENSITY_INC(BSET, I) 		\
    bitset_stats_info->types[BITSET_TYPE_ (BSET)].list_density[(I)]++


struct bitset_type_info_struct
{
  unsigned int allocs;
  unsigned int frees;
  unsigned int lists;
  unsigned int sets;
  unsigned int cache_sets;
  unsigned int resets;
  unsigned int cache_resets;
  unsigned int tests;
  unsigned int cache_tests;
  unsigned int list_counts[BITSET_LOG_COUNT_BINS];
  unsigned int list_sizes[BITSET_LOG_SIZE_BINS];
  unsigned int list_density[BITSET_DENSITY_BINS];
};

struct bitset_stats_info_struct
{
  unsigned int runs;
  struct bitset_type_info_struct types[BITSET_TYPE_NUM];
};


struct bitset_stats_info_struct bitset_stats_info_data;
struct bitset_stats_info_struct *bitset_stats_info;
int bitset_stats_enabled = 0;


/* Print a percentage histogram with message MSG to FILE.  */
static void
bitset_percent_histogram_print (FILE *file, const char *name, const char *msg,
				unsigned int n_bins, unsigned int *bins)
{
  unsigned int i;
  unsigned int total;

  total = 0;
  for (i = 0; i < n_bins; i++)
    total += bins[i];

  if (!total)
    return;

  fprintf (file, "%s %s", name, msg);
  for (i = 0; i < n_bins; i++)
    fprintf (file, "%.0f-%.0f%%\t%8u (%5.1f%%)\n",
	     i * 100.0 / n_bins,
	     (i + 1) * 100.0 / n_bins, bins[i],
	     (100.0 * bins[i]) / total);
}


/* Print a log histogram with message MSG to FILE.  */
static void
bitset_log_histogram_print (FILE *file, const char *name, const char *msg,
			    unsigned int n_bins, unsigned int *bins)
{
  unsigned int i;
  unsigned int total;
  unsigned int max_width;

  total = 0;
  for (i = 0; i < n_bins; i++)
    total += bins[i];

  if (!total)
    return;

  /* Determine number of useful bins.  */
  for (i = n_bins; i > 3 && ! bins[i - 1]; i--)
     continue;
  n_bins = i;

  /* 2 * ceil (log10 (2) * (N - 1)) + 1.  */
  max_width = 2 * (unsigned int) (0.30103 * (n_bins - 1) + 0.9999) + 1;

  fprintf (file, "%s %s", name, msg);
  for (i = 0; i < 2; i++)
    fprintf (file, "%*d\t%8u (%5.1f%%)\n",
	     max_width, i, bins[i], 100.0 * bins[i] / total);

  for (; i < n_bins; i++)
    fprintf (file, "%*lu-%lu\t%8u (%5.1f%%)\n",
	     max_width - ((unsigned int) (0.30103 * (i) + 0.9999) + 1),
	     (unsigned long) 1 << (i - 1),
	     ((unsigned long) 1 << i) - 1,
	     bins[i],
	     (100.0 * bins[i]) / total);
}


/* Print bitset statistics to FILE.  */
static void
bitset_stats_print_1 (FILE *file, const char *name,
		      struct bitset_type_info_struct *stats)
{
  if (!stats)
    return;

  fprintf (file, "%s:\n", name);
  fprintf (file, _("%u bitset_allocs, %u freed (%.2f%%).\n"),
	   stats->allocs, stats->frees,
	   stats->allocs ? 100.0 * stats->frees / stats->allocs : 0);
  fprintf (file, _("%u bitset_sets, %u cached (%.2f%%)\n"),
	   stats->sets, stats->cache_sets,
	   stats->sets ? 100.0 * stats->cache_sets / stats->sets : 0);
  fprintf (file, _("%u bitset_resets, %u cached (%.2f%%)\n"),
	   stats->resets, stats->cache_resets,
	   stats->resets ? 100.0 * stats->cache_resets / stats->resets : 0);
  fprintf (file, _("%u bitset_tests, %u cached (%.2f%%)\n"),
	   stats->tests, stats->cache_tests,
	   stats->tests ? 100.0 * stats->cache_tests / stats->tests : 0);

  fprintf (file, _("%u bitset_lists\n"), stats->lists);

  bitset_log_histogram_print (file, name, _("count log histogram\n"),
			      BITSET_LOG_COUNT_BINS, stats->list_counts);

  bitset_log_histogram_print (file, name, _("size log histogram\n"),
			      BITSET_LOG_SIZE_BINS, stats->list_sizes);

  bitset_percent_histogram_print (file, name, _("density histogram\n"),
				  BITSET_DENSITY_BINS, stats->list_density);
}


/* Print all bitset statistics to FILE.  */
static void
bitset_stats_print (FILE *file, int verbose ATTRIBUTE_UNUSED)
{
  int i;

  if (!bitset_stats_info)
    return;

  fprintf (file, _("Bitset statistics:\n\n"));

  if (bitset_stats_info->runs > 1)
    fprintf (file, _("Accumulated runs = %u\n"), bitset_stats_info->runs);

  for (i = 0; i < BITSET_TYPE_NUM; i++)
    bitset_stats_print_1 (file, bitset_type_names[i],
			  &bitset_stats_info->types[i]);
}


/* Initialise bitset statistics logging.  */
void
bitset_stats_enable (void)
{
  if (!bitset_stats_info)
    bitset_stats_info = &bitset_stats_info_data;
  bitset_stats_enabled = 1;
}


void
bitset_stats_disable (void)
{
  bitset_stats_enabled = 0;
}


/* Read bitset statistics file.  */
void
bitset_stats_read (const char *filename)
{
  FILE *file;

  if (!bitset_stats_info)
    return;

  if (!filename)
    filename = BITSET_STATS_FILE;

  file = fopen (filename, "r");
  if (file)
    {
      if (fread (&bitset_stats_info_data, sizeof (bitset_stats_info_data),
		 1, file) != 1)
	{
	  if (ferror (file))
	    perror (_("Could not read stats file."));
	  else
	    fprintf (stderr, _("Bad stats file size.\n"));
	}
      if (fclose (file) != 0)
	perror (_("Could not read stats file."));
    }
  bitset_stats_info_data.runs++;
}


/* Write bitset statistics file.  */
void
bitset_stats_write (const char *filename)
{
  FILE *file;

  if (!bitset_stats_info)
    return;

  if (!filename)
    filename = BITSET_STATS_FILE;

  file = fopen (filename, "w");
  if (file)
    {
      if (fwrite (&bitset_stats_info_data, sizeof (bitset_stats_info_data),
		  1, file) != 1)
	perror (_("Could not write stats file."));
      if (fclose (file) != 0)
	perror (_("Could not write stats file."));
    }
  else
    perror (_("Could not open stats file for writing."));
}


/* Dump bitset statistics to FILE.  */
void
bitset_stats_dump (FILE *file)
{
  bitset_stats_print (file, 0);
}


/* Function to be called from debugger to print bitset stats.  */
void
debug_bitset_stats (void)
{
  bitset_stats_print (stderr, 1);
}


static void
bitset_stats_set (bitset dst, bitset_bindex bitno)
{
  bitset bset = dst->s.bset;
  bitset_windex wordno = bitno / BITSET_WORD_BITS;
  bitset_windex offset = wordno - bset->b.cindex;

  BITSET_STATS_SETS_INC (bset);

  if (offset < bset->b.csize)
    {
      bset->b.cdata[offset] |= (bitset_word) 1 << (bitno % BITSET_WORD_BITS);
      BITSET_STATS_CACHE_SETS_INC (bset);
    }
  else
    BITSET_SET_ (bset, bitno);
}


static void
bitset_stats_reset (bitset dst, bitset_bindex bitno)
{
  bitset bset = dst->s.bset;
  bitset_windex wordno = bitno / BITSET_WORD_BITS;
  bitset_windex offset = wordno - bset->b.cindex;

  BITSET_STATS_RESETS_INC (bset);

  if (offset < bset->b.csize)
    {
      bset->b.cdata[offset] &=
	~((bitset_word) 1 << (bitno % BITSET_WORD_BITS));
      BITSET_STATS_CACHE_RESETS_INC (bset);
    }
  else
    BITSET_RESET_ (bset, bitno);
}


static int
bitset_stats_toggle (bitset src, bitset_bindex bitno)
{
    return BITSET_TOGGLE_ (src->s.bset, bitno);
}


static int
bitset_stats_test (bitset src, bitset_bindex bitno)
{
  bitset bset = src->s.bset;
  bitset_windex wordno = bitno / BITSET_WORD_BITS;
  bitset_windex offset = wordno - bset->b.cindex;

  BITSET_STATS_TESTS_INC (bset);

  if (offset < bset->b.csize)
    {
      BITSET_STATS_CACHE_TESTS_INC (bset);
      return (bset->b.cdata[offset] >> (bitno % BITSET_WORD_BITS)) & 1;
    }
  else
    return BITSET_TEST_ (bset, bitno);
}


static bitset_bindex
bitset_stats_size (bitset src)
{
  return BITSET_SIZE_ (src->s.bset);
}


static bitset_bindex
bitset_stats_count (bitset src)
{
  return BITSET_COUNT_ (src->s.bset);
}


static int
bitset_stats_empty_p (bitset dst)
{
  return BITSET_EMPTY_P_ (dst->s.bset);
}


static void
bitset_stats_ones (bitset dst)
{
  BITSET_ONES_ (dst->s.bset);
}


static void
bitset_stats_zero (bitset dst)
{
  BITSET_ZERO_ (dst->s.bset);
}


static void
bitset_stats_copy (bitset dst, bitset src)
{
  BITSET_CHECK2_ (dst, src);
  BITSET_COPY_ (dst->s.bset, src->s.bset);
}


static int
bitset_stats_disjoint_p (bitset dst, bitset src)
{
  BITSET_CHECK2_ (dst, src);
  return BITSET_DISJOINT_P_ (dst->s.bset, src->s.bset);
}


static int
bitset_stats_equal_p (bitset dst, bitset src)
{
  BITSET_CHECK2_ (dst, src);
  return BITSET_EQUAL_P_ (dst->s.bset, src->s.bset);
}


static void
bitset_stats_not (bitset dst, bitset src)
{
  BITSET_CHECK2_ (dst, src);
  BITSET_NOT_ (dst->s.bset, src->s.bset);
}


static int
bitset_stats_subset_p (bitset dst, bitset src)
{
  BITSET_CHECK2_ (dst, src);
  return BITSET_SUBSET_P_ (dst->s.bset, src->s.bset);
}


static void
bitset_stats_and (bitset dst, bitset src1, bitset src2)
{
  BITSET_CHECK3_ (dst, src1, src2);
  BITSET_AND_ (dst->s.bset, src1->s.bset, src2->s.bset);
}


static int
bitset_stats_and_cmp (bitset dst, bitset src1, bitset src2)
{
  BITSET_CHECK3_ (dst, src1, src2);
  return BITSET_AND_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset);
}


static void
bitset_stats_andn (bitset dst, bitset src1, bitset src2)
{
  BITSET_CHECK3_ (dst, src1, src2);
  BITSET_ANDN_ (dst->s.bset, src1->s.bset, src2->s.bset);
}


static int
bitset_stats_andn_cmp (bitset dst, bitset src1, bitset src2)
{
  BITSET_CHECK3_ (dst, src1, src2);
  return BITSET_ANDN_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset);
}


static void
bitset_stats_or (bitset dst, bitset src1, bitset src2)
{
  BITSET_CHECK3_ (dst, src1, src2);
  BITSET_OR_ (dst->s.bset, src1->s.bset, src2->s.bset);
}


static int
bitset_stats_or_cmp (bitset dst, bitset src1, bitset src2)
{
  BITSET_CHECK3_ (dst, src1, src2);
  return BITSET_OR_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset);
}


static void
bitset_stats_xor (bitset dst, bitset src1, bitset src2)
{
  BITSET_CHECK3_ (dst, src1, src2);
  BITSET_XOR_ (dst->s.bset, src1->s.bset, src2->s.bset);
}


static int
bitset_stats_xor_cmp (bitset dst, bitset src1, bitset src2)
{
  BITSET_CHECK3_ (dst, src1, src2);
  return BITSET_XOR_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset);
}


static void
bitset_stats_and_or (bitset dst, bitset src1, bitset src2, bitset src3)
{
  BITSET_CHECK4_ (dst, src1, src2, src3);

  BITSET_AND_OR_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
}


static int
bitset_stats_and_or_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
{
  BITSET_CHECK4_ (dst, src1, src2, src3);

  return BITSET_AND_OR_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
}


static void
bitset_stats_andn_or (bitset dst, bitset src1, bitset src2, bitset src3)
{
  BITSET_CHECK4_ (dst, src1, src2, src3);

  BITSET_ANDN_OR_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
}


static int
bitset_stats_andn_or_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
{
  BITSET_CHECK4_ (dst, src1, src2, src3);

  return BITSET_ANDN_OR_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
}


static void
bitset_stats_or_and (bitset dst, bitset src1, bitset src2, bitset src3)
{
  BITSET_CHECK4_ (dst, src1, src2, src3);

  BITSET_OR_AND_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
}


static int
bitset_stats_or_and_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
{
  BITSET_CHECK4_ (dst, src1, src2, src3);

  return BITSET_OR_AND_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
}


static bitset_bindex
bitset_stats_list (bitset bset, bitset_bindex *list,
		   bitset_bindex num, bitset_bindex *next)
{
  bitset_bindex count;
  bitset_bindex tmp;
  bitset_bindex size;
  bitset_bindex i;

  count = BITSET_LIST_ (bset->s.bset, list, num, next);

  BITSET_STATS_LISTS_INC (bset->s.bset);

  /* Log histogram of number of set bits.  */
  for (i = 0, tmp = count; tmp; tmp >>= 1, i++)
     continue;
  if (i >= BITSET_LOG_COUNT_BINS)
     i = BITSET_LOG_COUNT_BINS - 1;
  BITSET_STATS_LIST_COUNTS_INC (bset->s.bset, i);

  /* Log histogram of number of bits in set.  */
  size = BITSET_SIZE_ (bset->s.bset);
  for (i = 0, tmp = size; tmp; tmp >>= 1, i++)
     continue;
  if (i >= BITSET_LOG_SIZE_BINS)
     i = BITSET_LOG_SIZE_BINS - 1;
  BITSET_STATS_LIST_SIZES_INC (bset->s.bset, i);

  /* Histogram of fraction of bits set.  */
  i = size ? (count * BITSET_DENSITY_BINS) / size : 0;
  if (i >= BITSET_DENSITY_BINS)
     i = BITSET_DENSITY_BINS - 1;
  BITSET_STATS_LIST_DENSITY_INC (bset->s.bset, i);
  return count;
}


static bitset_bindex
bitset_stats_list_reverse (bitset bset, bitset_bindex *list,
			   bitset_bindex num, bitset_bindex *next)
{
  return BITSET_LIST_REVERSE_ (bset->s.bset, list, num, next);
}


static void
bitset_stats_free (bitset bset)
{
  BITSET_STATS_FREES_INC (bset->s.bset);
  BITSET_FREE_ (bset->s.bset);
}


struct bitset_vtable bitset_stats_vtable = {
  bitset_stats_set,
  bitset_stats_reset,
  bitset_stats_toggle,
  bitset_stats_test,
  bitset_stats_size,
  bitset_stats_count,
  bitset_stats_empty_p,
  bitset_stats_ones,
  bitset_stats_zero,
  bitset_stats_copy,
  bitset_stats_disjoint_p,
  bitset_stats_equal_p,
  bitset_stats_not,
  bitset_stats_subset_p,
  bitset_stats_and,
  bitset_stats_and_cmp,
  bitset_stats_andn,
  bitset_stats_andn_cmp,
  bitset_stats_or,
  bitset_stats_or_cmp,
  bitset_stats_xor,
  bitset_stats_xor_cmp,
  bitset_stats_and_or,
  bitset_stats_and_or_cmp,
  bitset_stats_andn_or,
  bitset_stats_andn_or_cmp,
  bitset_stats_or_and,
  bitset_stats_or_and_cmp,
  bitset_stats_list,
  bitset_stats_list_reverse,
  bitset_stats_free,
  BITSET_STATS
};


/* Return enclosed bitset type.  */
enum bitset_type
bitset_stats_type_get (bitset bset)
{
   return BITSET_TYPE_ (bset->s.bset);
}


size_t
bitset_stats_bytes (void)
{
  return sizeof (struct bitset_stats_struct);
}


bitset
bitset_stats_init (bitset bset, bitset_bindex n_bits, enum bitset_type type)
{
  size_t bytes;
  bitset sbset;

  bset->b.vtable = &bitset_stats_vtable;

  /* Disable cache.  */
  bset->b.cindex = 0;
  bset->b.csize = 0;
  bset->b.cdata = 0;

  /* Set up the actual bitset implementation that
     we are a wrapper over.  */
  switch (type)
    {
    case BITSET_ARRAY:
      bytes = abitset_bytes (n_bits);
      sbset = (bitset) xcalloc (1, bytes);
      abitset_init (sbset, n_bits);
      break;

    case BITSET_LIST:
      bytes = lbitset_bytes (n_bits);
      sbset = (bitset) xcalloc (1, bytes);
      lbitset_init (sbset, n_bits);
      break;

    case BITSET_TABLE:
      bytes = ebitset_bytes (n_bits);
      sbset = (bitset) xcalloc (1, bytes);
      ebitset_init (sbset, n_bits);
      break;

    default:
      abort ();
    }

  bset->s.bset = sbset;

  BITSET_STATS_ALLOCS_INC (type);

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