1 /* Bitset statistics.
2
3 Copyright (C) 2002-2006, 2009-2015, 2018-2021 Free Software Foundation, Inc.
4
5 Contributed by Michael Hayes (m.hayes@elec.canterbury.ac.nz).
6
7 This program is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <https://www.gnu.org/licenses/>. */
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
25 routines. */
26
27 #include <config.h>
28
29 #include "bitset/stats.h"
30
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34
35 #include "gettext.h"
36 #define _(Msgid) gettext (Msgid)
37
38 #include "bitset/array.h"
39 #include "bitset/base.h"
40 #include "bitset/list.h"
41 #include "bitset/table.h"
42 #include "bitset/vector.h"
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
78 struct bitset_type_info_struct
79 {
80 unsigned allocs;
81 unsigned frees;
82 unsigned lists;
83 unsigned sets;
84 unsigned cache_sets;
85 unsigned resets;
86 unsigned cache_resets;
87 unsigned tests;
88 unsigned cache_tests;
89 unsigned list_counts[BITSET_LOG_COUNT_BINS];
90 unsigned list_sizes[BITSET_LOG_SIZE_BINS];
91 unsigned list_density[BITSET_DENSITY_BINS];
92 };
93
94 struct bitset_stats_info_struct
95 {
96 unsigned 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 bool bitset_stats_enabled = false;
104
105
106 /* Print a percentage histogram with message MSG to FILE. */
107 static void
108 bitset_percent_histogram_print (FILE *file, const char *name, const char *msg,
109 unsigned n_bins, unsigned *bins)
110 {
111 unsigned total = 0;
112 for (unsigned i = 0; i < n_bins; i++)
113 total += bins[i];
114
115 if (!total)
116 return;
117
118 fprintf (file, "%s %s", name, msg);
119 for (unsigned i = 0; i < n_bins; i++)
120 fprintf (file, "%.0f-%.0f%%\t%8u (%5.1f%%)\n",
121 i * 100.0 / n_bins,
122 (i + 1) * 100.0 / n_bins, bins[i],
123 (100.0 * bins[i]) / total);
124 }
125
126
127 /* Print a log histogram with message MSG to FILE. */
128 static void
129 bitset_log_histogram_print (FILE *file, const char *name, const char *msg,
130 unsigned n_bins, unsigned *bins)
131 {
132 unsigned total = 0;
133 for (unsigned i = 0; i < n_bins; i++)
134 total += bins[i];
135
136 if (!total)
137 return;
138
139 /* Determine number of useful bins. */
140 {
141 unsigned i;
142 for (i = n_bins; i > 3 && ! bins[i - 1]; i--)
143 continue;
144 n_bins = i;
145 }
146
147 /* 2 * ceil (log10 (2) * (N - 1)) + 1. */
148 unsigned max_width = 2 * (unsigned) (0.30103 * (n_bins - 1) + 0.9999) + 1;
149
150 fprintf (file, "%s %s", name, msg);
151 {
152 unsigned i;
153 for (i = 0; i < 2; i++)
154 fprintf (file, "%*d\t%8u (%5.1f%%)\n",
155 max_width, i, bins[i], 100.0 * bins[i] / total);
156
157 for (; i < n_bins - 1; i++)
158 fprintf (file, "%*lu-%lu\t%8u (%5.1f%%)\n",
159 max_width - ((unsigned) (0.30103 * (i) + 0.9999) + 1),
160 1UL << (i - 1),
161 (1UL << i) - 1,
162 bins[i],
163 (100.0 * bins[i]) / total);
164
165 fprintf (file, "%*lu-...\t%8u (%5.1f%%)\n",
166 max_width - ((unsigned) (0.30103 * (i) + 0.9999) + 1),
167 1UL << (i - 1),
168 bins[i],
169 (100.0 * bins[i]) / total);
170 }
171 }
172
173
174 /* Print bitset statistics to FILE. */
175 static void
176 bitset_stats_print_1 (FILE *file, const char *name,
177 struct bitset_type_info_struct *stats)
178 {
179 if (!stats)
180 return;
181
182 fprintf (file, "%s:\n", name);
183 fprintf (file, _("%u bitset_allocs, %u freed (%.2f%%).\n"),
184 stats->allocs, stats->frees,
185 stats->allocs ? 100.0 * stats->frees / stats->allocs : 0);
186 fprintf (file, _("%u bitset_sets, %u cached (%.2f%%)\n"),
187 stats->sets, stats->cache_sets,
188 stats->sets ? 100.0 * stats->cache_sets / stats->sets : 0);
189 fprintf (file, _("%u bitset_resets, %u cached (%.2f%%)\n"),
190 stats->resets, stats->cache_resets,
191 stats->resets ? 100.0 * stats->cache_resets / stats->resets : 0);
192 fprintf (file, _("%u bitset_tests, %u cached (%.2f%%)\n"),
193 stats->tests, stats->cache_tests,
194 stats->tests ? 100.0 * stats->cache_tests / stats->tests : 0);
195
196 fprintf (file, _("%u bitset_lists\n"), stats->lists);
197
198 bitset_log_histogram_print (file, name, _("count log histogram\n"),
199 BITSET_LOG_COUNT_BINS, stats->list_counts);
200
201 bitset_log_histogram_print (file, name, _("size log histogram\n"),
202 BITSET_LOG_SIZE_BINS, stats->list_sizes);
203
204 bitset_percent_histogram_print (file, name, _("density histogram\n"),
205 BITSET_DENSITY_BINS, stats->list_density);
206 }
207
208
209 /* Print all bitset statistics to FILE. */
210 static void
211 bitset_stats_print (FILE *file, MAYBE_UNUSED bool verbose)
212 {
213 if (!bitset_stats_info)
214 return;
215
216 fprintf (file, _("Bitset statistics:\n\n"));
217
218 if (bitset_stats_info->runs > 1)
219 fprintf (file, _("Accumulated runs = %u\n"), bitset_stats_info->runs);
220
221 for (int i = 0; i < BITSET_TYPE_NUM; i++)
222 bitset_stats_print_1 (file, bitset_type_names[i],
223 &bitset_stats_info->types[i]);
224 }
225
226
227 /* Initialise bitset statistics logging. */
228 void
229 bitset_stats_enable (void)
230 {
231 if (!bitset_stats_info)
232 bitset_stats_info = &bitset_stats_info_data;
233 bitset_stats_enabled = true;
234 }
235
236
237 void
238 bitset_stats_disable (void)
239 {
240 bitset_stats_enabled = false;
241 }
242
243
244 /* Read bitset statistics file. */
245 void
246 bitset_stats_read (const char *file_name)
247 {
248 if (!bitset_stats_info)
249 return;
250
251 if (!file_name)
252 file_name = BITSET_STATS_FILE;
253
254 FILE *file = fopen (file_name, "re");
255 if (file)
256 {
257 if (fread (&bitset_stats_info_data, sizeof (bitset_stats_info_data),
258 1, file) != 1)
259 {
260 if (ferror (file))
261 perror (_("cannot read stats file"));
262 else
263 fprintf (stderr, _("bad stats file size\n"));
264 }
265 if (fclose (file) != 0)
266 perror (_("cannot read stats file"));
267 }
268 bitset_stats_info_data.runs++;
269 }
270
271
272 /* Write bitset statistics file. */
273 void
274 bitset_stats_write (const char *file_name)
275 {
276 if (!bitset_stats_info)
277 return;
278
279 if (!file_name)
280 file_name = BITSET_STATS_FILE;
281
282 FILE *file = fopen (file_name, "we");
283 if (file)
284 {
285 if (fwrite (&bitset_stats_info_data, sizeof (bitset_stats_info_data),
286 1, file) != 1)
287 perror (_("cannot write stats file"));
288 if (fclose (file) != 0)
289 perror (_("cannot write stats file"));
290 }
291 else
292 perror (_("cannot 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 = BITSET_LIST_ (bset->s.bset, list, num, next);
576
577 BITSET_STATS_LISTS_INC (bset->s.bset);
578
579 /* Log histogram of number of set bits. */
580 {
581 bitset_bindex i;
582 bitset_bindex tmp;
583 for (i = 0, tmp = count; tmp; tmp >>= 1, i++)
584 continue;
585 if (i >= BITSET_LOG_COUNT_BINS)
586 i = BITSET_LOG_COUNT_BINS - 1;
587 BITSET_STATS_LIST_COUNTS_INC (bset->s.bset, i);
588 }
589
590 /* Log histogram of number of bits in set. */
591 bitset_bindex size = BITSET_SIZE_ (bset->s.bset);
592 {
593 bitset_bindex i;
594 bitset_bindex tmp;
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
602 /* Histogram of fraction of bits set. */
603 {
604 bitset_bindex i = size ? (count * BITSET_DENSITY_BINS) / size : 0;
605 if (i >= BITSET_DENSITY_BINS)
606 i = BITSET_DENSITY_BINS - 1;
607 BITSET_STATS_LIST_DENSITY_INC (bset->s.bset, i);
608 }
609 return count;
610 }
611
612
613 static bitset_bindex
614 bitset_stats_list_reverse (bitset bset, bitset_bindex *list,
615 bitset_bindex num, bitset_bindex *next)
616 {
617 return BITSET_LIST_REVERSE_ (bset->s.bset, list, num, next);
618 }
619
620
621 static void
622 bitset_stats_free (bitset bset)
623 {
624 BITSET_STATS_FREES_INC (bset->s.bset);
625 BITSET_FREE_ (bset->s.bset);
626 }
627
628
629 struct bitset_vtable bitset_stats_vtable = {
630 bitset_stats_set,
631 bitset_stats_reset,
632 bitset_stats_toggle,
633 bitset_stats_test,
634 bitset_stats_resize,
635 bitset_stats_size,
636 bitset_stats_count,
637 bitset_stats_empty_p,
638 bitset_stats_ones,
639 bitset_stats_zero,
640 bitset_stats_copy,
641 bitset_stats_disjoint_p,
642 bitset_stats_equal_p,
643 bitset_stats_not,
644 bitset_stats_subset_p,
645 bitset_stats_and,
646 bitset_stats_and_cmp,
647 bitset_stats_andn,
648 bitset_stats_andn_cmp,
649 bitset_stats_or,
650 bitset_stats_or_cmp,
651 bitset_stats_xor,
652 bitset_stats_xor_cmp,
653 bitset_stats_and_or,
654 bitset_stats_and_or_cmp,
655 bitset_stats_andn_or,
656 bitset_stats_andn_or_cmp,
657 bitset_stats_or_and,
658 bitset_stats_or_and_cmp,
659 bitset_stats_list,
660 bitset_stats_list_reverse,
661 bitset_stats_free,
662 BITSET_STATS
663 };
664
665
666 /* Return enclosed bitset type. */
667 enum bitset_type
668 bitset_stats_type_get (bitset bset)
669 {
670 return BITSET_TYPE_ (bset->s.bset);
671 }
672
673
674 size_t
675 bitset_stats_bytes (void)
676 {
677 return sizeof (struct bitset_stats_struct);
678 }
679
680
681 bitset
682 bitset_stats_init (bitset bset, bitset_bindex n_bits, enum bitset_type type)
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 {
702 size_t bytes = abitset_bytes (n_bits);
703 bset->s.bset = xzalloc (bytes);
704 abitset_init (bset->s.bset, n_bits);
705 }
706 break;
707
708 case BITSET_LIST:
709 {
710 size_t bytes = lbitset_bytes (n_bits);
711 bset->s.bset = xzalloc (bytes);
712 lbitset_init (bset->s.bset, n_bits);
713 }
714 break;
715
716 case BITSET_TABLE:
717 {
718 size_t bytes = tbitset_bytes (n_bits);
719 bset->s.bset = xzalloc (bytes);
720 tbitset_init (bset->s.bset, n_bits);
721 }
722 break;
723
724 case BITSET_VECTOR:
725 {
726 size_t bytes = vbitset_bytes (n_bits);
727 bset->s.bset = xzalloc (bytes);
728 vbitset_init (bset->s.bset, n_bits);
729 }
730 break;
731 }
732
733 BITSET_STATS_ALLOCS_INC (type);
734
735 return bset;
736 }