Add benchmark and unit tests to reif.pl

Benchmarks compare performace of memberd/2 with and without goal expansion to
memberchk/2.

Unit test mostly capture the current behavior, do some sanity checks, couple
of corner cases (like handling of cyclic terms) and property test of
tfilter/3 and tpartition/4.

Author: hurufu

benches/README.md

@@ -26,7 +26,7 @@ cargo bench --bench run_criterion -- --profile-time <time>
 
 # to run iai, you need valgrind installed and to install iai-callgrind-runner
 # at the same version as is in Cargo.toml:
-cargo install iai-callgrind-runner --version 0.7.3
+cargo install iai-callgrind-runner --version 0.9.0
 
 cargo bench --bench run_iai
 ```

benches/reif.pl

@@ -0,0 +1,63 @@
+/*
+Copied from^W^W Inspired by memberbench[1], but has only benchmarks relevant to
+goal expansion of if_/3 and is adapted to be better integrated into Scryer's
+benchmarking subsystem: which doesn't need time reporting, and supports only
+single test at a time.
+
+[1]: http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/sicstus/memberbench.pl
+*/
+
+:- use_module(library(reif)).
+:- use_module(library(lists)).
+:- use_module(library(si)).
+
+
+run(Test, Count) :-
+   atom_si(Test),
+   integer_si(Count),
+   exptrue(Count),
+   \+ benchmark(Test, z, "abcdefghijklmnopqrstuvwxyz ")
+   ; true.
+
+
+% Baseline test – the fastest possible implementation
+benchmark(memberchk,   E, Es) :- memberchk(E, Es).
+
+% Expanded if_/3
+benchmark(memberd_ifc, E, Es) :- memberd_ifc(E, Es).
+
+% Non-expanded if_/3
+benchmark(memberd_fif, E, Es) :- memberd_fif(E, Es).
+
+
+memberd_ifc(X, [E|Es]) :-
+   if_(X = E, true, memberd_ifc(X, Es)).
+
+memberd_fif(X, [E|Es]) :-
+   fif_(X = E, true, memberd_fif(X, Es)).
+
+
+% Copy of _if/3, but with a different name, so it won't be expanded
+fif_(If_1, Then_0, Else_0) :-
+    call(If_1, T),
+    (  T == true  -> call(Then_0)
+    ;  T == false -> call(Else_0)
+    ;  nonvar(T) -> throw(error(type_error(boolean, T), _))
+    ;  throw(error(instantiation_error, _))
+    ).
+
+
+%% exptrue(N).
+%
+% Succeeds 10^N times if N is ground, usefull as a cheap way to repeat a given
+% predicate many times in benchmarks. There are many more ways to generate
+% choice points, but this one by far has the lowest overhead.
+exptrue(0).
+exptrue(1) :- ten.
+exptrue(2) :- ten, ten.
+exptrue(3) :- ten, ten, ten.
+exptrue(4) :- ten, ten, ten, ten.
+exptrue(5) :- ten, ten, ten, ten, ten.
+exptrue(6) :- ten, ten, ten, ten, ten, ten.
+
+ten. ten. ten. ten. ten. ten. ten. ten. ten. ten.

benches/run_iai.rs

@@ -13,6 +13,9 @@ mod iai {
     #[bench::count_edges(setup::prolog_benches()["count_edges"].setup())]
     #[bench::numlist(setup::prolog_benches()["numlist"].setup())]
     #[bench::csv_codename(setup::prolog_benches()["csv_codename"].setup())]
+    #[bench::memberbench_baseline(setup::prolog_benches()["memberbench_baseline"].setup())]
+    #[bench::memberbench_if_expanded(setup::prolog_benches()["memberbench_if_expanded"].setup())]
+    #[bench::memberbench_if_not_expanded(setup::prolog_benches()["memberbench_if_not_expanded"].setup())]
     fn bench(mut run: impl FnMut() -> QueryResolution) -> QueryResolution {
         run()
     }

benches/setup.rs

@@ -29,6 +29,27 @@ pub fn prolog_benches() -> BTreeMap<&'static str, PrologBenchmark> {
             Strategy::Reuse,
             btreemap! { "Name" => Value::try_from("SPACE".to_string()).unwrap()},
         ),
+        (
+            "memberbench_baseline",
+            "benches/reif.pl",
+            "run(memberchk,4).",
+            Strategy::Reuse,
+            btreemap! {},
+        ),
+        (
+            "memberbench_if_expanded",
+            "benches/reif.pl",
+            "run(memberd_ifc,4).",
+            Strategy::Reuse,
+            btreemap! {},
+        ),
+        (
+            "memberbench_if_not_expanded",
+            "benches/reif.pl",
+            "run(memberd_fif,4).",
+            Strategy::Reuse,
+            btreemap! {},
+        ),
     ]
     .map(|b| {
         (

src/tests/reif.pl

@@ -0,0 +1,131 @@
+:- module(reif_tests, []).
+
+:- use_module(library(reif)).
+:- use_module(library(lists)).
+:- use_module(library(dif)).
+:- use_module(library(loader)).
+:- use_module(library(lambda)).
+:- use_module(library(random)).
+:- use_module(test_framework).
+
+/*
+Those tests are just sanity checks – examples from the paper, to make sure I
+haven't messed up.
+*/
+test("indexing dif/2 p6#1", (
+    findall(X-Fs, tfilter(=(X),[1,2,3,2,3,3],Fs), [1-[1], 2-[2,2], 3-[3,3,3], Y-[]]),
+    maplist(dif(Y), [1,2,3])
+)).
+test("indexing dif/2 p6#2", findall(X, duplicate(X,[1,2,3,2,3,3]), [2,3])).
+test("indexing dif/2 p7#1", firstduplicate(1, [1,2,3,1])).
+test("indexing dif/2 p7#2",(
+    firstduplicate(X, [1,2,3,1]),
+    X == 1
+)).
+test("indexing dif/2 p7#3", (
+    findall(Y-A-B-C, firstduplicate(Y,[A,B,C]), [X-X-X-_, X-X-B1-X, X-A2-X-X]),
+    dif(B1,X),
+    dif(A2,X)
+)).
+
+test("doesnt modify free variables", (reif:goal_expanded(A,B), A == B, var(A))).
+test("expands call/1", reif:goal_expanded(call(a), a)).
+test("expands call/1 for modules", reif:goal_expanded(call(a:b(1)), a:b(1))).
+test("expands call/2 for modules", reif:goal_expanded(call(a:b,c), a:b(c))).
+test("doesn't expand call/2", reif:goal_expanded(call(b,c), call(b,c))).
+test("doesn't expand cyclic terms", (
+    X=a(X),
+    reif:goal_expanded(call(X), Y),
+    call(X) == Y
+)).
+test("doesn't expand cyclic call/1", (
+    X=call(X),
+    reif:goal_expanded(X, Y),
+    X == Y
+)).
+test("doesn't expand higher order predicates", (
+    X = maplist(=(1), _),
+    reif:goal_expanded(X, Y),
+    X == Y
+)).
+
+/*
+Following tests capture current results of goal expansion
+TODO: Investigate if if_/3 can be further expanded, and if it will be beneficial
+*/
+test("goal_expansion (=)", (
+    subsumes_full_expansion(if_(1=2,a,b), (
+        1 \= 2 -> b
+    ;   1 == 2 -> a
+    ;   1 = 2, a
+    ;   dif(1,2), b)))).
+
+test("goal_expansion (;)", (
+    subsumes_full_expansion(if_((1=2;3=3),a,b), (
+        1 \= 2 -> if_(3=3,a,b)
+    ;   1 == 2 -> a
+    ;   1 = 2, a
+    ;   dif(1,2), if_(3=3,a,b))))).
+
+test("goal_expansion (,)", (
+    subsumes_full_expansion(if_((1=2,3=3),a,b), (
+        1 \= 2 -> b
+    ;   1 == 2 -> if_(3=3,a,b)
+    ;   1 = 2, if_(3=3,a,b)
+    ;   dif(1,2), b)))).
+
+test("goal_expansion memberd_t", (
+    subsumes_full_expansion(if_(memberd_t(f,"abcdefgh"),t,f), (
+        call(memberd_t(f,"abcdefgh"),A),
+        (   A == true  -> t
+        ;   A == false -> f
+        ;   nonvar(A)  -> throw(error(type_error(boolean,A),_))
+        ;   throw(error(instantiation_error,_))))))).
+
+test("goal_expansion cond_t", (
+    subsumes_full_expansion(if_(cond_t(a,b),t,f), (
+        call(cond_t(a,b),A),
+        (   A == true  -> t
+        ;   A == false -> f
+        ;   nonvar(A)  -> throw(error(type_error(boolean,A),_))
+        ;   throw(error(instantiation_error,_))))))).
+
+test("set of solutions found by tpartition/4 and tfilter/3 is the same and correct", (
+    random_test_vector(TestVector),
+    findall((N,Ts), tpartition(=(N),TestVector,Ts,_), S),
+    findall((N,Ts), tfilter(=(N),TestVector,Ts), S),
+    maplist(_+\(N,Ts)^maplist(=(N),Ts), S)
+)).
+
+random_test_vector(TestVector) :-
+    random_integer(0, 1000, Length),
+    length(TestVector, Length),
+    maplist(random_integer(1,5), TestVector).
+
+% Expand goal until fix point is found
+full_expansion(G, X) :-
+    user:goal_expansion(G, Gx) -> full_expansion(Gx, X); G = X.
+
+% X is more general than fully expanded goal G
+subsumes_full_expansion(G, X) :-
+    full_expansion(G, Y),
+    subsumes_term(X, Y).
+
+/*
+Extra predicates from the paper
+*/
+duplicate(X, Xs) :-
+    tfilter(=(X), Xs, [_,_|_]).
+
+firstduplicate(X, [E|Es]) :-
+    if_(memberd_t(E,Es), X=E, firstduplicate(X, Es)).
+
+treememberd_t(_, nil, false).
+treememberd_t(E, t(F,L,R), T) :-
+    call((E=F; treememberd_t(E,L); treememberd_t(E,R)), T).
+
+tree_non_member(_, nill).
+tree_non_member(E, t(F,L,R)) :-
+    dif(E,F),
+    tree_non_member(E, L),
+    tree_non_member(E, R).

tests/scryer/cli/src_tests/reif_tests.stderr

@@ -0,0 +1 @@
+All tests passed

tests/scryer/cli/src_tests/reif_tests.stdout

@@ -0,0 +1,11 @@
+args = [
+    "-f",
+    "--no-add-history",
+    "-g", "use_module(library(reif_tests))",
+    "-g", "use_module(library(reif))",
+    "-g", "use_module(library(dif))",
+    "-g", "use_module(library(lambda))",
+    "-g", "use_module(library(lists))",
+    "-g", "reif_tests:main(reif_tests)",
+    "src/tests/reif.pl"
+]