Improve behavior implementation

Author: elbrujohalcon

.gitignore

@@ -1,3 +1,4 @@
+_build
 .eunit
 deps
 ebin
@@ -8,4 +9,4 @@ erl_crash.dump
 *.so
 *.o
 *.d
-.rebar
+.rebar

src/hyper.erl

@@ -37,7 +37,7 @@ new(P) ->
 
 -spec new(precision(), module()) -> filter().
 new(P, Mod) when 4 =< P andalso P =< 16 andalso is_atom(Mod) ->
-    #hyper{p = P, registers = {Mod, Mod:new(P)}}.
+    #hyper{p = P, registers = {Mod, hyper_register:new(Mod, P)}}.
 
 -spec is_hyper(filter()) -> boolean().
 is_hyper(#hyper{}) -> true;
@@ -53,7 +53,7 @@ insert(Value, #hyper{registers = {Mod, Registers}, p = P} = Hyper)
     ZeroCount = run_of_zeroes(RegisterValue) + 1,
 
     %% Registers are only allowed to increase, implement by backend
-    Hyper#hyper{registers = {Mod, Mod:set(Index, ZeroCount, Registers)}};
+    Hyper#hyper{registers = {Mod, hyper_register:set(Mod, Index, ZeroCount, Registers)}};
 
 insert(_Value, _Hyper) ->
     error(badarg).
@@ -76,7 +76,7 @@ union(Filters) when is_list(Filters) ->
                                   end, Filters),
 
             [First | _] = Filters,
-            First#hyper{registers = {Mod, Mod:max_merge(Registers)}};
+            First#hyper{registers = {Mod, hyper_register:max_merge(Mod, Registers)}};
 
         %% mixed P, but still must have same backend
         [{MinP, Mod} | _] ->
@@ -103,17 +103,17 @@ intersect_card(Left, Right) when Left#hyper.p =:= Right#hyper.p ->
 -spec card(filter()) -> float().
 card(#hyper{registers = {Mod, Registers0}, p = P}) ->
     M = trunc(pow(2, P)),
-    Registers = Mod:compact(Registers0),
+    Registers = hyper_register:compact(Mod, Registers0),
 
-    RegisterSum = Mod:register_sum(Registers),
+    RegisterSum = hyper_register:register_sum(Mod, Registers),
 
     E = alpha(M) * pow(M, 2) / RegisterSum,
     Ep = case E =< 5 * M of
              true -> E - estimate_bias(E, P);
              false -> E
          end,
 
-    V = Mod:zero_count(Registers),
+    V = hyper_register:zero_count(Mod, Registers),
 
     H = case V of
             0 ->
@@ -133,14 +133,14 @@ precision(#hyper{p = Precision}) ->
     Precision.
 
 bytes(#hyper{registers = {Mod, Registers}}) ->
-    Mod:bytes(Registers).
+    hyper_register:bytes(Mod, Registers).
 
 compact(#hyper{registers = {Mod, Registers}} = Hyper) ->
-    Hyper#hyper{registers = {Mod, Mod:compact(Registers)}}.
+    Hyper#hyper{registers = {Mod, hyper_register:compact(Mod, Registers)}}.
 
 reduce_precision(P, #hyper{p = OldP, registers = {Mod, Registers}} = Hyper)
   when P < OldP ->
-    Hyper#hyper{p = P, registers = {Mod, Mod:reduce_precision(P, Registers)}};
+    Hyper#hyper{p = P, registers = {Mod, hyper_register:reduce_precision(Mod, P, Registers)}};
 reduce_precision(P, #hyper{p = P} = Filter) ->
     Filter.
 
@@ -150,12 +150,12 @@ reduce_precision(P, #hyper{p = P} = Filter) ->
 
 -spec to_json(filter()) -> any().
 to_json(#hyper{p = P, registers = {Mod, Registers}}) ->
-    Compact = Mod:compact(Registers),
+    Compact = hyper_register:compact(Mod, Registers),
     {[
       {<<"p">>, P},
       {<<"registers">>, base64:encode(
                           zlib:gzip(
-                            Mod:encode_registers(Compact)))}
+                            hyper_register:encode_registers(Mod, Compact)))}
      ]}.
 
 -spec from_json(any()) -> filter().
@@ -168,7 +168,7 @@ from_json({Struct}, Mod) ->
     Bytes = zlib:gunzip(
               base64:decode(
                 proplists:get_value(<<"registers">>, Struct))),
-    Registers = Mod:decode_registers(Bytes, P),
+    Registers = hyper_register:decode_registers(Mod, Bytes, P),
 
     #hyper{p = P, registers = {Mod, Registers}}.
 
@@ -354,7 +354,7 @@ perf_report() ->
              Filter = insert_many(generate_unique(Card), new(P, Mod)),
 
              {Mod, Registers} = Filter#hyper.registers,
-             Bytes = Mod:encode_registers(Registers),
+             Bytes = hyper_register:encode_registers(Mod, Registers),
              Filled = lists:filter(fun (I) -> binary:at(Bytes, I) =/= 0 end,
                                    lists:seq(0, M-1)),
 

src/hyper_register.erl

@@ -4,6 +4,13 @@
 %% to allow for backend-specific optimizations.
 -module(hyper_register).
 
+-type t() :: module().
+
+-export_type([t/0]).
+
+-export([new/2, set/4, compact/2, max_merge/2, max_merge/3, reduce_precision/3,
+         register_sum/2, zero_count/2, encode_registers/2, decode_registers/3, bytes/2]).
+
 %% @doc: Creates a new instance of the backend. The return value of
 %% this function will be passed to all functions in this module.
 -callback new(P :: hyper:precision()) ->
@@ -63,3 +70,70 @@
 %% @doc: Size in bytes used to represent the registers in memory.
 -callback bytes(hyper:registers()) ->
     integer().
+
+%% @doc: Creates a new instance of the backend. The return value of
+%% this function will be passed to all functions in this module.
+-spec new(t(), P :: hyper:precision()) -> hyper:registers().
+new(RegisterImpl, P) ->
+    RegisterImpl:new(P).
+
+%% @doc: Set the register to the given value, *only* if the value
+%% already stored is lower than the new value. The backend needs to
+%% ensure the register value is only allowed to increase.
+-spec set(t(), Index :: integer(), Value :: integer(), hyper:registers()) ->
+             hyper:registers().
+set(RegisterImpl, Index, Value, Registers) ->
+    RegisterImpl:set(Index, Value, Registers).
+
+%% @doc: Compact is always called before any attempt at reading (sum,
+%% zero count, etc) or merging. It is intended to give backends that
+%% buffer the writes a chance to flush the buffer before the registers
+%% are needed.
+-spec compact(t(), hyper:registers()) -> hyper:registers().
+compact(RegisterImpl, Registers) ->
+    RegisterImpl:compact(Registers).
+
+%% @doc: Merge any number of registers, used to calculate the
+%% union. For two register values at the same index, the max value
+%% must be in the resulting register.
+-spec max_merge(t(), [hyper:registers()]) -> hyper:registers().
+max_merge(RegisterImpl, RegisterLists) ->
+    RegisterImpl:max_merge(RegisterLists).
+
+%% @doc: Same as max_merge/1 but used when we know only two filters
+%% are merged.
+-spec max_merge(t(), hyper:registers(), hyper:registers()) -> hyper:registers().
+max_merge(RegisterImpl, Registers1, Registers2) ->
+    RegisterImpl:max_merge(Registers1, Registers2).
+
+%% @doc: Reduce the precision of the registers. Used for mixed-precision
+%% union by first reducing the precision to the lowest of all filters.
+-spec reduce_precision(t(), hyper:precision(), hyper:registers()) -> hyper:registers().
+reduce_precision(RegisterImpl, Precision, Registers) ->
+    RegisterImpl:reduce_precision(Precision, Registers).
+
+%% @doc: Sum of 2^-R where R is the value in each register.
+-spec register_sum(t(), hyper:registers()) -> float().
+register_sum(RegisterImpl, Registers) ->
+    RegisterImpl:register_sum(Registers).
+
+%% @doc: Count of registers set to 0.
+-spec zero_count(t(), hyper:registers()) -> integer().
+zero_count(RegisterImpl, Registers) ->
+    RegisterImpl:zero_count(Registers).
+
+%% @doc: Encode and decode are called to convert the in-memory
+%% representation of the backend to the serialized format. Must return
+%% one binary where each register is encoded as an 8-bit integer.
+-spec encode_registers(t(), hyper:registers()) -> binary().
+encode_registers(RegisterImpl, Registers) ->
+    RegisterImpl:encode_registers(Registers).
+
+-spec decode_registers(t(), binary(), hyper:precision()) -> hyper:registers().
+decode_registers(RegisterImpl, Encoded, Precision) ->
+    RegisterImpl:decode_registers(Encoded, Precision).
+
+%% @doc: Size in bytes used to represent the registers in memory.
+-spec bytes(t(), hyper:registers()) -> integer().
+bytes(RegisterImpl, Registers) ->
+    RegisterImpl:bytes(Registers).