// returns 0 on error, 1 if ok.
int and_or_test() {
bitset_container_t* B1 = bitset_container_create();
bitset_container_t* B2 = bitset_container_create();
bitset_container_t* BI = bitset_container_create();
bitset_container_t* BO = bitset_container_create();
int x, c, ci, co;
printf("[%s] %s\n", __FILE__, __func__);
if ((B1 == NULL) || (B2 == NULL) || (BO == NULL) || (BI == NULL)) {
printf("Bug %s, line %d \n", __FILE__, __LINE__);
return 0;
}
for (x = 0; x < (1 << 16); x += 3) {
bitset_container_set(B1, (uint16_t)x);
bitset_container_set(BI, (uint16_t)x);
}
for (x = 0; x < (1 << 16);
x += 62) { // important: 62 is not divisible by 3
bitset_container_set(B2, (uint16_t)x);
bitset_container_set(BI, (uint16_t)x);
}
for (x = 0; x < (1 << 16); x += 62 * 3) {
bitset_container_set(BO, (uint16_t)x);
}
// we interleave O and I on purpose (to trigger bugs!)
ci = bitset_container_compute_cardinality(BO); // expected intersection
co = bitset_container_compute_cardinality(BI); // expected union
bitset_container_and_nocard(B1, B2, BI);
c = bitset_container_compute_cardinality(BI);
if (c != ci) {
printf("Bug %s, line %d \n", __FILE__, __LINE__);
return 0;
}
c = bitset_container_and(B1, B2, BI);
;
if (c != ci) {
printf("Bug %s, line %d \n", __FILE__, __LINE__);
return 0;
}
bitset_container_or_nocard(B1, B2, BO);
c = bitset_container_compute_cardinality(BO);
if (c != co) {
printf("Bug %s, line %d \n", __FILE__, __LINE__);
return 0;
}
c = bitset_container_or(B1, B2, BO);
if (c != co) {
printf("Bug %s, line %d \n", __FILE__, __LINE__);
return 0;
}
bitset_container_free(B1);
bitset_container_free(B2);
bitset_container_free(BI);
bitset_container_free(BO);
return 1;
}
// returns 0 on error, 1 if ok.
int set_get_test() {
bitset_container_t* B = bitset_container_create();
int x;
printf("[%s] %s\n", __FILE__, __func__);
if (B == NULL) {
printf("Bug %s, line %d \n", __FILE__, __LINE__);
return 0;
}
for (x = 0; x < 1 << 16; x++) {
assert(!bitset_container_get(B, x));
}
for (x = 0; x < 1 << 16; x += 3) {
assert(bitset_container_cardinality(B) == x / 3);
assert(!bitset_container_get(B, x));
bitset_container_set(B, (uint16_t)x);
assert(bitset_container_get(B, x));
assert(bitset_container_cardinality(B) == x / 3 + 1);
}
for (x = 0; x < 1 << 16; x++) {
int isset = bitset_container_get(B, (uint16_t)x);
int shouldbeset = (x / 3 * 3 == x);
if (isset != shouldbeset) {
printf("Bug %s, line %d \n", __FILE__, __LINE__);
bitset_container_free(B);
return 0;
}
}
if (bitset_container_cardinality(B) != (1 << 16) / 3 + 1) {
printf("Bug %s, line %d \n", __FILE__, __LINE__);
bitset_container_free(B);
return 0;
}
if (bitset_container_compute_cardinality(B) != (1 << 16) / 3 + 1) {
printf("Bug %s, line %d \n", __FILE__, __LINE__);
bitset_container_free(B);
return 0;
}
for (x = 0; x < 1 << 16; x += 3) {
bitset_container_unset(B, (uint16_t)x);
}
if (bitset_container_cardinality(B) != 0) {
printf("Bug %s, line %d \n", __FILE__, __LINE__);
bitset_container_free(B);
return 0;
}
if (bitset_container_compute_cardinality(B) != 0) {
printf("Bug %s, line %d \n", __FILE__, __LINE__);
bitset_container_free(B);
return 0;
}
bitset_container_free(B);
return 1;
}
void run_bitset_container_union(const run_container_t *src_1,
const bitset_container_t *src_2,
bitset_container_t *dst) {
assert(!run_container_is_full(src_1)); // catch this case upstream
if (src_2 != dst) bitset_container_copy(src_2, dst);
for (int32_t rlepos = 0; rlepos < src_1->n_runs; ++rlepos) {
rle16_t rle = src_1->runs[rlepos];
bitset_set_lenrange(dst->array, rle.value, rle.length);
}
dst->cardinality = bitset_container_compute_cardinality(dst);
}
/*
* Same as bitset_container_negation except that if the output is to
* be a
* bitset_container_t, then src is modified and no allocation is made.
* If the output is to be an array_container_t, then caller is responsible
* to free the container.
* In all cases, the result is in *dst.
*/
bool bitset_container_negation_range_inplace(bitset_container_t *src,
const int range_start,
const int range_end, void **dst) {
bitset_flip_range(src->array, (uint32_t)range_start, (uint32_t)range_end);
src->cardinality = bitset_container_compute_cardinality(src);
if (src->cardinality > DEFAULT_MAX_SIZE) {
*dst = src;
return true;
}
*dst = array_container_from_bitset(src);
bitset_container_free(src);
return false;
}
// returns 0 on error, 1 if ok.
int xor_test() {
bitset_container_t* B1 = bitset_container_create();
bitset_container_t* B2 = bitset_container_create();
bitset_container_t* BI = bitset_container_create();
int x, c, cx;
printf("[%s] %s\n", __FILE__, __func__);
for (x = 0; x < (1 << 16); x += 3) {
bitset_container_set(B1, (uint16_t)x);
bitset_container_set(BI, (uint16_t)x);
}
for (x = 0; x < (1 << 16);
x += 62) { // important: 62 is not divisible by 3
bitset_container_set(B2, (uint16_t)x);
bitset_container_set(BI, (uint16_t)x);
}
for (x = 0; x < (1 << 16); x += 62 * 3) {
bitset_container_unset(BI, (uint16_t)x);
}
cx = bitset_container_compute_cardinality(BI); // expected xor
bitset_container_xor_nocard(B1, B2, BI);
c = bitset_container_compute_cardinality(BI);
if (c != cx) {
printf("Bug %s, line %d \n", __FILE__, __LINE__);
return 0;
}
c = bitset_container_xor(B1, B2, BI);
if (c != cx) {
printf("Bug %s, line %d \n", __FILE__, __LINE__);
return 0;
}
bitset_container_free(B1);
bitset_container_free(B2);
bitset_container_free(BI);
return 1;
}
bool run_bitset_container_andnot(const run_container_t *src_1,
const bitset_container_t *src_2, void **dst) {
// follows the Java implementation as of June 2016
int card = run_container_cardinality(src_1);
if (card <= DEFAULT_MAX_SIZE) {
// must be an array
array_container_t *answer = array_container_create_given_capacity(card);
answer->cardinality = 0;
for (int32_t rlepos = 0; rlepos < src_1->n_runs; ++rlepos) {
rle16_t rle = src_1->runs[rlepos];
for (int run_value = rle.value; run_value <= rle.value + rle.length;
++run_value) {
if (!bitset_container_get(src_2, (uint16_t)run_value)) {
answer->array[answer->cardinality++] = (uint16_t)run_value;
}
}
}
*dst = answer;
return false;
} else { // we guess it will be a bitset, though have to check guess when
// done
bitset_container_t *answer = bitset_container_clone(src_2);
uint32_t last_pos = 0;
for (int32_t rlepos = 0; rlepos < src_1->n_runs; ++rlepos) {
rle16_t rle = src_1->runs[rlepos];
uint32_t start = rle.value;
uint32_t end = start + rle.length + 1;
bitset_reset_range(answer->array, last_pos, start);
bitset_flip_range(answer->array, start, end);
last_pos = end;
}
bitset_reset_range(answer->array, last_pos, (uint32_t)(1 << 16));
answer->cardinality = bitset_container_compute_cardinality(answer);
if (answer->cardinality <= DEFAULT_MAX_SIZE) {
*dst = array_container_from_bitset(answer);
bitset_container_free(answer);
return false; // not bitset
}
*dst = answer;
return true; // bitset
}
}
bool bitset_run_container_iandnot(bitset_container_t *src_1,
const run_container_t *src_2, void **dst) {
*dst = src_1;
for (int32_t rlepos = 0; rlepos < src_2->n_runs; ++rlepos) {
rle16_t rle = src_2->runs[rlepos];
bitset_reset_range(src_1->array, rle.value,
rle.value + rle.length + UINT32_C(1));
}
src_1->cardinality = bitset_container_compute_cardinality(src_1);
if (src_1->cardinality <= DEFAULT_MAX_SIZE) {
*dst = array_container_from_bitset(src_1);
bitset_container_free(src_1);
return false; // not bitset
} else
return true;
}
bool bitset_run_container_andnot(const bitset_container_t *src_1,
const run_container_t *src_2, void **dst) {
// follows Java implementation
bitset_container_t *result = bitset_container_create();
bitset_container_copy(src_1, result);
for (int32_t rlepos = 0; rlepos < src_2->n_runs; ++rlepos) {
rle16_t rle = src_2->runs[rlepos];
bitset_reset_range(result->array, rle.value,
rle.value + rle.length + UINT32_C(1));
}
result->cardinality = bitset_container_compute_cardinality(result);
if (result->cardinality <= DEFAULT_MAX_SIZE) {
*dst = array_container_from_bitset(result);
bitset_container_free(result);
return false; // not bitset
}
*dst = result;
return true; // bitset
}
/* Negation across a range of the container
* Compute the negation of src and write the result
* to *dst. A true return value indicates a bitset result,
* otherwise the result is an array container.
* We assume that dst is not pre-allocated. In
* case of failure, *dst will be NULL.
*/
bool bitset_container_negation_range(const bitset_container_t *src,
const int range_start, const int range_end,
void **dst) {
// TODO maybe consider density-based estimate
// and sometimes build result directly as array, with
// conversion back to bitset if wrong. Or determine
// actual result cardinality, then go directly for the known final cont.
// keep computation using bitsets as long as possible.
bitset_container_t *t = bitset_container_clone(src);
bitset_flip_range(t->array, (uint32_t)range_start, (uint32_t)range_end);
t->cardinality = bitset_container_compute_cardinality(t);
if (t->cardinality > DEFAULT_MAX_SIZE) {
*dst = t;
return true;
} else {
*dst = array_container_from_bitset(t);
bitset_container_free(t);
return false;
}
}
/* Compute the intersection of src_1 and src_2 and write the result to
* *dst. If the result is true then the result is a bitset_container_t
* otherwise is a array_container_t. */
bool run_bitset_container_intersection(const run_container_t *src_1,
const bitset_container_t *src_2,
void **dst) {
int32_t card = run_container_cardinality(src_1);
if (card <= DEFAULT_MAX_SIZE) {
// result can only be an array (assuming that we never make a
// RunContainer)
if (card > src_2->cardinality) {
card = src_2->cardinality;
}
array_container_t *answer = array_container_create_given_capacity(card);
*dst = answer;
if (*dst == NULL) {
return false;
}
for (int32_t rlepos = 0; rlepos < src_1->n_runs; ++rlepos) {
rle16_t rle = src_1->runs[rlepos];
uint32_t endofrun = (uint32_t)rle.value + rle.length;
for (uint32_t runValue = rle.value; runValue <= endofrun;
++runValue) {
if (bitset_container_contains(src_2, runValue)) {
answer->array[answer->cardinality++] = (uint16_t)runValue;
}
}
}
return false;
}
if (*dst == src_2) { // we attempt in-place
bitset_container_t *answer = (bitset_container_t *)*dst;
uint32_t start = 0;
for (int32_t rlepos = 0; rlepos < src_1->n_runs; ++rlepos) {
const rle16_t rle = src_1->runs[rlepos];
uint32_t end = rle.value;
bitset_reset_range(src_2->array, start, end);
start = end + rle.length + 1;
}
bitset_reset_range(src_2->array, start, UINT32_C(1) << 16);
answer->cardinality = bitset_container_compute_cardinality(answer);
if (src_2->cardinality > DEFAULT_MAX_SIZE) {
return true;
} else {
array_container_t *newanswer = array_container_from_bitset(src_2);
if (newanswer == NULL) {
*dst = NULL;
return false;
}
*dst = newanswer;
return false;
}
} else { // no inplace
// we expect the answer to be a bitmap (if we are lucky)
bitset_container_t *answer = bitset_container_clone(src_2);
*dst = answer;
if (answer == NULL) {
return true;
}
uint32_t start = 0;
for (int32_t rlepos = 0; rlepos < src_1->n_runs; ++rlepos) {
const rle16_t rle = src_1->runs[rlepos];
uint32_t end = rle.value;
bitset_reset_range(answer->array, start, end);
start = end + rle.length + 1;
}
bitset_reset_range(answer->array, start, UINT32_C(1) << 16);
answer->cardinality = bitset_container_compute_cardinality(answer);
if (answer->cardinality > DEFAULT_MAX_SIZE) {
return true;
} else {
array_container_t *newanswer = array_container_from_bitset(answer);
bitset_container_free(*dst);
if (newanswer == NULL) {
*dst = NULL;
return false;
}
*dst = newanswer;
return false;
}
}
}
int main() {
int repeat = 500;
int size = (1 << 16) / 3;
tellmeall();
printf("bitset container benchmarks\n");
bitset_container_t* B = bitset_container_create();
BEST_TIME(set_test(B), 0, repeat, size);
int answer = get_test(B);
size = 1 << 16;
BEST_TIME(get_test(B), answer, repeat, size);
BEST_TIME(bitset_container_cardinality(B), answer, repeat, 1);
BEST_TIME(bitset_container_compute_cardinality(B), answer, repeat,
BITSET_CONTAINER_SIZE_IN_WORDS);
size = (1 << 16) / 3;
BEST_TIME(unset_test(B), 0, repeat, size);
bitset_container_free(B);
for (int howmany = 4096; howmany <= (1 << 16); howmany *= 2) {
bitset_container_t* Bt = bitset_container_create();
while (bitset_container_cardinality(Bt) < howmany) {
bitset_container_set(Bt, (uint16_t)pcg32_random());
}
size_t nbrtestvalues = 1024;
uint16_t* testvalues = malloc(nbrtestvalues * sizeof(uint16_t));
printf("\n number of values in container = %d\n",
bitset_container_cardinality(Bt));
int card = bitset_container_cardinality(Bt);
uint32_t* out = malloc(sizeof(uint32_t) * (unsigned)card + 32);
BEST_TIME(bitset_container_to_uint32_array(out, Bt, 1234), card, repeat,
card);
free(out);
BEST_TIME_PRE_ARRAY(Bt, bitset_container_get, bitset_cache_prefetch,
testvalues, nbrtestvalues);
BEST_TIME_PRE_ARRAY(Bt, bitset_container_get, bitset_cache_flush,
testvalues, nbrtestvalues);
free(testvalues);
bitset_container_free(Bt);
}
printf("\n");
bitset_container_t* B1 = bitset_container_create();
for (int x = 0; x < 1 << 16; x += 3) {
bitset_container_set(B1, (uint16_t)x);
}
bitset_container_t* B2 = bitset_container_create();
for (int x = 0; x < 1 << 16; x += 5) {
bitset_container_set(B2, (uint16_t)x);
}
bitset_container_t* BO = bitset_container_create();
BEST_TIME(bitset_container_or_nocard(B1, B2, BO), -1, repeat,
BITSET_CONTAINER_SIZE_IN_WORDS);
answer = bitset_container_compute_cardinality(BO);
BEST_TIME(bitset_container_or(B1, B2, BO), answer, repeat,
BITSET_CONTAINER_SIZE_IN_WORDS);
BEST_TIME(bitset_container_cardinality(BO), answer, repeat, 1);
BEST_TIME(bitset_container_compute_cardinality(BO), answer, repeat,
BITSET_CONTAINER_SIZE_IN_WORDS);
BEST_TIME(bitset_container_and_nocard(B1, B2, BO), -1, repeat,
BITSET_CONTAINER_SIZE_IN_WORDS);
answer = bitset_container_compute_cardinality(BO);
BEST_TIME(bitset_container_and(B1, B2, BO), answer, repeat,
BITSET_CONTAINER_SIZE_IN_WORDS);
BEST_TIME(bitset_container_cardinality(BO), answer, repeat, 1);
BEST_TIME(bitset_container_compute_cardinality(BO), answer, repeat,
BITSET_CONTAINER_SIZE_IN_WORDS);
// next we are going to benchmark conversion from bitset to array (an
// important step)
bitset_container_clear(B1);
for (int k = 0; k < 4096; ++k) {
bitset_container_set(B1, (uint16_t)ranged_random(1 << 16));
}
answer = get_cardinality_through_conversion_to_array(B1);
BEST_TIME(get_cardinality_through_conversion_to_array(B1), answer, repeat,
BITSET_CONTAINER_SIZE_IN_WORDS);
bitset_container_free(BO);
bitset_container_free(B1);
bitset_container_free(B2);
return 0;
}
