add unit tests with FastValueBuilderFactory also

6 files changed, 61 insertions, 32 deletions

diff --git a/eval/src/tests/instruction/generic_concat/generic_concat_test.cpp b/eval/src/tests/instruction/generic_concat/generic_concat_test.cpp
index 675aa36d63a..aaea8fdcb28 100644
--- a/eval/src/tests/instruction/generic_concat/generic_concat_test.cpp
+++ b/eval/src/tests/instruction/generic_concat/generic_concat_test.cpp
@@ -1,6 +1,7 @@
 // Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include <vespa/eval/eval/simple_value.h>
+#include <vespa/eval/eval/fast_value.h>
 #include <vespa/eval/eval/value_codec.h>
 #include <vespa/eval/eval/simple_tensor.h>
 #include <vespa/eval/eval/simple_tensor_engine.h>
@@ -120,9 +121,10 @@ TensorSpec reference_concat(const TensorSpec &a, const TensorSpec &b, const std:
     return result;
 }
 
-TensorSpec perform_generic_concat(const TensorSpec &a, const TensorSpec &b, const std::string &concat_dim) {
+TensorSpec perform_generic_concat(const TensorSpec &a, const TensorSpec &b,
+                                  const std::string &concat_dim, const ValueBuilderFactory &factory)
+{
     Stash stash;
-    const auto &factory = SimpleValueBuilderFactory::get();
     auto lhs = value_from_spec(a, factory);
     auto rhs = value_from_spec(b, factory);
     auto my_op = GenericConcat::make_instruction(lhs->type(), rhs->type(), concat_dim, factory, stash);
@@ -142,18 +144,26 @@ TEST(GenericConcatTest, generic_reference_concat_works) {
     }
 }
 
-TEST(GenericConcatTest, generic_concat_works_for_simple_values) {
+void test_generic_concat_with(const ValueBuilderFactory &factory) {
     ASSERT_TRUE((concat_layouts.size() % 2) == 0);
     for (size_t i = 0; i < concat_layouts.size(); i += 2) {
         const TensorSpec lhs = spec(concat_layouts[i], N());
         const TensorSpec rhs = spec(concat_layouts[i + 1], Div16(N()));
         SCOPED_TRACE(fmt("\n===\nin LHS: %s\nin RHS: %s\n===\n", lhs.to_string().c_str(), rhs.to_string().c_str()));
-        auto actual = perform_generic_concat(lhs, rhs, "y");
+        auto actual = perform_generic_concat(lhs, rhs, "y", factory);
         auto expect = reference_concat(lhs, rhs, "y");
         EXPECT_EQ(actual, expect);
     }
 }
 
+TEST(GenericConcatTest, generic_concat_works_for_simple_values) {
+    test_generic_concat_with(SimpleValueBuilderFactory::get());
+}
+
+TEST(GenericConcatTest, generic_concat_works_for_fast_values) {
+    test_generic_concat_with(FastValueBuilderFactory::get());
+}
+
 TEST(GenericConcatTest, dense_concat_plan_can_be_created) {
     auto lhs = ValueType::from_spec("tensor(a[2],b[3],c[5],d{},f[2],g[3])");
     auto rhs = ValueType::from_spec("tensor(a[2],b[3],c[7],e{},h[3],i[4])");
diff --git a/eval/src/tests/instruction/generic_join/generic_join_test.cpp b/eval/src/tests/instruction/generic_join/generic_join_test.cpp
index cf04b2ca990..558f20d2e10 100644
--- a/eval/src/tests/instruction/generic_join/generic_join_test.cpp
+++ b/eval/src/tests/instruction/generic_join/generic_join_test.cpp
@@ -70,19 +70,10 @@ TensorSpec reference_join(const TensorSpec &a, const TensorSpec &b, join_fun_t f
     return result;
 }
 
-TensorSpec perform_generic_join(const TensorSpec &a, const TensorSpec &b, join_fun_t function) {
+TensorSpec perform_generic_join(const TensorSpec &a, const TensorSpec &b,
+                                join_fun_t function, const ValueBuilderFactory &factory)
+{
     Stash stash;
-    const auto &factory = SimpleValueBuilderFactory::get();
-    auto lhs = value_from_spec(a, factory);
-    auto rhs = value_from_spec(b, factory);
-    auto my_op = GenericJoin::make_instruction(lhs->type(), rhs->type(), function, factory, stash);
-    InterpretedFunction::EvalSingle single(factory, my_op);
-    return spec_from_value(single.eval(std::vector<Value::CREF>({*lhs,*rhs})));
-}
-
-TensorSpec perform_generic_join_fast(const TensorSpec &a, const TensorSpec &b, join_fun_t function) {
-    Stash stash;
-    const auto &factory = FastValueBuilderFactory::get();
     auto lhs = value_from_spec(a, factory);
     auto rhs = value_from_spec(b, factory);
     auto my_op = GenericJoin::make_instruction(lhs->type(), rhs->type(), function, factory, stash);
@@ -140,9 +131,9 @@ TEST(GenericJoinTest, generic_join_works_for_simple_and_fast_values) {
         for (auto fun: {operation::Add::f, operation::Sub::f, operation::Mul::f, operation::Div::f}) {
             SCOPED_TRACE(fmt("\n===\nLHS: %s\nRHS: %s\n===\n", lhs.to_string().c_str(), rhs.to_string().c_str()));
             auto expect = reference_join(lhs, rhs, fun);
-            auto actual = perform_generic_join(lhs, rhs, fun);
-            auto fast = perform_generic_join_fast(lhs, rhs, fun); 
-            EXPECT_EQ(actual, expect);
+            auto simple = perform_generic_join(lhs, rhs, fun, SimpleValueBuilderFactory::get());
+            auto fast = perform_generic_join(lhs, rhs, fun, FastValueBuilderFactory::get());
+            EXPECT_EQ(simple, expect);
             EXPECT_EQ(fast, expect);
         }
     }
diff --git a/eval/src/tests/instruction/generic_map/generic_map_test.cpp b/eval/src/tests/instruction/generic_map/generic_map_test.cpp
index 69fb417e0ad..63a9563a11b 100644
--- a/eval/src/tests/instruction/generic_map/generic_map_test.cpp
+++ b/eval/src/tests/instruction/generic_map/generic_map_test.cpp
@@ -1,6 +1,7 @@
 // Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include <vespa/eval/eval/simple_value.h>
+#include <vespa/eval/eval/fast_value.h>
 #include <vespa/eval/eval/value_codec.h>
 #include <vespa/eval/instruction/generic_map.h>
 #include <vespa/eval/eval/interpreted_function.h>
@@ -47,7 +48,7 @@ TensorSpec perform_generic_map(const TensorSpec &a, map_fun_t func, const ValueB
     return spec_from_value(single.eval(std::vector<Value::CREF>({*lhs})));
 }
 
-void test_generic_map(const ValueBuilderFactory &factory) {
+void test_generic_map_with(const ValueBuilderFactory &factory) {
     for (const auto & layout : map_layouts) {
         TensorSpec lhs = spec(layout, Div16(N()));
         ValueType lhs_type = ValueType::from_spec(lhs.type());
@@ -61,7 +62,11 @@ void test_generic_map(const ValueBuilderFactory &factory) {
 }
 
 TEST(GenericMapTest, generic_map_works_for_simple_values) {
-    test_generic_map(SimpleValueBuilderFactory::get());
+    test_generic_map_with(SimpleValueBuilderFactory::get());
+}
+
+TEST(GenericMapTest, generic_map_works_for_fast_values) {
+    test_generic_map_with(FastValueBuilderFactory::get());
 }
 
 TensorSpec immediate_generic_map(const TensorSpec &a, map_fun_t func, const ValueBuilderFactory &factory)
diff --git a/eval/src/tests/instruction/generic_merge/generic_merge_test.cpp b/eval/src/tests/instruction/generic_merge/generic_merge_test.cpp
index fd9b8513acb..5166ef6ccc9 100644
--- a/eval/src/tests/instruction/generic_merge/generic_merge_test.cpp
+++ b/eval/src/tests/instruction/generic_merge/generic_merge_test.cpp
@@ -1,6 +1,7 @@
 // Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include <vespa/eval/eval/simple_value.h>
+#include <vespa/eval/eval/fast_value.h>
 #include <vespa/eval/eval/value_codec.h>
 #include <vespa/eval/instruction/generic_merge.h>
 #include <vespa/eval/eval/interpreted_function.h>
@@ -55,9 +56,8 @@ TensorSpec reference_merge(const TensorSpec &a, const TensorSpec &b, join_fun_t
     return result;
 }
 
-TensorSpec perform_generic_merge(const TensorSpec &a, const TensorSpec &b, join_fun_t fun) {
+TensorSpec perform_generic_merge(const TensorSpec &a, const TensorSpec &b, join_fun_t fun, const ValueBuilderFactory &factory) {
     Stash stash;
-    const auto &factory = SimpleValueBuilderFactory::get();
     auto lhs = value_from_spec(a, factory);
     auto rhs = value_from_spec(b, factory);
     auto my_op = GenericMerge::make_instruction(lhs->type(), rhs->type(), fun, factory, stash);
@@ -65,7 +65,7 @@ TensorSpec perform_generic_merge(const TensorSpec &a, const TensorSpec &b, join_
     return spec_from_value(single.eval(std::vector<Value::CREF>({*lhs, *rhs})));
 }
 
-TEST(GenericMergeTest, generic_merge_works_for_simple_values) {
+void test_generic_merge_with(const ValueBuilderFactory &factory) {
     ASSERT_TRUE((merge_layouts.size() % 2) == 0);
     for (size_t i = 0; i < merge_layouts.size(); i += 2) {
         TensorSpec lhs = spec(merge_layouts[i], N());
@@ -73,12 +73,20 @@ TEST(GenericMergeTest, generic_merge_works_for_simple_values) {
         SCOPED_TRACE(fmt("\n===\nLHS: %s\nRHS: %s\n===\n", lhs.to_string().c_str(), rhs.to_string().c_str()));
         for (auto fun: {operation::Add::f, operation::Mul::f, operation::Sub::f, operation::Max::f}) {
             auto expect = reference_merge(lhs, rhs, fun);
-            auto actual = perform_generic_merge(lhs, rhs, fun);
+            auto actual = perform_generic_merge(lhs, rhs, fun, factory);
             EXPECT_EQ(actual, expect);
         }
     }
 }
 
+TEST(GenericMergeTest, generic_merge_works_for_simple_values) {
+    test_generic_merge_with(SimpleValueBuilderFactory::get());
+}
+
+TEST(GenericMergeTest, generic_merge_works_for_fast_values) {
+    test_generic_merge_with(FastValueBuilderFactory::get());
+}
+
 TensorSpec immediate_generic_merge(const TensorSpec &a, const TensorSpec &b, join_fun_t fun) {
     const auto &factory = SimpleValueBuilderFactory::get();
     auto lhs = value_from_spec(a, factory);
diff --git a/eval/src/tests/instruction/generic_reduce/generic_reduce_test.cpp b/eval/src/tests/instruction/generic_reduce/generic_reduce_test.cpp
index 490055bf02f..cc36c139c99 100644
--- a/eval/src/tests/instruction/generic_reduce/generic_reduce_test.cpp
+++ b/eval/src/tests/instruction/generic_reduce/generic_reduce_test.cpp
@@ -1,6 +1,7 @@
 // Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include <vespa/eval/eval/simple_value.h>
+#include <vespa/eval/eval/fast_value.h>
 #include <vespa/eval/eval/value_codec.h>
 #include <vespa/eval/instruction/generic_reduce.h>
 #include <vespa/eval/eval/interpreted_function.h>
@@ -62,9 +63,10 @@ TensorSpec reference_reduce(const TensorSpec &a, const std::vector<vespalib::str
     return spec_from_value(*value_from_spec(result, factory));
 }
 
-TensorSpec perform_generic_reduce(const TensorSpec &a, const std::vector<vespalib::string> &dims, Aggr aggr) {
+TensorSpec perform_generic_reduce(const TensorSpec &a, const std::vector<vespalib::string> &dims,
+                                  Aggr aggr, const ValueBuilderFactory &factory)
+{
     Stash stash;
-    const auto &factory = SimpleValueBuilderFactory::get();
     auto lhs = value_from_spec(a, factory);
     auto my_op = GenericReduce::make_instruction(lhs->type(), aggr, dims, factory, stash);
     InterpretedFunction::EvalSingle single(factory, my_op);
@@ -94,22 +96,30 @@ TEST(GenericReduceTest, sparse_reduce_plan_can_be_created) {
     EXPECT_EQ(plan.keep_dims, expect_keep_dims);
 }
 
-TEST(GenericReduceTest, generic_reduce_works_for_simple_values) {
+void test_generic_reduce_with(const ValueBuilderFactory &factory) {
     for (const Layout &layout: layouts) {
         TensorSpec input = spec(layout, Div16(N()));
         for (Aggr aggr: {Aggr::SUM, Aggr::AVG, Aggr::MIN, Aggr::MAX}) {
             for (const Domain &domain: layout) {
                 auto expect = reference_reduce(input, {domain.dimension}, aggr);
-                auto actual = perform_generic_reduce(input, {domain.dimension}, aggr);
+                auto actual = perform_generic_reduce(input, {domain.dimension}, aggr, factory);
                 EXPECT_EQ(actual, expect);
             }
             auto expect = reference_reduce(input, {}, aggr);
-            auto actual = perform_generic_reduce(input, {}, aggr);
+            auto actual = perform_generic_reduce(input, {}, aggr, factory);
             EXPECT_EQ(actual, expect);
         }
     }
 }
 
+TEST(GenericReduceTest, generic_reduce_works_for_simple_values) {
+    test_generic_reduce_with(SimpleValueBuilderFactory::get());
+}
+
+TEST(GenericReduceTest, generic_reduce_works_for_fast_values) {
+    test_generic_reduce_with(FastValueBuilderFactory::get());
+}
+
 TensorSpec immediate_generic_reduce(const TensorSpec &a, const std::vector<vespalib::string> &dims, Aggr aggr) {
     const auto &factory = SimpleValueBuilderFactory::get();
     auto lhs = value_from_spec(a, factory);
diff --git a/eval/src/tests/instruction/generic_rename/generic_rename_test.cpp b/eval/src/tests/instruction/generic_rename/generic_rename_test.cpp
index 124462f0e0f..b2e30a8b78c 100644
--- a/eval/src/tests/instruction/generic_rename/generic_rename_test.cpp
+++ b/eval/src/tests/instruction/generic_rename/generic_rename_test.cpp
@@ -1,6 +1,7 @@
 // Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include <vespa/eval/eval/simple_value.h>
+#include <vespa/eval/eval/fast_value.h>
 #include <vespa/eval/eval/value_codec.h>
 #include <vespa/eval/instruction/generic_rename.h>
 #include <vespa/eval/eval/interpreted_function.h>
@@ -121,7 +122,7 @@ TensorSpec perform_generic_rename(const TensorSpec &a,
     return spec_from_value(single.eval(std::vector<Value::CREF>({*lhs})));
 }
 
-void test_generic_rename(const ValueBuilderFactory &factory) {
+void test_generic_rename_with(const ValueBuilderFactory &factory) {
     for (const auto & layout : rename_layouts) {
         TensorSpec lhs = spec(layout, N());
         ValueType lhs_type = ValueType::from_spec(lhs.type());
@@ -139,7 +140,11 @@ void test_generic_rename(const ValueBuilderFactory &factory) {
 }
 
 TEST(GenericRenameTest, generic_rename_works_for_simple_values) {
-    test_generic_rename(SimpleValueBuilderFactory::get());
+    test_generic_rename_with(SimpleValueBuilderFactory::get());
+}
+
+TEST(GenericRenameTest, generic_rename_works_for_fast_values) {
+    test_generic_rename_with(FastValueBuilderFactory::get());
 }
 
 TensorSpec immediate_generic_rename(const TensorSpec &a, const FromTo &ft)