Move apply_block to C and optimize hex formatting

Author: whitfin

.travis.yml

@@ -4,7 +4,7 @@ elixir:
 otp_release:
   - 18.0
 script:
-  - HASH_IMPL=native mix test --trace
-  - HASH_IMPL=embedded mix test --trace
+  - STATE_IMPL=native UTIL_IMPL=native mix test --trace
+  - STATE_IMPL=embedded UTIL_IMPL=embedded mix test --trace
 after_success:
-  - HASH_IMPL=embedded MIX_ENV=test mix coveralls.travis
+  - STATE_IMPL=embedded UTIL_IMPL=embedded MIX_ENV=test mix coveralls.travis

Makefile

@@ -9,9 +9,10 @@ ifneq ($(OS),Windows_NT)
 	endif
 endif
 
-_native/native_impl.so: clean
+_native: clean
 	mkdir -p _native
-	$(CC) -w $(CFLAGS) -shared $(LDFLAGS) -o $@ c_src/native_impl.c
+	$(CC) -w $(CFLAGS) -shared $(LDFLAGS) -o $@/state.so c_src/state.c
+	$(CC) -w $(CFLAGS) -shared $(LDFLAGS) -o $@/util.so c_src/util.c
 
 clean:
 	$(RM) -r _native/*

c_src/native_impl.c

@@ -0,0 +1,96 @@
+#include "erl_nif.h"
+#include <inttypes.h>
+
+#define ROTATE_LEFT(x, b) (unsigned long)(((x) << (b)) | ((x) >> (64 - (b))))
+
+#define COMPRESS                \
+  v0 += v1;                     \
+  v2 += v3;                     \
+  v1 = ROTATE_LEFT(v1, 13);     \
+  v3 = ROTATE_LEFT(v3, 16);     \
+  v1 ^= v0;                     \
+  v3 ^= v2;                     \
+  v0 = ROTATE_LEFT(v0, 32);     \
+  v2 += v1;                     \
+  v0 += v3;                     \
+  v1 = ROTATE_LEFT(v1, 17);     \
+  v3 = ROTATE_LEFT(v3, 21);     \
+  v1 ^= v2;                     \
+  v3 ^= v0;                     \
+  v2 = ROTATE_LEFT(v2, 32);
+
+static ERL_NIF_TERM apply_block(ErlNifEnv* env, int arc, const ERL_NIF_TERM argv[]) {
+  int arity;
+  const ERL_NIF_TERM** tuple;
+
+  enif_get_tuple(env, argv[0], &arity, &tuple);
+
+  unsigned long v0;
+  unsigned long v1;
+  unsigned long v2;
+  unsigned long v3;
+  unsigned long m;
+
+  enif_get_ulong(env, tuple[0], &v0);
+  enif_get_ulong(env, tuple[1], &v1);
+  enif_get_ulong(env, tuple[2], &v2);
+  enif_get_ulong(env, tuple[3], &v3);
+  enif_get_ulong(env, argv[1], &m);
+
+  int c;
+
+  enif_get_int(env, argv[2], &c);
+
+  v3 ^= m;
+  for(int i = 0; i < c; i++){
+    COMPRESS
+  }
+  v0 ^= m;
+
+  return enif_make_tuple4(
+    env,
+    enif_make_ulong(env, v0),
+    enif_make_ulong(env, v1),
+    enif_make_ulong(env, v2),
+    enif_make_ulong(env, v3)
+  );
+}
+
+static ERL_NIF_TERM finalize(ErlNifEnv* env, int arc, const ERL_NIF_TERM argv[]) {
+  int arity;
+  const ERL_NIF_TERM** tuple;
+
+  enif_get_tuple(env, argv[0], &arity, &tuple);
+
+  unsigned long v0;
+  unsigned long v1;
+  unsigned long v2;
+  unsigned long v3;
+
+  enif_get_ulong(env, tuple[0], &v0);
+  enif_get_ulong(env, tuple[1], &v1);
+  enif_get_ulong(env, tuple[2], &v2);
+  enif_get_ulong(env, tuple[3], &v3);
+
+  int d;
+
+  enif_get_int(env, argv[1], &d);
+
+  v2 ^= 0xff;
+  for(int i = 0; i < d; i++){
+    COMPRESS
+  }
+
+  return enif_make_ulong(env, v0 ^ v1 ^ v2 ^ v3);
+}
+
+static ErlNifFunc nif_funcs[] = {
+  { "apply_internal_block", 3, apply_block },
+  { "finalize", 2, finalize }
+};
+
+static int upgrade(ErlNifEnv* env, void** new, void** old, ERL_NIF_TERM info){
+  return 0;
+}
+
+ERL_NIF_INIT(Elixir.SipHash.State,nif_funcs,NULL,NULL,upgrade,NULL)

c_src/state.c

@@ -0,0 +1,24 @@
+#include "erl_nif.h"
+
+static ERL_NIF_TERM format(ErlNifEnv* env, int arc, const ERL_NIF_TERM argv[]) {
+  unsigned long n;
+  ErlNifBinary f, r;
+
+  enif_alloc_binary(16, &r);
+  enif_get_ulong(env, argv[0], &n);
+  enif_inspect_binary(env, argv[1], &f);
+
+  sprintf(r.data, f.data, n);
+
+  return enif_make_binary(env, &r);
+}
+
+static ErlNifFunc nif_funcs[] = {
+  { "format", 2, format }
+};
+
+static int upgrade(ErlNifEnv* env, void** new, void** old, ERL_NIF_TERM info){
+  return 0;
+}
+
+ERL_NIF_INIT(Elixir.SipHash.Util,nif_funcs,NULL,NULL,upgrade,NULL)

c_src/util.c

@@ -10,9 +10,7 @@
     "^\\s+use\\s+"
   ],
   "custom_stop_words": [
-    "case :erlang.load_nif",
-    "Logger",
-    "log_msg"
+    "_other"
   ],
   "coverage_options": {
     "treat_no_relevant_lines_as_covered": false

coveralls.json

@@ -9,6 +9,10 @@ defmodule SipHash do
   the NIFs are automatically loaded during the start of the application. Please
   note that the use of NIFs brings a significant performance improvement, and so
   you should only disable them with good reason.
+
+  Due to the use of NIFs, please only use the public `SipHash` functions. Do not
+  rely on the behaviour of any submodules, as incorrect use of native functions
+  can result in crashes in your application.
   """
 
   # alias both SipHash.State/Util
@@ -89,7 +93,6 @@ defmodule SipHash do
     c_pass = 2
     d_pass = 4
     to_hex = false
-    l_pad  = false
     state  = State.initialize(key)
 
     case opts do
@@ -99,7 +102,6 @@ defmodule SipHash do
         c_pass = Keyword.get(opts, :c, c_pass)
         d_pass = Keyword.get(opts, :d, d_pass)
         to_hex = Keyword.get(opts, :hex, to_hex)
-        l_pad  = Keyword.get(opts, :padding, l_pad)
     end
 
     input
@@ -114,9 +116,7 @@ defmodule SipHash do
        end)
     |> State.apply_last_block(in_len, c_pass)
     |> State.finalize(d_pass)
-    |> Util.to_hex(to_hex)
-    |> Util.to_case(s_case, :upper)
-    |> Util.pad_left(l_pad)
+    |> Util.format(to_hex, s_case)
   end
 
   @doc """

lib/siphash.ex

@@ -20,7 +20,7 @@ defmodule SipHash.State do
   @initial_v3 0x7465646279746573
 
   # define native implementation
-  @native_impl [".", "_native", "native_impl"] |> Path.join |> Path.expand
+  @native_impl [".", "_native", "state"] |> Path.join |> Path.expand
 
   # setup init load
   @on_load :init
@@ -31,33 +31,28 @@ defmodule SipHash.State do
   implementation, we don't have to exit on failure.
   """
   def init do
-    case System.get_env("HASH_IMPL") do
-      "embedded" ->
-        Logger.bare_log(:debug, "Loaded embedded compression.")
-      _other ->
-        case :erlang.load_nif(@native_impl, 0) do
-          :ok ->
-            Logger.bare_log(:debug, "Loaded native compression.")
-          err ->
-            log_msg = "Unable to load native compression! Using embedded instead."
-            Logger.bare_log(:warn, log_msg <> "\n" <> inspect(err))
-        end
+    case System.get_env("STATE_IMPL") do
+      "embedded" -> :ok;
+      _other -> :erlang.load_nif(@native_impl, 0)
     end
   end
 
   @doc """
   Applies a block (an 8-byte chunk) to the digest, and returns the state after
-  transformation. If a binary chunk is passed in, it's converted to a number (as
-  little endian) before being passed to the main body. First we XOR v3 before
-  compressing the state twice. Once complete, we then XOR v0, and return the
-  final state.
+  transformation. A binary chunk is passed in, and then it is converted to a
+  number (as little endian) before being passed to the internal function
+  `SipHash.State.apply_internal_block/3`.
   """
-  @spec apply_block(s, binary | number, number) :: s
+  @spec apply_block(s, binary, number) :: s
   def apply_block({ _v0, _v1, _v2, _v3 } = state, m, c)
   when is_binary(m) and is_number(c) do
-    apply_block(state, Util.bytes_to_long(m), c)
+    apply_internal_block(state, Util.bytes_to_long(m), c)
   end
-  def apply_block({ v0, v1, v2, v3 }, m, c) when is_number(m) and is_number(c) do
+
+  # Applies a block to the digest, and returns the state after transformation.
+  # First we XOR v3 before compressing the state twice. Once it's complete, we
+  # then XOR v0, and return the final state.
+  defp apply_internal_block({ v0, v1, v2, v3 }, m, c) do
     state = { v0, v1, v2, v3 ^^^ m }
 
     { v0, v1, v2, v3 } =