static void test_for_size(size_t size)
{
struct ewah_bitmap *a = generate_bitmap(size);
struct ewah_bitmap *b = generate_bitmap(size);
struct ewah_bitmap *result = ewah_new();
size_t i;
struct {
const char *name;
void (*generate)(struct ewah_bitmap *, struct ewah_bitmap *, struct ewah_bitmap *);
size_t (*check)(size_t, size_t);
} tests[] = {
{"or", &ewah_or, &op_or},
{"xor", &ewah_xor, &op_xor},
{"and", &ewah_and, &op_and},
{"and-not", &ewah_and_not, &op_andnot}
};
for (i = 0; i < sizeof(tests)/sizeof(tests[0]); ++i) {
fprintf(stderr, "'%s' in %zu bits... ", tests[i].name, size);
tests[i].generate(a, b, result);
if (verify_operation(a, b, result, tests[i].check))
fprintf(stderr, "OK\n");
ewah_clear(result);
}
ewah_free(a);
ewah_free(b);
ewah_free(result);
}
int ewah_deserialize(struct ewah_bitmap *self, int fd)
{
size_t i;
eword_t dump[2048];
const size_t words_per_dump = sizeof(dump) / sizeof(eword_t);
uint32_t bitsize, word_count, rlw_pos;
eword_t *buffer = NULL;
size_t words_left;
ewah_clear(self);
/* 32 bit -- bit size for the map */
if (read(fd, &bitsize, 4) != 4)
return -1;
self->bit_size = (size_t)ntohl(bitsize);
/** 32 bit -- number of compressed 64-bit words */
if (read(fd, &word_count, 4) != 4)
return -1;
self->buffer_size = self->alloc_size = (size_t)ntohl(word_count);
self->buffer = ewah_realloc(self->buffer,
self->alloc_size * sizeof(eword_t));
if (!self->buffer)
return -1;
/** 64 bit x N -- compressed words */
buffer = self->buffer;
words_left = self->buffer_size;
while (words_left >= words_per_dump) {
if (read(fd, dump, sizeof(dump)) != sizeof(dump))
return -1;
for (i = 0; i < words_per_dump; ++i, ++buffer)
*buffer = ntohll(dump[i]);
words_left -= words_per_dump;
}
if (words_left) {
if (read(fd, dump, words_left * 8) != words_left * 8)
return -1;
for (i = 0; i < words_left; ++i, ++buffer)
*buffer = ntohll(dump[i]);
}
/** 32 bit -- position for the RLW */
if (read(fd, &rlw_pos, 4) != 4)
return -1;
self->rlw = self->buffer + ntohl(rlw_pos);
return 0;
}
struct ewah_bitmap *ewah_new(void)
{
struct ewah_bitmap *self;
self = xmalloc(sizeof(struct ewah_bitmap));
self->alloc_size = 32;
ALLOC_ARRAY(self->buffer, self->alloc_size);
ewah_clear(self);
return self;
}
void ewah_pool_free(struct ewah_bitmap *self)
{
if (self == NULL)
return;
if (bitmap_pool_size == BITMAP_POOL_MAX ||
self->alloc_size == 0) {
ewah_free(self);
return;
}
ewah_clear(self);
bitmap_pool[bitmap_pool_size++] = self;
}
