/* Negation across a range of container
* Compute the negation of src and write the result
* to *dst. Return values are the *_TYPECODES as defined * in containers.h
* We assume that dst is not pre-allocated. In
* case of failure, *dst will be NULL.
*/
int run_container_negation_range(const run_container_t *src,
const int range_start, const int range_end,
void **dst) {
uint8_t return_typecode;
// follows the Java implementation
if (range_end <= range_start) {
*dst = run_container_clone(src);
return RUN_CONTAINER_TYPE_CODE;
}
run_container_t *ans = run_container_create_given_capacity(
src->n_runs + 1); // src->n_runs + 1);
int k = 0;
for (; k < src->n_runs && src->runs[k].value < range_start; ++k) {
ans->runs[k] = src->runs[k];
ans->n_runs++;
}
run_container_smart_append_exclusive(
ans, (uint16_t)range_start, (uint16_t)(range_end - range_start - 1));
for (; k < src->n_runs; ++k) {
run_container_smart_append_exclusive(ans, src->runs[k].value,
src->runs[k].length);
}
*dst = convert_run_to_efficient_container(ans, &return_typecode);
if (return_typecode != RUN_CONTAINER_TYPE_CODE) run_container_free(ans);
return return_typecode;
}
bool run_bitset_container_iandnot(run_container_t *src_1,
const bitset_container_t *src_2, void **dst) {
// dummy implementation
bool ans = run_bitset_container_andnot(src_1, src_2, dst);
run_container_free(src_1);
return ans;
}
void and_or_test() {
run_container_t* B1 = run_container_create();
run_container_t* B2 = run_container_create();
run_container_t* BI = run_container_create();
run_container_t* BO = run_container_create();
run_container_t* TMP = run_container_create();
assert_non_null(B1);
assert_non_null(B2);
assert_non_null(BI);
assert_non_null(BO);
assert_non_null(TMP);
for (size_t x = 0; x < (1 << 16); x += 3) {
run_container_add(B1, x);
run_container_add(BI, x);
}
// important: 62 is not divisible by 3
for (size_t x = 0; x < (1 << 16); x += 62) {
run_container_add(B2, x);
run_container_add(BI, x);
}
for (size_t x = 0; x < (1 << 16); x += 62 * 3) {
run_container_add(BO, x);
}
run_container_intersection(B1, B2, TMP);
assert_true(run_container_equals(BO, TMP));
run_container_union(B1, B2, TMP);
assert_true(run_container_equals(BI, TMP));
run_container_free(B1);
run_container_free(B2);
run_container_free(BO);
run_container_free(BI);
run_container_free(TMP);
}
void add_contains_test() {
run_container_t* B = run_container_create();
assert_non_null(B);
int expected_card = 0;
for (size_t x = 0; x < 1 << 16; x += 3) {
assert_true(run_container_add(B, x));
assert_true(run_container_contains(B, x));
assert_int_equal(run_container_cardinality(B), ++expected_card);
assert_true(run_container_cardinality(B) <= B->capacity);
}
for (size_t x = 0; x < 1 << 16; x++) {
assert_int_equal(run_container_contains(B, x), (x / 3 * 3 == x));
}
assert_int_equal(run_container_cardinality(B), (1 << 16) / 3 + 1);
for (size_t x = 0; x < 1 << 16; x += 3) {
assert_true(run_container_contains(B, x));
assert_true(run_container_remove(B, x));
assert_int_equal(run_container_cardinality(B), --expected_card);
assert_false(run_container_contains(B, x));
}
assert_int_equal(run_container_cardinality(B), 0);
for (int x = 65535; x >= 0; x -= 3) {
assert_true(run_container_add(B, x));
assert_true(run_container_contains(B, x));
assert_int_equal(run_container_cardinality(B), ++expected_card);
assert_true(run_container_cardinality(B) <= B->capacity);
}
assert_int_equal(run_container_cardinality(B), (1 << 16) / 3 + 1);
for (size_t x = 0; x < 1 << 16; x++) {
assert_int_equal(run_container_contains(B, x), (x / 3 * 3 == x));
}
for (size_t x = 0; x < 1 << 16; x += 3) {
assert_true(run_container_contains(B, x));
assert_true(run_container_remove(B, x));
assert_int_equal(run_container_cardinality(B), --expected_card);
assert_false(run_container_contains(B, x));
}
run_container_free(B);
}
void printf_test() {
run_container_t* B = run_container_create();
assert_non_null(B);
run_container_add(B, 1);
run_container_add(B, 2);
run_container_add(B, 3);
run_container_add(B, 10);
run_container_add(B, 10000);
run_container_printf(B);
printf("\n");
run_container_free(B);
}
// returns 0 on error, 1 if ok.
void to_uint32_array_test() {
for (size_t offset = 1; offset < 128; offset *= 2) {
run_container_t* B = run_container_create();
assert_non_null(B);
for (int k = 0; k < (1 << 16); k += offset) {
run_container_add(B, k);
}
int card = run_container_cardinality(B);
uint32_t* out = malloc(sizeof(uint32_t) * card);
int nc = run_container_to_uint32_array(out, B, 0);
assert_int_equal(nc, card);
for (int k = 1; k < nc; ++k) {
assert_int_equal(out[k], offset + out[k - 1]);
}
free(out);
run_container_free(B);
}
}
int main() {
int repeat = 500;
int size = TESTSIZE;
tellmeall();
printf("run container benchmarks\n");
run_container_t* B = run_container_create();
BEST_TIME(add_test(B), 0, repeat, size);
int answer = contains_test(B);
size = 1 << 16;
BEST_TIME(contains_test(B), answer, repeat, size);
size = (1 << 16) / 3;
BEST_TIME(remove_test(B), 0, repeat, size);
run_container_free(B);
for (int howmany = 32; howmany <= (1 << 16); howmany *= 8) {
run_container_t* Bt = run_container_create();
for (int j = 0; j < howmany; ++j) {
run_container_add(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",
run_container_cardinality(Bt));
int card = run_container_cardinality(Bt);
uint32_t* out = malloc(sizeof(uint32_t) * (unsigned long)card);
BEST_TIME(run_container_to_uint32_array(out, Bt, 1234), card, repeat,
card);
free(out);
BEST_TIME_PRE_ARRAY(Bt, run_container_contains, run_cache_prefetch,
testvalues, nbrtestvalues);
BEST_TIME_PRE_ARRAY(Bt, run_container_contains, run_cache_flush,
testvalues, nbrtestvalues);
free(testvalues);
run_container_free(Bt);
}
printf("\n");
run_container_t* B1 = run_container_create();
for (int x = 0; x < 1 << 16; x += 3) {
run_container_add(B1, (uint16_t)x);
}
run_container_t* B2 = run_container_create();
for (int x = 0; x < 1 << 16; x += 5) {
run_container_add(B2, (uint16_t)x);
}
int32_t inputsize;
inputsize = B1->n_runs + B2->n_runs;
run_container_t* BO = run_container_create();
printf("\nUnion and intersections...\n");
printf("\nNote:\n");
printf(
"union times are expressed in cycles per number of input elements "
"(both runs)\n");
printf(
"intersection times are expressed in cycles per number of output "
"elements\n\n");
printf("==intersection and union test 1 \n");
printf("input 1 cardinality = %d, input 2 cardinality = %d \n",
run_container_cardinality(B1), run_container_cardinality(B2));
answer = union_test(B1, B2, BO);
printf("union cardinality = %d \n", answer);
printf("B1 card = %d B2 card = %d \n", run_container_cardinality(B1),
run_container_cardinality(B2));
inputsize = B1->n_runs + B2->n_runs;
BEST_TIME(union_test(B1, B2, BO), answer, repeat, inputsize);
answer = intersection_test(B1, B2, BO);
printf("intersection cardinality = %d \n", answer);
BEST_TIME(intersection_test(B1, B2, BO), answer, repeat, answer);
printf("==intersection and union test 2 \n");
run_container_clear(B1);
run_container_clear(B2);
for (int x = 0; x < (1 << 16); x += 64) {
int length = x % 11;
for (int y = 0; y < length; ++y)
run_container_add(B1, (uint16_t)(x + y));
}
for (int x = 1; x < 1 << 16; x += x) {
run_container_add(B2, (uint16_t)x);
}
printf("input 1 cardinality = %d, input 2 cardinality = %d \n",
run_container_cardinality(B1), run_container_cardinality(B2));
answer = union_test(B1, B2, BO);
printf("union cardinality = %d \n", answer);
printf("B1 card = %d B2 card = %d \n", run_container_cardinality(B1),
run_container_cardinality(B2));
inputsize = B1->n_runs + B2->n_runs;
BEST_TIME(union_test(B1, B2, BO), answer, repeat, inputsize);
answer = intersection_test(B1, B2, BO);
printf("intersection cardinality = %d \n", answer);
BEST_TIME(intersection_test(B1, B2, BO), answer, repeat, answer);
run_container_free(B1);
run_container_free(B2);
run_container_free(BO);
return 0;
}
int run_array_container_andnot(const run_container_t *src_1,
const array_container_t *src_2, void **dst) {
// follows the Java impl as of June 2016
int card = run_container_cardinality(src_1);
const int arbitrary_threshold = 32;
if (card <= arbitrary_threshold) {
if (src_2->cardinality == 0) {
*dst = run_container_clone(src_1);
return RUN_CONTAINER_TYPE_CODE;
}
// Java's "lazyandNot.toEfficientContainer" thing
run_container_t *answer = run_container_create_given_capacity(
card + array_container_cardinality(src_2));
int rlepos = 0;
int xrlepos = 0; // "x" is src_2
rle16_t rle = src_1->runs[rlepos];
int32_t start = rle.value;
int32_t end = start + rle.length + 1;
int32_t xstart = src_2->array[xrlepos];
while ((rlepos < src_1->n_runs) && (xrlepos < src_2->cardinality)) {
if (end <= xstart) {
// output the first run
answer->runs[answer->n_runs++] =
(rle16_t){.value = (uint16_t)start,
.length = (uint16_t)(end - start - 1)};
rlepos++;
if (rlepos < src_1->n_runs) {
start = src_1->runs[rlepos].value;
end = start + src_1->runs[rlepos].length + 1;
}
} else if (xstart + 1 <= start) {
// exit the second run
xrlepos++;
if (xrlepos < src_2->cardinality) {
xstart = src_2->array[xrlepos];
}
} else {
if (start < xstart) {
answer->runs[answer->n_runs++] =
(rle16_t){.value = (uint16_t)start,
.length = (uint16_t)(xstart - start - 1)};
}
if (xstart + 1 < end) {
start = xstart + 1;
} else {
rlepos++;
if (rlepos < src_1->n_runs) {
start = src_1->runs[rlepos].value;
end = start + src_1->runs[rlepos].length + 1;
}
}
}
}
if (rlepos < src_1->n_runs) {
answer->runs[answer->n_runs++] =
(rle16_t){.value = (uint16_t)start,
.length = (uint16_t)(end - start - 1)};
rlepos++;
if (rlepos < src_1->n_runs) {
memcpy(answer->runs + answer->n_runs, src_1->runs + rlepos,
(src_1->n_runs - rlepos) * sizeof(rle16_t));
answer->n_runs += (src_1->n_runs - rlepos);
}
}
uint8_t return_type;
*dst = convert_run_to_efficient_container(answer, &return_type);
if (answer != *dst) run_container_free(answer);
return return_type;
}
/*
* Same as run_container_negation except that if the output is to
* be a
* run_container_t, and has the capacity to hold the result,
* then src is modified and no allocation is made.
* In all cases, the result is in *dst.
*/
int run_container_negation_range_inplace(run_container_t *src,
const int range_start,
const int range_end, void **dst) {
uint8_t return_typecode;
if (range_end <= range_start) {
*dst = src;
return RUN_CONTAINER_TYPE_CODE;
}
// TODO: efficient special case when range is 0 to 65535 inclusive
if (src->capacity == src->n_runs) {
// no excess room. More checking to see if result can fit
bool last_val_before_range = false;
bool first_val_in_range = false;
bool last_val_in_range = false;
bool first_val_past_range = false;
if (range_start > 0)
last_val_before_range =
run_container_contains(src, (uint16_t)(range_start - 1));
first_val_in_range = run_container_contains(src, (uint16_t)range_start);
if (last_val_before_range == first_val_in_range) {
last_val_in_range =
run_container_contains(src, (uint16_t)(range_end - 1));
if (range_end != 0x10000)
first_val_past_range =
run_container_contains(src, (uint16_t)range_end);
if (last_val_in_range ==
first_val_past_range) { // no space for inplace
int ans = run_container_negation_range(src, range_start,
range_end, dst);
run_container_free(src);
return ans;
}
}
}
// all other cases: result will fit
run_container_t *ans = src;
int my_nbr_runs = src->n_runs;
ans->n_runs = 0;
int k = 0;
for (; (k < my_nbr_runs) && (src->runs[k].value < range_start); ++k) {
// ans->runs[k] = src->runs[k]; (would be self-copy)
ans->n_runs++;
}
// as with Java implementation, use locals to give self a buffer of depth 1
rle16_t buffered = (rle16_t){.value = (uint16_t)0, .length = (uint16_t)0};
rle16_t next = buffered;
if (k < my_nbr_runs) buffered = src->runs[k];
run_container_smart_append_exclusive(
ans, (uint16_t)range_start, (uint16_t)(range_end - range_start - 1));
for (; k < my_nbr_runs; ++k) {
if (k + 1 < my_nbr_runs) next = src->runs[k + 1];
run_container_smart_append_exclusive(ans, buffered.value,
buffered.length);
buffered = next;
}
*dst = convert_run_to_efficient_container(ans, &return_typecode);
if (return_typecode != RUN_CONTAINER_TYPE_CODE) run_container_free(ans);
return return_typecode;
}
