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).

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
-- 
1.8.4.1.898.g8bf8a41.dirty

--
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