initial commit

Author: jfeser

bin/bench.ml

@@ -0,0 +1,54 @@
+open! Core
+open Core_bench
+open Bitarray
+
+let () =
+  Random.self_init ();
+  let random_native () = Native.init ~f:(fun _ -> Random.bool ()) (64 * 4) in
+  let random_vect () = Vectorized.init ~f:(fun _ -> Random.bool ()) (64 * 4) in
+
+  let n1 = random_native () and n2 = random_native () in
+  let v1 = random_vect () and v2 = random_vect () in
+  let and_native = Bench.Test.create ~name:"and-native" (fun () -> Native.and_ n1 n2) in
+  let and_vect = Bench.Test.create ~name:"and-vect" (fun () -> Vectorized.and_ v1 v2) in
+  let hamming_native =
+    Bench.Test.create ~name:"native" (fun () -> Native.hamming_weight n1)
+  in
+  let hamming_vect =
+    Bench.Test.create ~name:"vect" (fun () -> Vectorized.hamming_weight v1)
+  in
+
+  let hamming_dist_native =
+    Bench.Test.create ~name:"native" (fun () -> Native.hamming_distance n1 n2)
+  in
+  let hamming_dist_vect =
+    Bench.Test.create ~name:"vect" (fun () -> Vectorized.hamming_distance v1 v2)
+  in
+
+  let rep_native =
+    Bench.Test.create ~name:"native" (fun () ->
+        Native.replicate ~w:16 ~h:16 n1 ~dx:1 ~dy:2 ~ct:5)
+  in
+  let rep_vect =
+    Bench.Test.create ~name:"vect" (fun () ->
+        Vectorized.replicate ~w:16 ~h:16 v1 ~dx:1 ~dy:2 ~ct:5)
+  in
+
+  let hash_native = Bench.Test.create ~name:"native" (fun () -> Vectorized.hash v1) in
+  let hash_vect = Bench.Test.create ~name:"vect" (fun () -> Vectorized.vec_hash v1) in
+
+  Command_unix.run
+  @@ Command.group ~summary:"bitvector benchmarks"
+       [
+         ("hash", Bench.make_command [ hash_native; hash_vect ]);
+         ( "other",
+           Bench.make_command
+             [
+               Bench.Test.create_group ~name:"replicate" [ rep_vect; rep_native ];
+               Bench.Test.create_group ~name:"and" [ and_native; and_vect ];
+               Bench.Test.create_group ~name:"hamming-weight"
+                 [ hamming_native; hamming_vect ];
+               Bench.Test.create_group ~name:"hamming-dist"
+                 [ hamming_dist_native; hamming_dist_vect ];
+             ] );
+       ]

bin/dune

@@ -0,0 +1,5 @@
+(executable
+ (name bench)
+ (libraries bitarray core core_bench core_unix.command_unix)
+ (preprocess
+  (pps ppx_jane)))

lib/bitarray.ispc

@@ -0,0 +1,119 @@
+typedef int32 word_t;
+
+export uniform bool bitarray_any(uniform word_t a[], uniform int len) {
+  bool part = false;
+  foreach (i = 0 ... len) { part |= popcnt((int32)a[i]) > 0; }
+  return any(part);
+}
+
+export uniform int bitarray_hamming_weight(uniform word_t a[],
+                                           uniform int len) {
+  uniform int part = 0;
+  for (uniform int i = 0; i < len; i++) {
+    part += popcnt(a[i]);
+  }
+  return part;
+}
+
+inline bool read_bit(const uniform word_t x[], const int b,
+                     const uniform int len) {
+  int i = b >> 5;       // div by word_size = 32
+  int j = b & (32 - 1); // mod by word size
+  return ((x[i] >> j) & 1);
+}
+
+inline int offset(int x, int y, uniform int w, uniform int h) {
+  return ((h - 1 - y) * w) + x;
+}
+
+export void bitarray_replicate(const uniform word_t a[], const uniform int dx,
+                               const uniform int dy, const uniform int ct,
+                               const uniform int w, const uniform int h,
+                               uniform word_t r[], const uniform int len) {
+  foreach (word_idx = 0 ... len) {
+    int start_bit = 32 * word_idx;
+    int x = start_bit % w;
+    int y = h - 1 - (start_bit / w);
+    word_t word = a[word_idx];
+    for (uniform int b = 0; b < 32; b++) {
+      bool bit = false;
+      int xx = x;
+      int yy = y;
+      for (uniform int c = 0; c < ct && xx >= 0 && xx < w && yy >= 0 && yy < h;
+           c++) {
+        bit |= read_bit(a, offset(xx, yy, w, h), len);
+        xx -= dx;
+        yy -= dy;
+      }
+      word |= ((int)bit) << b;
+      y = (x == w - 1) ? y - 1 : y;
+      x = (x == w - 1) ? 0 : (x + 1);
+    }
+    r[word_idx] = word;
+  }
+}
+
+// TODO: wrapping translation
+export void bitarray_translate(const uniform word_t a[], const uniform int dx,
+                               const uniform int dy, const uniform int w,
+                               const uniform int h, uniform word_t r[],
+                               const uniform int len) {
+  foreach (word_idx = 0 ... len) {
+    int start_bit = 32 * word_idx;
+    // get the x,y coords of the least significant bit in the word
+    int x = start_bit % w;
+    int y = h - 1 - (start_bit / w);
+    // get the shifted coords of the lsb
+    int xx = x - dx;
+    int yy = y - dy;
+    // what is the bit offset of the shifted coords? the word that contains
+    // this offset (and maybe the next word) will be the source for the
+    // shift
+    int read_word_bit = offset(xx, yy, w, h);
+    int read_word1 = read_word_bit / 32;
+    int read_word2 = read_word1 + 1;
+
+    word_t w1 = (read_word1 >= 0 && read_word1 < len) ? a[read_word1] : 0;
+    word_t w2 = (read_word2 >= 0 && read_word2 < len) ? a[read_word2] : 0;
+
+    int k = read_word_bit % 32;
+    // take the low k bits of w1 and the high 32-k bits of w2
+    r[word_idx] = (w1 << (32 - k)) | (w2 >> k);
+  }
+}
+
+export void bitarray_corners(const uniform word_t a[], const uniform int w,
+                             const uniform int h, uniform word_t r[],
+                             const uniform int len) {
+  foreach (word_idx = 0 ... len) {
+    int start_bit = 32 * word_idx;
+    int x = start_bit % w;
+    int y = h - 1 - (start_bit / w);
+
+    word_t word = 0;
+    for (uniform int b = 0; b < 32; b++) {
+      int offset = start_bit + b;
+      bool b1 = read_bit(a, offset - w - 1, len);
+      bool b2 = read_bit(a, offset - w, len);
+      bool b3 = read_bit(a, offset - w + 1, len);
+
+      bool b4 = read_bit(a, offset - 1, len);
+      bool b5 = read_bit(a, offset, len);
+      bool b6 = read_bit(a, offset + 1, len);
+
+      bool b7 = read_bit(a, offset + w - 1, len);
+      bool b8 = read_bit(a, offset + w, len);
+      bool b9 = read_bit(a, offset + w + 1, len);
+
+      bool bit = x > 0 && x < w && y > 0 && y < h && b5 &&
+                 (!(b1 || b2 || b4) || !(b2 || b3 || b6) || !(b4 || b7 || b8) ||
+                  !(b6 || b8 || b9));
+
+      word |= ((int)bit) << b;
+
+      y = (x == w - 1) ? y - 1 : y;
+      x = (x == w - 1) ? 0 : (x + 1);
+    }
+    r[word_idx] = word;
+  }
+}

lib/bitarray.ml

@@ -0,0 +1,31 @@
+module type S = sig
+  type t [@@deriving compare, hash, sexp]
+
+  val length : t -> int
+  val bits_per_word : int
+  val nwords : int -> int
+  val create : int -> bool -> t
+  val init_fold : f:('a -> int -> 'a * bool) -> init:'a -> int -> t
+  val init : f:(int -> bool) -> int -> t
+  val init_bitmap : w:int -> h:int -> f:(i:int -> x:int -> y:int -> bool) -> t
+  val of_list : bool list -> t
+  val get : t -> int -> bool
+  val to_list : t -> bool list
+  val fold : t -> f:('a -> bool -> 'a) -> init:'a -> 'a
+  val iteri : t -> f:(int -> bool -> unit) -> unit
+  val is_empty : t -> bool
+  val not : t -> t
+  val and_ : t -> t -> t
+  val or_ : t -> t -> t
+  val xor : t -> t -> t
+  val hamming_weight : t -> int
+  val hamming_distance : t -> t -> int
+  val jaccard : t -> t -> float
+  val replicate : w:int -> h:int -> t -> dx:int -> dy:int -> ct:int -> t
+  val corners : w:int -> h:int -> t -> t
+  val pp_bitmap : w:int -> Format.formatter -> t -> unit
+end
+
+include Vectorized
+module Native = Native
+module Vectorized = Vectorized

lib/bitarray.mli

@@ -0,0 +1,36 @@
+module type S = sig
+  type t [@@deriving compare, hash, sexp]
+
+  val length : t -> int
+  val bits_per_word : int
+  val nwords : int -> int
+  val create : int -> bool -> t
+  val init_fold : f:('a -> int -> 'a * bool) -> init:'a -> int -> t
+  val init : f:(int -> bool) -> int -> t
+  val init_bitmap : w:int -> h:int -> f:(i:int -> x:int -> y:int -> bool) -> t
+  val of_list : bool list -> t
+  val get : t -> int -> bool
+  val to_list : t -> bool list
+  val fold : t -> f:('a -> bool -> 'a) -> init:'a -> 'a
+  val iteri : t -> f:(int -> bool -> unit) -> unit
+  val is_empty : t -> bool
+  val not : t -> t
+  val and_ : t -> t -> t
+  val or_ : t -> t -> t
+  val xor : t -> t -> t
+  val hamming_weight : t -> int
+  val hamming_distance : t -> t -> int
+  val jaccard : t -> t -> float
+  val replicate : w:int -> h:int -> t -> dx:int -> dy:int -> ct:int -> t
+  val corners : w:int -> h:int -> t -> t
+  val pp_bitmap : w:int -> Format.formatter -> t -> unit
+end
+
+include S
+module Native : S
+
+module Vectorized : sig
+  include S
+
+  val vec_hash : t -> int
+end

lib/bitarray_stubs.c

@@ -0,0 +1,141 @@
+#include <caml/alloc.h>
+#include <caml/memory.h>
+#include <caml/mlvalues.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+#include "bitarray.h"
+
+typedef int32_t word_t;
+
+#define len(s) (caml_string_length(s) / (sizeof(word_t)))
+
+CAMLprim value bitarray_and_stub(value b1, value b2, value b3) {
+  const word_t *p1 = (const word_t *)String_val(b1),
+               *p2 = (const word_t *)String_val(b2);
+  word_t *p3 = (word_t *)Bytes_val(b3);
+
+  for (int i = 0; i < len(b1); i++) {
+    p3[i] = p1[i] & p2[i];
+  }
+  return Val_unit;
+}
+
+CAMLprim value bitarray_or_stub(value b1, value b2, value b3) {
+  const word_t *p1 = (const word_t *)String_val(b1),
+               *p2 = (const word_t *)String_val(b2);
+  word_t *p3 = (word_t *)Bytes_val(b3);
+
+  for (int i = 0; i < len(b1); i++) {
+    p3[i] = p1[i] | p2[i];
+  }
+  return Val_unit;
+}
+
+CAMLprim value bitarray_xor_stub(value b1, value b2, value b3) {
+  const word_t *p1 = (const word_t *)String_val(b1),
+               *p2 = (const word_t *)String_val(b2);
+  word_t *p3 = (word_t *)Bytes_val(b3);
+
+  for (int i = 0; i < len(b1); i++) {
+    p3[i] = p1[i] ^ p2[i];
+  }
+  return Val_unit;
+}
+
+CAMLprim value bitarray_any_stub(value b) {
+  return Val_bool(bitarray_any((word_t *)(String_val(b)), len(b)));
+}
+
+CAMLprim value bitarray_not_stub(value b1, value b2) {
+  const word_t *p1 = (const word_t *)String_val(b1);
+  word_t *p2 = (word_t *)Bytes_val(b2);
+
+  for (int i = 0; i < len(b1); i++) {
+    p2[i] = ~p1[i];
+  }
+  return Val_unit;
+}
+
+CAMLprim intnat bitarray_hamming_weight_stub(value b) {
+  return bitarray_hamming_weight((word_t *)(String_val(b)), len(b));
+}
+
+CAMLprim value bitarray_hamming_weight_stub_byte(value b) {
+  return Val_int(bitarray_hamming_weight_stub(b));
+}
+
+CAMLprim intnat bitarray_hamming_distance_stub(value b1, value b2) {
+  const word_t *p1 = (const word_t *)String_val(b1),
+               *p2 = (const word_t *)String_val(b2);
+  int count = 0;
+
+#pragma GCC unroll 8
+  for (int i = 0; i < len(b1); i++) {
+    count += __builtin_popcount(p1[i] ^ p2[i]);
+  }
+  return count;
+}
+
+CAMLprim value bitarray_hamming_distance_stub_byte(value b1, value b2) {
+  return Val_int(bitarray_hamming_distance_stub(b1, b2));
+}
+
+CAMLprim double bitarray_jaccard_stub(value b1, value b2) {
+  const word_t *p1 = (const word_t *)String_val(b1),
+               *p2 = (const word_t *)String_val(b2);
+  int union_ = 0, inter = 0, len = len(b1);
+
+  if (len == 0) {
+    return 0.;
+  }
+  for (int i = 0; i < len; i++) {
+    union_ += __builtin_popcount(p1[i] | p2[i]);
+    inter += __builtin_popcount(p1[i] & p2[i]);
+  }
+
+  return union_ == 0 ? 0.0 : 1.0 - ((double)inter / (double)union_);
+}
+
+CAMLprim value bitarray_jaccard_stub_byte(value b1, value b2) {
+  return caml_copy_double(bitarray_jaccard_stub(b1, b2));
+}
+
+CAMLprim value bitarray_replicate_stub(value b1, intnat x, intnat y, intnat ct,
+                                       intnat w, intnat h, value b2) {
+  bitarray_replicate((word_t *)(String_val(b1)), x, y, ct, w, h,
+                     (word_t *)(Bytes_val(b2)), len(b1));
+  return Val_unit;
+}
+
+CAMLprim value bitarray_replicate_stub_byte(value b1, value x, value y,
+                                            value ct, value w, value h,
+                                            value b2) {
+  return bitarray_replicate_stub(b1, Int_val(x), Int_val(y), Int_val(ct),
+                                 Int_val(w), Int_val(h), b2);
+}
+
+CAMLprim intnat bitarray_hash_stub(value d, value k) {
+  int *dd = (int *)d;
+  int *kk = (int *)k;
+  long sum = 0;
+  for (int i = 0; i < len(d); i += 2) {
+    sum += (long)(dd[i] + kk[i]) * (long)(dd[i + 1] + kk[i + 1]);
+  }
+  return sum;
+}
+
+CAMLprim value bitarray_hash_stub_byte(value d, value k) {
+  return Val_int(bitarray_hash_stub(d, k));
+}
+
+CAMLprim value bitarray_corners_stub(value b1, intnat w, intnat h, value b2) {
+  bitarray_corners((word_t *)(String_val(b1)), w, h, (word_t *)(Bytes_val(b2)),
+                   len(b1));
+  return Val_unit;
+}
+
+CAMLprim value bitarray_corners_stub_byte(value b1, value w, value h,
+                                          value b2) {
+  return bitarray_corners_stub(b1, Int_val(w), Int_val(h), b2);
+}