Jeff King <p...@peff.net> writes:

> From: Vicent Marti <tan...@gmail.com>
>
> EWAH is a word-aligned compressed variant of a bitset (i.e. a data
> structure that acts as a 0-indexed boolean array for many entries).

I think I've already pointed out some when the original series was
posted, but this does not seem to compile with -Wdecl-after-stmt
(possibly other violations may exist; I haven't looked very closely
yet).

>
> It uses a 64-bit run-length encoding (RLE) compression scheme,
> trading some compression for better processing speed.
>
> The goal of this word-aligned implementation is not to achieve
> the best compression, but rather to improve query processing time.
> As it stands right now, this EWAH implementation will always be more
> efficient storage-wise than its uncompressed alternative.
>
> EWAH arrays will be used as the on-disk format to store reachability
> bitmaps for all objects in a repository while keeping reasonable sizes,
> in the same way that JGit does.
>
> This EWAH implementation is a mostly straightforward port of the
> original `javaewah` library that JGit currently uses. The library is
> self-contained and has been embedded whole (4 files) inside the `ewah`
> folder to ease redistribution.
>
> The library is re-licensed under the GPLv2 with the permission of Daniel
> Lemire, the original author. The source code for the C version can
> be found on GitHub:
>
>       https://github.com/vmg/libewok
>
> The original Java implementation can also be found on GitHub:
>
>       https://github.com/lemire/javaewah
>
> Signed-off-by: Vicent Marti <tan...@gmail.com>
> Signed-off-by: Jeff King <p...@peff.net>
> ---
>  Makefile           |   6 +
>  ewah/bitmap.c      | 226 +++++++++++++++++
>  ewah/ewah_bitmap.c | 701 
> +++++++++++++++++++++++++++++++++++++++++++++++++++++
>  ewah/ewah_io.c     | 192 +++++++++++++++
>  ewah/ewah_rlw.c    | 120 +++++++++
>  ewah/ewok.h        | 223 +++++++++++++++++
>  ewah/ewok_rlw.h    | 114 +++++++++
>  7 files changed, 1582 insertions(+)
>  create mode 100644 ewah/bitmap.c
>  create mode 100644 ewah/ewah_bitmap.c
>  create mode 100644 ewah/ewah_io.c
>  create mode 100644 ewah/ewah_rlw.c
>  create mode 100644 ewah/ewok.h
>  create mode 100644 ewah/ewok_rlw.h
>
> diff --git a/Makefile b/Makefile
> index 48ff0bd..eacb940 100644
> --- a/Makefile
> +++ b/Makefile
> @@ -667,6 +667,8 @@ LIB_H += diff.h
>  LIB_H += diffcore.h
>  LIB_H += dir.h
>  LIB_H += exec_cmd.h
> +LIB_H += ewah/ewok.h
> +LIB_H += ewah/ewok_rlw.h
>  LIB_H += fetch-pack.h
>  LIB_H += fmt-merge-msg.h
>  LIB_H += fsck.h
> @@ -800,6 +802,10 @@ LIB_OBJS += dir.o
>  LIB_OBJS += editor.o
>  LIB_OBJS += entry.o
>  LIB_OBJS += environment.o
> +LIB_OBJS += ewah/bitmap.o
> +LIB_OBJS += ewah/ewah_bitmap.o
> +LIB_OBJS += ewah/ewah_io.o
> +LIB_OBJS += ewah/ewah_rlw.o
>  LIB_OBJS += exec_cmd.o
>  LIB_OBJS += fetch-pack.o
>  LIB_OBJS += fsck.o
> diff --git a/ewah/bitmap.c b/ewah/bitmap.c
> new file mode 100644
> index 0000000..d248577
> --- /dev/null
> +++ b/ewah/bitmap.c
> @@ -0,0 +1,226 @@
> +/**
> + * Copyright 2013, GitHub, Inc
> + * Copyright 2009-2013, Daniel Lemire, Cliff Moon,
> + *   David McIntosh, Robert Becho, Google Inc. and Veronika Zenz
> + *
> + * 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., 51 Franklin Street, Fifth Floor, Boston, MA  
> 02110-1301, USA.
> + */
> +#include <assert.h>
> +#include <stdlib.h>
> +#include <string.h>
> +
> +#include "ewok.h"
> +
> +#define MASK(x) ((eword_t)1 << (x % BITS_IN_WORD))
> +#define BLOCK(x) (x / BITS_IN_WORD)
> +
> +struct bitmap *bitmap_new(void)
> +{
> +     struct bitmap *bitmap = ewah_malloc(sizeof(struct bitmap));
> +     bitmap->words = ewah_calloc(32, sizeof(eword_t));
> +     bitmap->word_alloc = 32;
> +     return bitmap;
> +}
> +
> +void bitmap_set(struct bitmap *self, size_t pos)
> +{
> +     size_t block = BLOCK(pos);
> +
> +     if (block >= self->word_alloc) {
> +             size_t old_size = self->word_alloc;
> +             self->word_alloc = block * 2;
> +             self->words = ewah_realloc(self->words, self->word_alloc * 
> sizeof(eword_t));
> +
> +             memset(self->words + old_size, 0x0,
> +                     (self->word_alloc - old_size) * sizeof(eword_t));
> +     }
> +
> +     self->words[block] |= MASK(pos);
> +}
> +
> +void bitmap_clear(struct bitmap *self, size_t pos)
> +{
> +     size_t block = BLOCK(pos);
> +
> +     if (block < self->word_alloc)
> +             self->words[block] &= ~MASK(pos);
> +}
> +
> +int bitmap_get(struct bitmap *self, size_t pos)
> +{
> +     size_t block = BLOCK(pos);
> +     return block < self->word_alloc && (self->words[block] & MASK(pos)) != 
> 0;
> +}
> +
> +struct ewah_bitmap *bitmap_to_ewah(struct bitmap *bitmap)
> +{
> +     struct ewah_bitmap *ewah = ewah_new();
> +     size_t i, running_empty_words = 0;
> +     eword_t last_word = 0;
> +
> +     for (i = 0; i < bitmap->word_alloc; ++i) {
> +             if (bitmap->words[i] == 0) {
> +                     running_empty_words++;
> +                     continue;
> +             }
> +
> +             if (last_word != 0) {
> +                     ewah_add(ewah, last_word);
> +             }
> +
> +             if (running_empty_words > 0) {
> +                     ewah_add_empty_words(ewah, 0, running_empty_words);
> +                     running_empty_words = 0;
> +             }
> +
> +             last_word = bitmap->words[i];
> +     }
> +
> +     ewah_add(ewah, last_word);
> +     return ewah;
> +}
> +
> +struct bitmap *ewah_to_bitmap(struct ewah_bitmap *ewah)
> +{
> +     struct bitmap *bitmap = bitmap_new();
> +     struct ewah_iterator it;
> +     eword_t blowup;
> +     size_t i = 0;
> +
> +     ewah_iterator_init(&it, ewah);
> +
> +     while (ewah_iterator_next(&blowup, &it)) {
> +             if (i >= bitmap->word_alloc) {
> +                     bitmap->word_alloc *= 1.5;
> +                     bitmap->words = ewah_realloc(
> +                             bitmap->words, bitmap->word_alloc * 
> sizeof(eword_t));
> +             }
> +
> +             bitmap->words[i++] = blowup;
> +     }
> +
> +     bitmap->word_alloc = i;
> +     return bitmap;
> +}
> +
> +void bitmap_and_not(struct bitmap *self, struct bitmap *other)
> +{
> +     const size_t count = (self->word_alloc < other->word_alloc) ?
> +             self->word_alloc : other->word_alloc;
> +
> +     size_t i;
> +
> +     for (i = 0; i < count; ++i) {
> +             self->words[i] &= ~other->words[i];
> +     }
> +}
> +
> +void bitmap_or_ewah(struct bitmap *self, struct ewah_bitmap *other)
> +{
> +     size_t original_size = self->word_alloc;
> +     size_t other_final = (other->bit_size / BITS_IN_WORD) + 1;
> +     size_t i = 0;
> +     struct ewah_iterator it;
> +     eword_t word;
> +
> +     if (self->word_alloc < other_final) {
> +             self->word_alloc = other_final;
> +             self->words = ewah_realloc(self->words, self->word_alloc * 
> sizeof(eword_t));
> +             memset(self->words + original_size, 0x0,
> +                     (self->word_alloc - original_size) * sizeof(eword_t));
> +     }
> +
> +     ewah_iterator_init(&it, other);
> +
> +     while (ewah_iterator_next(&word, &it)) {
> +             self->words[i++] |= word;
> +     }
> +}
> +
> +void bitmap_each_bit(struct bitmap *self, ewah_callback callback, void *data)
> +{
> +     size_t pos = 0, i;
> +
> +     for (i = 0; i < self->word_alloc; ++i) {
> +             eword_t word = self->words[i];
> +             uint32_t offset;
> +
> +             if (word == (eword_t)~0) {
> +                     for (offset = 0; offset < BITS_IN_WORD; ++offset) {
> +                             callback(pos++, data);
> +                     }
> +             } else {
> +                     for (offset = 0; offset < BITS_IN_WORD; ++offset) {
> +                             if ((word >> offset) == 0)
> +                                     break;
> +
> +                             offset += ewah_bit_ctz64(word >> offset);
> +                             callback(pos + offset, data);
> +                     }
> +                     pos += BITS_IN_WORD;
> +             }
> +     }
> +}
> +
> +size_t bitmap_popcount(struct bitmap *self)
> +{
> +     size_t i, count = 0;
> +
> +     for (i = 0; i < self->word_alloc; ++i) {
> +             count += ewah_bit_popcount64(self->words[i]);
> +     }
> +
> +     return count;
> +}
> +
> +int bitmap_equals(struct bitmap *self, struct bitmap *other)
> +{
> +     struct bitmap *big, *small;
> +     size_t i;
> +
> +     if (self->word_alloc < other->word_alloc) {
> +             small = self;
> +             big = other;
> +     } else {
> +             small = other;
> +             big = self;
> +     }
> +
> +     for (i = 0; i < small->word_alloc; ++i) {
> +             if (small->words[i] != big->words[i])
> +                     return 0;
> +     }
> +
> +     for (; i < big->word_alloc; ++i) {
> +             if (big->words[i] != 0)
> +                     return 0;
> +     }
> +
> +     return 1;
> +}
> +
> +void bitmap_reset(struct bitmap *bitmap)
> +{
> +     memset(bitmap->words, 0x0, bitmap->word_alloc * sizeof(eword_t));
> +}
> +
> +void bitmap_free(struct bitmap *bitmap)
> +{
> +     if (bitmap == NULL)
> +             return;
> +
> +     free(bitmap->words);
> +     free(bitmap);
> +}
> diff --git a/ewah/ewah_bitmap.c b/ewah/ewah_bitmap.c
> new file mode 100644
> index 0000000..b74a1eb
> --- /dev/null
> +++ b/ewah/ewah_bitmap.c
> @@ -0,0 +1,701 @@
> +/**
> + * Copyright 2013, GitHub, Inc
> + * Copyright 2009-2013, Daniel Lemire, Cliff Moon,
> + *   David McIntosh, Robert Becho, Google Inc. and Veronika Zenz
> + *
> + * 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., 51 Franklin Street, Fifth Floor, Boston, MA  
> 02110-1301, USA.
> + */
> +#include <assert.h>
> +#include <stdlib.h>
> +#include <unistd.h>
> +#include <string.h>
> +#include <stdio.h>
> +
> +#include "ewok.h"
> +#include "ewok_rlw.h"
> +
> +static inline size_t min_size(size_t a, size_t b)
> +{
> +     return a < b ? a : b;
> +}
> +
> +static inline size_t max_size(size_t a, size_t b)
> +{
> +     return a > b ? a : b;
> +}
> +
> +static inline void buffer_grow(struct ewah_bitmap *self, size_t new_size)
> +{
> +     size_t rlw_offset = (uint8_t *)self->rlw - (uint8_t *)self->buffer;
> +
> +     if (self->alloc_size >= new_size)
> +             return;
> +
> +     self->alloc_size = new_size;
> +     self->buffer = ewah_realloc(self->buffer, self->alloc_size * 
> sizeof(eword_t));
> +     self->rlw = self->buffer + (rlw_offset / sizeof(size_t));
> +}
> +
> +static inline void buffer_push(struct ewah_bitmap *self, eword_t value)
> +{
> +     if (self->buffer_size + 1 >= self->alloc_size) {
> +             buffer_grow(self, self->buffer_size * 3 / 2);
> +     }
> +
> +     self->buffer[self->buffer_size++] = value;
> +}
> +
> +static void buffer_push_rlw(struct ewah_bitmap *self, eword_t value)
> +{
> +     buffer_push(self, value);
> +     self->rlw = self->buffer + self->buffer_size - 1;
> +}
> +
> +static size_t add_empty_words(struct ewah_bitmap *self, int v, size_t number)
> +{
> +     size_t added = 0;
> +
> +     if (rlw_get_run_bit(self->rlw) != v && rlw_size(self->rlw) == 0) {
> +             rlw_set_run_bit(self->rlw, v);
> +     }
> +     else if (rlw_get_literal_words(self->rlw) != 0 || 
> rlw_get_run_bit(self->rlw) != v) {
> +             buffer_push_rlw(self, 0);
> +             if (v) rlw_set_run_bit(self->rlw, v);
> +             added++;
> +     }
> +
> +     eword_t runlen = rlw_get_running_len(self->rlw);
> +     eword_t can_add = min_size(number, RLW_LARGEST_RUNNING_COUNT - runlen);
> +
> +     rlw_set_running_len(self->rlw, runlen + can_add);
> +     number -= can_add;
> +
> +     while (number >= RLW_LARGEST_RUNNING_COUNT) {
> +             buffer_push_rlw(self, 0);
> +             added++;
> +
> +             if (v) rlw_set_run_bit(self->rlw, v);
> +             rlw_set_running_len(self->rlw, RLW_LARGEST_RUNNING_COUNT);
> +
> +             number -= RLW_LARGEST_RUNNING_COUNT;
> +     }
> +
> +     if (number > 0) {
> +             buffer_push_rlw(self, 0);
> +             added++;
> +
> +             if (v) rlw_set_run_bit(self->rlw, v);
> +             rlw_set_running_len(self->rlw, number);
> +     }
> +
> +     return added;
> +}
> +
> +size_t ewah_add_empty_words(struct ewah_bitmap *self, int v, size_t number)
> +{
> +     if (number == 0)
> +             return 0;
> +
> +     self->bit_size += number * BITS_IN_WORD;
> +     return add_empty_words(self, v, number);
> +}
> +
> +static size_t add_literal(struct ewah_bitmap *self, eword_t new_data)
> +{
> +     eword_t current_num = rlw_get_literal_words(self->rlw);
> +
> +     if (current_num >= RLW_LARGEST_LITERAL_COUNT) {
> +             buffer_push_rlw(self, 0);
> +
> +             rlw_set_literal_words(self->rlw, 1);
> +             buffer_push(self, new_data);
> +             return 2;
> +     }
> +
> +     rlw_set_literal_words(self->rlw, current_num + 1);
> +
> +     /* sanity check */
> +     assert(rlw_get_literal_words(self->rlw) == current_num + 1);
> +
> +     buffer_push(self, new_data);
> +     return 1;
> +}
> +
> +void ewah_add_dirty_words(
> +     struct ewah_bitmap *self, const eword_t *buffer, size_t number, int 
> negate)
> +{
> +     size_t literals, can_add;
> +
> +     while (1) {
> +             literals = rlw_get_literal_words(self->rlw);
> +             can_add = min_size(number, RLW_LARGEST_LITERAL_COUNT - 
> literals);
> +
> +             rlw_set_literal_words(self->rlw, literals + can_add);
> +
> +             if (self->buffer_size + can_add >= self->alloc_size) {
> +                     buffer_grow(self, (self->buffer_size + can_add) * 3 / 
> 2);
> +             }
> +
> +             if (negate) {
> +                     size_t i;
> +                     for (i = 0; i < can_add; ++i)
> +                             self->buffer[self->buffer_size++] = ~buffer[i];
> +             } else {
> +                     memcpy(self->buffer + self->buffer_size, buffer, 
> can_add * sizeof(eword_t));
> +                     self->buffer_size += can_add;
> +             }
> +
> +             self->bit_size += can_add * BITS_IN_WORD;
> +
> +             if (number - can_add == 0)
> +                     break;
> +
> +             buffer_push_rlw(self, 0);
> +             buffer += can_add;
> +             number -= can_add;
> +     }
> +}
> +
> +static size_t add_empty_word(struct ewah_bitmap *self, int v)
> +{
> +     int no_literal = (rlw_get_literal_words(self->rlw) == 0);
> +     eword_t run_len = rlw_get_running_len(self->rlw);
> +
> +     if (no_literal && run_len == 0) {
> +             rlw_set_run_bit(self->rlw, v);
> +             assert(rlw_get_run_bit(self->rlw) == v);
> +     }
> +
> +     if (no_literal && rlw_get_run_bit(self->rlw) == v &&
> +             run_len < RLW_LARGEST_RUNNING_COUNT) {
> +             rlw_set_running_len(self->rlw, run_len + 1);
> +             assert(rlw_get_running_len(self->rlw) == run_len + 1);
> +             return 0;
> +     }
> +
> +     else {
> +             buffer_push_rlw(self, 0);
> +
> +             assert(rlw_get_running_len(self->rlw) == 0);
> +             assert(rlw_get_run_bit(self->rlw) == 0);
> +             assert(rlw_get_literal_words(self->rlw) == 0);
> +
> +             rlw_set_run_bit(self->rlw, v);
> +             assert(rlw_get_run_bit(self->rlw) == v);
> +
> +             rlw_set_running_len(self->rlw, 1);
> +             assert(rlw_get_running_len(self->rlw) == 1);
> +             assert(rlw_get_literal_words(self->rlw) == 0);
> +             return 1;
> +     }
> +}
> +
> +size_t ewah_add(struct ewah_bitmap *self, eword_t word)
> +{
> +     self->bit_size += BITS_IN_WORD;
> +
> +     if (word == 0)
> +             return add_empty_word(self, 0);
> +
> +     if (word == (eword_t)(~0))
> +             return add_empty_word(self, 1);
> +
> +     return add_literal(self, word);
> +}
> +
> +void ewah_set(struct ewah_bitmap *self, size_t i)
> +{
> +     const size_t dist =
> +             (i + BITS_IN_WORD) / BITS_IN_WORD -
> +             (self->bit_size + BITS_IN_WORD - 1) / BITS_IN_WORD;
> +
> +     assert(i >= self->bit_size);
> +
> +     self->bit_size = i + 1;
> +
> +     if (dist > 0) {
> +             if (dist > 1)
> +                     add_empty_words(self, 0, dist - 1);
> +
> +             add_literal(self, (eword_t)1 << (i % BITS_IN_WORD));
> +             return;
> +     }
> +
> +     if (rlw_get_literal_words(self->rlw) == 0) {
> +             rlw_set_running_len(self->rlw, rlw_get_running_len(self->rlw) - 
> 1);
> +             add_literal(self, (eword_t)1 << (i % BITS_IN_WORD));
> +             return;
> +     }
> +
> +     self->buffer[self->buffer_size - 1] |= ((eword_t)1 << (i % 
> BITS_IN_WORD));
> +
> +     /* check if we just completed a stream of 1s */
> +     if (self->buffer[self->buffer_size - 1] == (eword_t)(~0)) {
> +             self->buffer[--self->buffer_size] = 0;
> +             rlw_set_literal_words(self->rlw, 
> rlw_get_literal_words(self->rlw) - 1);
> +             add_empty_word(self, 1);
> +     }
> +}
> +
> +void ewah_each_bit(struct ewah_bitmap *self, void (*callback)(size_t, 
> void*), void *payload)
> +{
> +     size_t pos = 0;
> +     size_t pointer = 0;
> +     size_t k;
> +
> +     while (pointer < self->buffer_size) {
> +             eword_t *word = &self->buffer[pointer];
> +
> +             if (rlw_get_run_bit(word)) {
> +                     size_t len = rlw_get_running_len(word) * BITS_IN_WORD;
> +                     for (k = 0; k < len; ++k, ++pos) {
> +                             callback(pos, payload);
> +                     }
> +             } else {
> +                     pos += rlw_get_running_len(word) * BITS_IN_WORD;
> +             }
> +
> +             ++pointer;
> +
> +             for (k = 0; k < rlw_get_literal_words(word); ++k) {
> +                     int c;
> +
> +                     /* todo: zero count optimization */
> +                     for (c = 0; c < BITS_IN_WORD; ++c, ++pos) {
> +                             if ((self->buffer[pointer] & ((eword_t)1 << c)) 
> != 0) {
> +                                     callback(pos, payload);
> +                             }
> +                     }
> +
> +                     ++pointer;
> +             }
> +     }
> +}
> +
> +struct ewah_bitmap *ewah_new(void)
> +{
> +     struct ewah_bitmap *self;
> +
> +     self = ewah_malloc(sizeof(struct ewah_bitmap));
> +     if (self == NULL)
> +             return NULL;
> +
> +     self->buffer = ewah_malloc(32 * sizeof(eword_t));
> +     self->alloc_size = 32;
> +
> +     ewah_clear(self);
> +     return self;
> +}
> +
> +void ewah_clear(struct ewah_bitmap *self)
> +{
> +     self->buffer_size = 1;
> +     self->buffer[0] = 0;
> +     self->bit_size = 0;
> +     self->rlw = self->buffer;
> +}
> +
> +void ewah_free(struct ewah_bitmap *self)
> +{
> +     if (self->alloc_size)
> +             free(self->buffer);
> +
> +     free(self);
> +}
> +
> +static void read_new_rlw(struct ewah_iterator *it)
> +{
> +     const eword_t *word = NULL;
> +
> +     it->literals = 0;
> +     it->compressed = 0;
> +
> +     while (1) {
> +             word = &it->buffer[it->pointer];
> +
> +             it->rl = rlw_get_running_len(word);
> +             it->lw = rlw_get_literal_words(word);
> +             it->b = rlw_get_run_bit(word);
> +
> +             if (it->rl || it->lw)
> +                     return;
> +
> +             if (it->pointer < it->buffer_size - 1) {
> +                     it->pointer++;
> +             } else {
> +                     it->pointer = it->buffer_size;
> +                     return;
> +             }
> +     }
> +}
> +
> +int ewah_iterator_next(eword_t *next, struct ewah_iterator *it)
> +{
> +     if (it->pointer >= it->buffer_size)
> +             return 0;
> +
> +     if (it->compressed < it->rl) {
> +             it->compressed++;
> +             *next = it->b ? (eword_t)(~0) : 0;
> +     } else {
> +             assert(it->literals < it->lw);
> +
> +             it->literals++;
> +             it->pointer++;
> +
> +             assert(it->pointer < it->buffer_size);
> +
> +             *next = it->buffer[it->pointer];
> +     }
> +
> +     if (it->compressed == it->rl && it->literals == it->lw) {
> +             if (++it->pointer < it->buffer_size)
> +                     read_new_rlw(it);
> +     }
> +
> +     return 1;
> +}
> +
> +void ewah_iterator_init(struct ewah_iterator *it, struct ewah_bitmap *parent)
> +{
> +     it->buffer = parent->buffer;
> +     it->buffer_size = parent->buffer_size;
> +     it->pointer = 0;
> +
> +     it->lw = 0;
> +     it->rl = 0;
> +     it->compressed = 0;
> +     it->literals = 0;
> +     it->b = 0;
> +
> +     if (it->pointer < it->buffer_size)
> +             read_new_rlw(it);
> +}
> +
> +void ewah_dump(struct ewah_bitmap *self)
> +{
> +     size_t i;
> +     fprintf(stderr, "%zu bits | %zu words | ", self->bit_size, 
> self->buffer_size);
> +
> +     for (i = 0; i < self->buffer_size; ++i)
> +             fprintf(stderr, "%016llx ", (unsigned long 
> long)self->buffer[i]);
> +
> +     fprintf(stderr, "\n");
> +}
> +
> +void ewah_not(struct ewah_bitmap *self)
> +{
> +     size_t pointer = 0;
> +
> +     while (pointer < self->buffer_size) {
> +             eword_t *word = &self->buffer[pointer];
> +             size_t literals, k;
> +
> +             rlw_xor_run_bit(word);
> +             ++pointer;
> +
> +             literals = rlw_get_literal_words(word);
> +             for (k = 0; k < literals; ++k) {
> +                     self->buffer[pointer] = ~self->buffer[pointer];
> +                     ++pointer;
> +             }
> +     }
> +}
> +
> +void ewah_xor(
> +     struct ewah_bitmap *ewah_i,
> +     struct ewah_bitmap *ewah_j,
> +     struct ewah_bitmap *out)
> +{
> +     struct rlw_iterator rlw_i;
> +     struct rlw_iterator rlw_j;
> +
> +     rlwit_init(&rlw_i, ewah_i);
> +     rlwit_init(&rlw_j, ewah_j);
> +
> +     while (rlwit_word_size(&rlw_i) > 0 && rlwit_word_size(&rlw_j) > 0) {
> +             while (rlw_i.rlw.running_len > 0 || rlw_j.rlw.running_len > 0) {
> +                     struct rlw_iterator *prey, *predator;
> +                     size_t index;
> +                     int negate_words;
> +
> +                     if (rlw_i.rlw.running_len < rlw_j.rlw.running_len) {
> +                             prey = &rlw_i;
> +                             predator = &rlw_j;
> +                     } else {
> +                             prey = &rlw_j;
> +                             predator = &rlw_i;
> +                     }
> +
> +                     negate_words = !!predator->rlw.running_bit;
> +                     index = rlwit_discharge(prey, out, 
> predator->rlw.running_len, negate_words);
> +
> +                     ewah_add_empty_words(out, negate_words, 
> predator->rlw.running_len - index);
> +                     rlwit_discard_first_words(predator, 
> predator->rlw.running_len);
> +             }
> +
> +             size_t literals = min_size(rlw_i.rlw.literal_words, 
> rlw_j.rlw.literal_words);
> +
> +             if (literals) {
> +                     size_t k;
> +
> +                     for (k = 0; k < literals; ++k) {
> +                             ewah_add(out,
> +                                     rlw_i.buffer[rlw_i.literal_word_start + 
> k] ^
> +                                     rlw_j.buffer[rlw_j.literal_word_start + 
> k]
> +                             );
> +                     }
> +
> +                     rlwit_discard_first_words(&rlw_i, literals);
> +                     rlwit_discard_first_words(&rlw_j, literals);
> +             }
> +     }
> +
> +     if (rlwit_word_size(&rlw_i) > 0) {
> +             rlwit_discharge(&rlw_i, out, ~0, 0);
> +     } else {
> +             rlwit_discharge(&rlw_j, out, ~0, 0);
> +     }
> +
> +     out->bit_size = max_size(ewah_i->bit_size, ewah_j->bit_size);
> +}
> +
> +void ewah_and(
> +     struct ewah_bitmap *ewah_i,
> +     struct ewah_bitmap *ewah_j,
> +     struct ewah_bitmap *out)
> +{
> +     struct rlw_iterator rlw_i;
> +     struct rlw_iterator rlw_j;
> +
> +     rlwit_init(&rlw_i, ewah_i);
> +     rlwit_init(&rlw_j, ewah_j);
> +
> +     while (rlwit_word_size(&rlw_i) > 0 && rlwit_word_size(&rlw_j) > 0) {
> +             while (rlw_i.rlw.running_len > 0 || rlw_j.rlw.running_len > 0) {
> +                     struct rlw_iterator *prey, *predator;
> +
> +                     if (rlw_i.rlw.running_len < rlw_j.rlw.running_len) {
> +                             prey = &rlw_i;
> +                             predator = &rlw_j;
> +                     } else {
> +                             prey = &rlw_j;
> +                             predator = &rlw_i;
> +                     }
> +
> +                     if (predator->rlw.running_bit == 0) {
> +                             ewah_add_empty_words(out, 0, 
> predator->rlw.running_len);
> +                             rlwit_discard_first_words(prey, 
> predator->rlw.running_len);
> +                             rlwit_discard_first_words(predator, 
> predator->rlw.running_len);
> +                     } else {
> +                             size_t index;
> +                             index = rlwit_discharge(prey, out, 
> predator->rlw.running_len, 0);
> +                             ewah_add_empty_words(out, 0, 
> predator->rlw.running_len - index);
> +                             rlwit_discard_first_words(predator, 
> predator->rlw.running_len);
> +                     }
> +             }
> +
> +             size_t literals = min_size(rlw_i.rlw.literal_words, 
> rlw_j.rlw.literal_words);
> +
> +             if (literals) {
> +                     size_t k;
> +
> +                     for (k = 0; k < literals; ++k) {
> +                             ewah_add(out,
> +                                     rlw_i.buffer[rlw_i.literal_word_start + 
> k] &
> +                                     rlw_j.buffer[rlw_j.literal_word_start + 
> k]
> +                             );
> +                     }
> +
> +                     rlwit_discard_first_words(&rlw_i, literals);
> +                     rlwit_discard_first_words(&rlw_j, literals);
> +             }
> +     }
> +
> +     if (rlwit_word_size(&rlw_i) > 0) {
> +             rlwit_discharge_empty(&rlw_i, out);
> +     } else {
> +             rlwit_discharge_empty(&rlw_j, out);
> +     }
> +
> +     out->bit_size = max_size(ewah_i->bit_size, ewah_j->bit_size);
> +}
> +
> +void ewah_and_not(
> +     struct ewah_bitmap *ewah_i,
> +     struct ewah_bitmap *ewah_j,
> +     struct ewah_bitmap *out)
> +{
> +     struct rlw_iterator rlw_i;
> +     struct rlw_iterator rlw_j;
> +
> +     rlwit_init(&rlw_i, ewah_i);
> +     rlwit_init(&rlw_j, ewah_j);
> +
> +     while (rlwit_word_size(&rlw_i) > 0 && rlwit_word_size(&rlw_j) > 0) {
> +             while (rlw_i.rlw.running_len > 0 || rlw_j.rlw.running_len > 0) {
> +                     struct rlw_iterator *prey, *predator;
> +
> +                     if (rlw_i.rlw.running_len < rlw_j.rlw.running_len) {
> +                             prey = &rlw_i;
> +                             predator = &rlw_j;
> +                     } else {
> +                             prey = &rlw_j;
> +                             predator = &rlw_i;
> +                     }
> +
> +                     if ((predator->rlw.running_bit && prey == &rlw_i) ||
> +                             (!predator->rlw.running_bit && prey != &rlw_i)) 
> {
> +                             ewah_add_empty_words(out, 0, 
> predator->rlw.running_len);
> +                             rlwit_discard_first_words(prey, 
> predator->rlw.running_len);
> +                             rlwit_discard_first_words(predator, 
> predator->rlw.running_len);
> +                     } else {
> +                             size_t index;
> +                             int negate_words;
> +
> +                             negate_words = (&rlw_i != prey);
> +                             index = rlwit_discharge(prey, out, 
> predator->rlw.running_len, negate_words);
> +                             ewah_add_empty_words(out, negate_words, 
> predator->rlw.running_len - index);
> +                             rlwit_discard_first_words(predator, 
> predator->rlw.running_len);
> +                     }
> +             }
> +
> +             size_t literals = min_size(rlw_i.rlw.literal_words, 
> rlw_j.rlw.literal_words);
> +
> +             if (literals) {
> +                     size_t k;
> +
> +                     for (k = 0; k < literals; ++k) {
> +                             ewah_add(out,
> +                                     rlw_i.buffer[rlw_i.literal_word_start + 
> k] &
> +                                     ~(rlw_j.buffer[rlw_j.literal_word_start 
> + k])
> +                             );
> +                     }
> +
> +                     rlwit_discard_first_words(&rlw_i, literals);
> +                     rlwit_discard_first_words(&rlw_j, literals);
> +             }
> +     }
> +
> +     if (rlwit_word_size(&rlw_i) > 0) {
> +             rlwit_discharge(&rlw_i, out, ~0, 0);
> +     } else {
> +             rlwit_discharge_empty(&rlw_j, out);
> +     }
> +
> +     out->bit_size = max_size(ewah_i->bit_size, ewah_j->bit_size);
> +}
> +
> +void ewah_or(
> +     struct ewah_bitmap *ewah_i,
> +     struct ewah_bitmap *ewah_j,
> +     struct ewah_bitmap *out)
> +{
> +     struct rlw_iterator rlw_i;
> +     struct rlw_iterator rlw_j;
> +
> +     rlwit_init(&rlw_i, ewah_i);
> +     rlwit_init(&rlw_j, ewah_j);
> +
> +     while (rlwit_word_size(&rlw_i) > 0 && rlwit_word_size(&rlw_j) > 0) {
> +             while (rlw_i.rlw.running_len > 0 || rlw_j.rlw.running_len > 0) {
> +                     struct rlw_iterator *prey, *predator;
> +
> +                     if (rlw_i.rlw.running_len < rlw_j.rlw.running_len) {
> +                             prey = &rlw_i;
> +                             predator = &rlw_j;
> +                     } else {
> +                             prey = &rlw_j;
> +                             predator = &rlw_i;
> +                     }
> +
> +
> +                     if (predator->rlw.running_bit) {
> +                             ewah_add_empty_words(out, 0, 
> predator->rlw.running_len);
> +                             rlwit_discard_first_words(prey, 
> predator->rlw.running_len);
> +                             rlwit_discard_first_words(predator, 
> predator->rlw.running_len);
> +                     } else {
> +                             size_t index;
> +                             index = rlwit_discharge(prey, out, 
> predator->rlw.running_len, 0);
> +                             ewah_add_empty_words(out, 0, 
> predator->rlw.running_len - index);
> +                             rlwit_discard_first_words(predator, 
> predator->rlw.running_len);
> +                     }
> +             }
> +
> +             size_t literals = min_size(rlw_i.rlw.literal_words, 
> rlw_j.rlw.literal_words);
> +
> +             if (literals) {
> +                     size_t k;
> +
> +                     for (k = 0; k < literals; ++k) {
> +                             ewah_add(out,
> +                                     rlw_i.buffer[rlw_i.literal_word_start + 
> k] |
> +                                     rlw_j.buffer[rlw_j.literal_word_start + 
> k]
> +                             );
> +                     }
> +
> +                     rlwit_discard_first_words(&rlw_i, literals);
> +                     rlwit_discard_first_words(&rlw_j, literals);
> +             }
> +     }
> +
> +     if (rlwit_word_size(&rlw_i) > 0) {
> +             rlwit_discharge(&rlw_i, out, ~0, 0);
> +     } else {
> +             rlwit_discharge(&rlw_j, out, ~0, 0);
> +     }
> +
> +     out->bit_size = max_size(ewah_i->bit_size, ewah_j->bit_size);
> +}
> +
> +
> +#define BITMAP_POOL_MAX 16
> +static struct ewah_bitmap *bitmap_pool[BITMAP_POOL_MAX];
> +static size_t bitmap_pool_size;
> +
> +struct ewah_bitmap *ewah_pool_new(void)
> +{
> +     if (bitmap_pool_size)
> +             return bitmap_pool[--bitmap_pool_size];
> +
> +     return ewah_new();
> +}
> +
> +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;
> +}
> +
> +uint32_t ewah_checksum(struct ewah_bitmap *self)
> +{
> +     const uint8_t *p = (uint8_t *)self->buffer;
> +     uint32_t crc = (uint32_t)self->bit_size;
> +     size_t size = self->buffer_size * sizeof(eword_t);
> +
> +     while (size--)
> +             crc = (crc << 5) - crc + (uint32_t)*p++;
> +
> +     return crc;
> +}
> diff --git a/ewah/ewah_io.c b/ewah/ewah_io.c
> new file mode 100644
> index 0000000..db6c062
> --- /dev/null
> +++ b/ewah/ewah_io.c
> @@ -0,0 +1,192 @@
> +/**
> + * Copyright 2013, GitHub, Inc
> + * Copyright 2009-2013, Daniel Lemire, Cliff Moon,
> + *   David McIntosh, Robert Becho, Google Inc. and Veronika Zenz
> + *
> + * 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., 51 Franklin Street, Fifth Floor, Boston, MA  
> 02110-1301, USA.
> + */
> +#include <stdlib.h>
> +#include <unistd.h>
> +#include <stdio.h>
> +
> +#include "git-compat-util.h"
> +#include "ewok.h"
> +
> +int ewah_serialize_native(struct ewah_bitmap *self, int fd)
> +{
> +     uint32_t write32;
> +     size_t to_write = self->buffer_size * 8;
> +
> +     /* 32 bit -- bit size fr the map */
> +     write32 = (uint32_t)self->bit_size;
> +     if (write(fd, &write32, 4) != 4)
> +             return -1;
> +
> +     /** 32 bit -- number of compressed 64-bit words */
> +     write32 = (uint32_t)self->buffer_size;
> +     if (write(fd, &write32, 4) != 4)
> +             return -1;
> +
> +     if (write(fd, self->buffer, to_write) != to_write)
> +             return -1;
> +
> +     /** 32 bit -- position for the RLW */
> +     write32 = self->rlw - self->buffer;
> +     if (write(fd, &write32, 4) != 4)
> +             return -1;
> +
> +     return (3 * 4) + to_write;
> +}
> +
> +int ewah_serialize_to(struct ewah_bitmap *self,
> +                   int (*write_fun)(void *, const void *, size_t),
> +                   void *data)
> +{
> +     size_t i;
> +     eword_t dump[2048];
> +     const size_t words_per_dump = sizeof(dump) / sizeof(eword_t);
> +
> +     /* 32 bit -- bit size fr the map */
> +     uint32_t bitsize =  htonl((uint32_t)self->bit_size);
> +     if (write_fun(data, &bitsize, 4) != 4)
> +             return -1;
> +
> +     /** 32 bit -- number of compressed 64-bit words */
> +     uint32_t word_count =  htonl((uint32_t)self->buffer_size);
> +     if (write_fun(data, &word_count, 4) != 4)
> +             return -1;
> +
> +     /** 64 bit x N -- compressed words */
> +     const eword_t *buffer = self->buffer;
> +     size_t words_left = self->buffer_size;
> +
> +     while (words_left >= words_per_dump) {
> +             for (i = 0; i < words_per_dump; ++i, ++buffer)
> +                     dump[i] = htonll(*buffer);
> +
> +             if (write_fun(data, dump, sizeof(dump)) != sizeof(dump))
> +                     return -1;
> +
> +             words_left -= words_per_dump;
> +     }
> +
> +     if (words_left) {
> +             for (i = 0; i < words_left; ++i, ++buffer)
> +                     dump[i] = htonll(*buffer);
> +
> +             if (write_fun(data, dump, words_left * 8) != words_left * 8)
> +                     return -1;
> +     }
> +
> +     /** 32 bit -- position for the RLW */
> +     uint32_t rlw_pos = (uint8_t*)self->rlw - (uint8_t *)self->buffer;
> +     rlw_pos = htonl(rlw_pos / sizeof(eword_t));
> +
> +     if (write_fun(data, &rlw_pos, 4) != 4)
> +             return -1;
> +
> +     return (3 * 4) + (self->buffer_size * 8);
> +}
> +
> +static int write_helper(void *fd, const void *buf, size_t len)
> +{
> +     return write((intptr_t)fd, buf, len);
> +}
> +
> +int ewah_serialize(struct ewah_bitmap *self, int fd)
> +{
> +     return ewah_serialize_to(self, write_helper, (void *)(intptr_t)fd);
> +}
> +
> +int ewah_read_mmap(struct ewah_bitmap *self, void *map, size_t len)
> +{
> +     uint32_t *read32 = map;
> +     eword_t *read64;
> +     size_t i;
> +
> +     self->bit_size = ntohl(*read32++);
> +     self->buffer_size = self->alloc_size = ntohl(*read32++);
> +     self->buffer = ewah_realloc(self->buffer, self->alloc_size * 
> sizeof(eword_t));
> +
> +     if (!self->buffer)
> +             return -1;
> +
> +     for (i = 0, read64 = (void *)read32; i < self->buffer_size; ++i) {
> +             self->buffer[i] = ntohll(*read64++);
> +     }
> +
> +     read32 = (void *)read64;
> +     self->rlw = self->buffer + ntohl(*read32++);
> +
> +     return (3 * 4) + (self->buffer_size * 8);
> +}
> +
> +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);
> +
> +     ewah_clear(self);
> +
> +     /* 32 bit -- bit size fr the map */
> +     uint32_t bitsize;
> +     if (read(fd, &bitsize, 4) != 4)
> +             return -1;
> +
> +     self->bit_size = (size_t)ntohl(bitsize);
> +
> +     /** 32 bit -- number of compressed 64-bit words */
> +     uint32_t word_count;
> +     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 */
> +     eword_t *buffer = self->buffer;
> +     size_t 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 */
> +     uint32_t rlw_pos;
> +     if (read(fd, &rlw_pos, 4) != 4)
> +             return -1;
> +
> +     self->rlw = self->buffer + ntohl(rlw_pos);
> +
> +     return 0;
> +}
> diff --git a/ewah/ewah_rlw.c b/ewah/ewah_rlw.c
> new file mode 100644
> index 0000000..0281025
> --- /dev/null
> +++ b/ewah/ewah_rlw.c
> @@ -0,0 +1,120 @@
> +/**
> + * Copyright 2013, GitHub, Inc
> + * Copyright 2009-2013, Daniel Lemire, Cliff Moon,
> + *   David McIntosh, Robert Becho, Google Inc. and Veronika Zenz
> + *
> + * 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., 51 Franklin Street, Fifth Floor, Boston, MA  
> 02110-1301, USA.
> + */
> +#include <assert.h>
> +#include <stdlib.h>
> +#include <unistd.h>
> +#include <string.h>
> +
> +#include "ewok.h"
> +#include "ewok_rlw.h"
> +
> +static inline int next_word(struct rlw_iterator *it)
> +{
> +     if (it->pointer >= it->size)
> +             return 0;
> +
> +     it->rlw.word = &it->buffer[it->pointer];
> +     it->pointer += rlw_get_literal_words(it->rlw.word) + 1;
> +
> +     it->rlw.literal_words = rlw_get_literal_words(it->rlw.word);
> +     it->rlw.running_len = rlw_get_running_len(it->rlw.word);
> +     it->rlw.running_bit = rlw_get_run_bit(it->rlw.word);
> +     it->rlw.literal_word_offset = 0;
> +
> +     return 1;
> +}
> +
> +void rlwit_init(struct rlw_iterator *it, struct ewah_bitmap *from_ewah)
> +{
> +     it->buffer = from_ewah->buffer;
> +     it->size = from_ewah->buffer_size;
> +     it->pointer = 0;
> +
> +     next_word(it);
> +
> +     it->literal_word_start = rlwit_literal_words(it) + 
> it->rlw.literal_word_offset;
> +}
> +
> +void rlwit_discard_first_words(struct rlw_iterator *it, size_t x)
> +{
> +     while (x > 0) {
> +             size_t discard;
> +
> +             if (it->rlw.running_len > x) {
> +                     it->rlw.running_len -= x;
> +                     return;
> +             }
> +
> +             x -= it->rlw.running_len;
> +             it->rlw.running_len = 0;
> +
> +             discard = (x > it->rlw.literal_words) ? it->rlw.literal_words : 
> x;
> +
> +             it->literal_word_start += discard;
> +             it->rlw.literal_words -= discard;
> +             x -= discard;
> +
> +             if (x > 0 || rlwit_word_size(it) == 0) {
> +                     if (!next_word(it))
> +                             break;
> +
> +                     it->literal_word_start =
> +                             rlwit_literal_words(it) + 
> it->rlw.literal_word_offset;
> +             }
> +     }
> +}
> +
> +size_t rlwit_discharge(
> +     struct rlw_iterator *it, struct ewah_bitmap *out, size_t max, int 
> negate)
> +{
> +     size_t index = 0;
> +
> +     while (index < max && rlwit_word_size(it) > 0) {
> +             size_t pd, pl = it->rlw.running_len;
> +
> +             if (index + pl > max) {
> +                     pl = max - index;
> +             }
> +
> +             ewah_add_empty_words(out, it->rlw.running_bit ^ negate, pl);
> +             index += pl;
> +
> +             pd = it->rlw.literal_words;
> +             if (pd + index > max) {
> +                     pd = max - index;
> +             }
> +
> +             ewah_add_dirty_words(out,
> +                     it->buffer + it->literal_word_start, pd, negate);
> +
> +             rlwit_discard_first_words(it, pd + pl);
> +             index += pd;
> +     }
> +
> +     return index;
> +}
> +
> +void rlwit_discharge_empty(struct rlw_iterator *it, struct ewah_bitmap *out)
> +{
> +     while (rlwit_word_size(it) > 0) {
> +             ewah_add_empty_words(out, 0, rlwit_word_size(it));
> +             rlwit_discard_first_words(it, rlwit_word_size(it));
> +     }
> +}
> diff --git a/ewah/ewok.h b/ewah/ewok.h
> new file mode 100644
> index 0000000..3db7703
> --- /dev/null
> +++ b/ewah/ewok.h
> @@ -0,0 +1,223 @@
> +/**
> + * Copyright 2013, GitHub, Inc
> + * Copyright 2009-2013, Daniel Lemire, Cliff Moon,
> + *   David McIntosh, Robert Becho, Google Inc. and Veronika Zenz
> + *
> + * 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., 51 Franklin Street, Fifth Floor, Boston, MA  
> 02110-1301, USA.
> + */
> +#ifndef __EWOK_BITMAP_C__
> +#define __EWOK_BITMAP_C__
> +
> +#include <stdint.h>
> +
> +#ifndef ewah_malloc
> +#    define ewah_malloc malloc
> +#endif
> +#ifndef ewah_realloc
> +#    define ewah_realloc realloc
> +#endif
> +#ifndef ewah_calloc
> +#    define ewah_calloc calloc
> +#endif
> +
> +typedef uint64_t eword_t;
> +#define BITS_IN_WORD (sizeof(eword_t) * 8)
> +
> +/**
> + * Do not use __builtin_popcountll. The GCC implementation
> + * is notoriously slow on all platforms.
> + *
> + * See: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=36041
> + */
> +static inline uint32_t ewah_bit_popcount64(uint64_t x)
> +{
> +     x = (x & 0x5555555555555555ULL) + ((x >>  1) & 0x5555555555555555ULL);
> +     x = (x & 0x3333333333333333ULL) + ((x >>  2) & 0x3333333333333333ULL);
> +     x = (x & 0x0F0F0F0F0F0F0F0FULL) + ((x >>  4) & 0x0F0F0F0F0F0F0F0FULL);
> +     return (x * 0x0101010101010101ULL) >> 56;
> +}
> +
> +#define ewah_bit_ctz64(x) __builtin_ctzll(x)
> +
> +struct ewah_bitmap {
> +     eword_t *buffer;
> +     size_t buffer_size;
> +     size_t alloc_size;
> +     size_t bit_size;
> +     eword_t *rlw;
> +};
> +
> +typedef void (*ewah_callback)(size_t pos, void *);
> +
> +struct ewah_bitmap *ewah_pool_new(void);
> +void ewah_pool_free(struct ewah_bitmap *self);
> +
> +/**
> + * Allocate a new EWAH Compressed bitmap
> + */
> +struct ewah_bitmap *ewah_new(void);
> +
> +/**
> + * Clear all the bits in the bitmap. Does not free or resize
> + * memory.
> + */
> +void ewah_clear(struct ewah_bitmap *self);
> +
> +/**
> + * Free all the memory of the bitmap
> + */
> +void ewah_free(struct ewah_bitmap *self);
> +
> +int ewah_serialize_to(struct ewah_bitmap *self,
> +                   int (*write_fun)(void *out, const void *buf, size_t len),
> +                   void *out);
> +int ewah_serialize(struct ewah_bitmap *self, int fd);
> +int ewah_serialize_native(struct ewah_bitmap *self, int fd);
> +
> +int ewah_deserialize(struct ewah_bitmap *self, int fd);
> +int ewah_read_mmap(struct ewah_bitmap *self, void *map, size_t len);
> +int ewah_read_mmap_native(struct ewah_bitmap *self, void *map, size_t len);
> +
> +uint32_t ewah_checksum(struct ewah_bitmap *self);
> +
> +/**
> + * Logical not (bitwise negation) in-place on the bitmap
> + *
> + * This operation is linear time based on the size of the bitmap.
> + */
> +void ewah_not(struct ewah_bitmap *self);
> +
> +/**
> + * Call the given callback with the position of every single bit
> + * that has been set on the bitmap.
> + *
> + * This is an efficient operation that does not fully decompress
> + * the bitmap.
> + */
> +void ewah_each_bit(struct ewah_bitmap *self, ewah_callback callback, void 
> *payload);
> +
> +/**
> + * Set a given bit on the bitmap.
> + *
> + * The bit at position `pos` will be set to true. Because of the
> + * way that the bitmap is compressed, a set bit cannot be unset
> + * later on.
> + *
> + * Furthermore, since the bitmap uses streaming compression, bits
> + * can only set incrementally.
> + *
> + * E.g.
> + *           ewah_set(bitmap, 1); // ok
> + *           ewah_set(bitmap, 76); // ok
> + *           ewah_set(bitmap, 77); // ok
> + *           ewah_set(bitmap, 8712800127); // ok
> + *           ewah_set(bitmap, 25); // failed, assert raised
> + */
> +void ewah_set(struct ewah_bitmap *self, size_t i);
> +
> +struct ewah_iterator {
> +     const eword_t *buffer;
> +     size_t buffer_size;
> +
> +     size_t pointer;
> +     eword_t compressed, literals;
> +     eword_t rl, lw;
> +     int b;
> +};
> +
> +/**
> + * Initialize a new iterator to run through the bitmap in uncompressed form.
> + *
> + * The iterator can be stack allocated. The underlying bitmap must not be 
> freed
> + * before the iteration is over.
> + *
> + * E.g.
> + *
> + *           struct ewah_bitmap *bitmap = ewah_new();
> + *           struct ewah_iterator it;
> + *
> + *           ewah_iterator_init(&it, bitmap);
> + */
> +void ewah_iterator_init(struct ewah_iterator *it, struct ewah_bitmap 
> *parent);
> +
> +/**
> + * Yield every single word in the bitmap in uncompressed form. This is:
> + * yield single words (32-64 bits) where each bit represents an actual
> + * bit from the bitmap.
> + *
> + * Return: true if a word was yield, false if there are no words left
> + */
> +int ewah_iterator_next(eword_t *next, struct ewah_iterator *it);
> +
> +void ewah_or(
> +     struct ewah_bitmap *ewah_i,
> +     struct ewah_bitmap *ewah_j,
> +     struct ewah_bitmap *out);
> +
> +void ewah_and_not(
> +     struct ewah_bitmap *ewah_i,
> +     struct ewah_bitmap *ewah_j,
> +     struct ewah_bitmap *out);
> +
> +void ewah_xor(
> +     struct ewah_bitmap *ewah_i,
> +     struct ewah_bitmap *ewah_j,
> +     struct ewah_bitmap *out);
> +
> +void ewah_and(
> +     struct ewah_bitmap *ewah_i,
> +     struct ewah_bitmap *ewah_j,
> +     struct ewah_bitmap *out);
> +
> +void ewah_dump(struct ewah_bitmap *self);
> +
> +/**
> + * Direct word access
> + */
> +size_t ewah_add_empty_words(struct ewah_bitmap *self, int v, size_t number);
> +void ewah_add_dirty_words(
> +     struct ewah_bitmap *self, const eword_t *buffer, size_t number, int 
> negate);
> +size_t ewah_add(struct ewah_bitmap *self, eword_t word);
> +
> +
> +/**
> + * Uncompressed, old-school bitmap that can be efficiently compressed
> + * into an `ewah_bitmap`.
> + */
> +struct bitmap {
> +     eword_t *words;
> +     size_t word_alloc;
> +};
> +
> +struct bitmap *bitmap_new(void);
> +void bitmap_set(struct bitmap *self, size_t pos);
> +void bitmap_clear(struct bitmap *self, size_t pos);
> +int bitmap_get(struct bitmap *self, size_t pos);
> +void bitmap_reset(struct bitmap *self);
> +void bitmap_free(struct bitmap *self);
> +int bitmap_equals(struct bitmap *self, struct bitmap *other);
> +int bitmap_is_subset(struct bitmap *self, struct bitmap *super);
> +
> +struct ewah_bitmap * bitmap_to_ewah(struct bitmap *bitmap);
> +struct bitmap *ewah_to_bitmap(struct ewah_bitmap *ewah);
> +
> +void bitmap_and_not(struct bitmap *self, struct bitmap *other);
> +void bitmap_or_ewah(struct bitmap *self, struct ewah_bitmap *other);
> +void bitmap_or(struct bitmap *self, const struct bitmap *other);
> +
> +void bitmap_each_bit(struct bitmap *self, ewah_callback callback, void 
> *data);
> +size_t bitmap_popcount(struct bitmap *self);
> +
> +#endif
> diff --git a/ewah/ewok_rlw.h b/ewah/ewok_rlw.h
> new file mode 100644
> index 0000000..63efdf9
> --- /dev/null
> +++ b/ewah/ewok_rlw.h
> @@ -0,0 +1,114 @@
> +/**
> + * Copyright 2013, GitHub, Inc
> + * Copyright 2009-2013, Daniel Lemire, Cliff Moon,
> + *   David McIntosh, Robert Becho, Google Inc. and Veronika Zenz
> + *
> + * 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., 51 Franklin Street, Fifth Floor, Boston, MA  
> 02110-1301, USA.
> + */
> +#ifndef __EWOK_RLW_H__
> +#define __EWOK_RLW_H__
> +
> +#define RLW_RUNNING_BITS (sizeof(eword_t) * 4)
> +#define RLW_LITERAL_BITS (sizeof(eword_t) * 8 - 1 - RLW_RUNNING_BITS)
> +
> +#define RLW_LARGEST_RUNNING_COUNT (((eword_t)1 << RLW_RUNNING_BITS) - 1)
> +#define RLW_LARGEST_LITERAL_COUNT (((eword_t)1 << RLW_LITERAL_BITS) - 1)
> +
> +#define RLW_LARGEST_RUNNING_COUNT_SHIFT (RLW_LARGEST_RUNNING_COUNT << 1)
> +
> +#define RLW_RUNNING_LEN_PLUS_BIT (((eword_t)1 << (RLW_RUNNING_BITS + 1)) - 1)
> +
> +static int rlw_get_run_bit(const eword_t *word)
> +{
> +     return *word & (eword_t)1;
> +}
> +
> +static inline void rlw_set_run_bit(eword_t *word, int b)
> +{
> +     if (b) {
> +             *word |= (eword_t)1;
> +     } else {
> +             *word &= (eword_t)(~1);
> +     }
> +}
> +
> +static inline void rlw_xor_run_bit(eword_t *word)
> +{
> +     if (*word & 1) {
> +             *word &= (eword_t)(~1);
> +     } else {
> +             *word |= (eword_t)1;
> +     }
> +}
> +
> +static inline void rlw_set_running_len(eword_t *word, eword_t l)
> +{
> +     *word |= RLW_LARGEST_RUNNING_COUNT_SHIFT;
> +     *word &= (l << 1) | (~RLW_LARGEST_RUNNING_COUNT_SHIFT);
> +}
> +
> +static inline eword_t rlw_get_running_len(const eword_t *word)
> +{
> +     return (*word >> 1) & RLW_LARGEST_RUNNING_COUNT;
> +}
> +
> +static inline eword_t rlw_get_literal_words(const eword_t *word)
> +{
> +     return *word >> (1 + RLW_RUNNING_BITS);
> +}
> +
> +static inline void rlw_set_literal_words(eword_t *word, eword_t l)
> +{
> +     *word |= ~RLW_RUNNING_LEN_PLUS_BIT;
> +     *word &= (l << (RLW_RUNNING_BITS + 1)) | RLW_RUNNING_LEN_PLUS_BIT;
> +}
> +
> +static inline eword_t rlw_size(const eword_t *self)
> +{
> +     return rlw_get_running_len(self) + rlw_get_literal_words(self);
> +}
> +
> +struct rlw_iterator {
> +     const eword_t *buffer;
> +     size_t size;
> +     size_t pointer;
> +     size_t literal_word_start;
> +
> +     struct {
> +             const eword_t *word;
> +             int literal_words;
> +             int running_len;
> +             int literal_word_offset;
> +             int running_bit;
> +     } rlw;
> +};
> +
> +void rlwit_init(struct rlw_iterator *it, struct ewah_bitmap *bitmap);
> +void rlwit_discard_first_words(struct rlw_iterator *it, size_t x);
> +size_t rlwit_discharge(
> +     struct rlw_iterator *it, struct ewah_bitmap *out, size_t max, int 
> negate);
> +void rlwit_discharge_empty(struct rlw_iterator *it, struct ewah_bitmap *out);
> +
> +static inline size_t rlwit_word_size(struct rlw_iterator *it)
> +{
> +     return it->rlw.running_len + it->rlw.literal_words;
> +}
> +
> +static inline size_t rlwit_literal_words(struct rlw_iterator *it)
> +{
> +     return it->pointer - it->rlw.literal_words;
> +}
> +
> +#endif
--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to majord...@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to