test with FastValueBuilderFactory also

5 files changed, 119 insertions, 23 deletions

diff --git a/eval/src/tests/instruction/dense_dot_product_function/dense_dot_product_function_test.cpp b/eval/src/tests/instruction/dense_dot_product_function/dense_dot_product_function_test.cpp
index b9430ff7073..ff4a92d4fff 100644
--- a/eval/src/tests/instruction/dense_dot_product_function/dense_dot_product_function_test.cpp
+++ b/eval/src/tests/instruction/dense_dot_product_function/dense_dot_product_function_test.cpp
@@ -1,5 +1,6 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
+#include <vespa/eval/eval/fast_value.h>
 #include <vespa/eval/eval/tensor_function.h>
 #include <vespa/eval/eval/test/eval_fixture.h>
 #include <vespa/eval/eval/test/tensor_model.hpp>
@@ -16,7 +17,8 @@ using namespace vespalib;
 using namespace vespalib::eval;
 using namespace vespalib::eval::test;
 
-const TensorEngine &prod_engine = tensor::DefaultTensorEngine::ref();
+const TensorEngine &old_engine = tensor::DefaultTensorEngine::ref();
+const ValueBuilderFactory &prod_factory = FastValueBuilderFactory::get();
 
 struct MyVecSeq : Sequence {
     double bias;
@@ -44,11 +46,17 @@ void check_gen_with_result(size_t l, size_t r, double wanted) {
     param_repo.add("a", makeTensor(l, leftBias));
     param_repo.add("b", makeTensor(r, rightBias));
     vespalib::string expr = "reduce(a*b,sum,x)";
-    EvalFixture evaluator(prod_engine, expr, param_repo, true);
+    EvalFixture evaluator(prod_factory, expr, param_repo, true);
     EXPECT_EQUAL(spec(wanted), evaluator.result());
     EXPECT_EQUAL(evaluator.result(), EvalFixture::ref(expr, param_repo));
     auto info = evaluator.find_all<DenseDotProductFunction>();
     EXPECT_EQUAL(info.size(), 1u);
+
+    EvalFixture old_evaluator(old_engine, expr, param_repo, true);
+    EXPECT_EQUAL(spec(wanted), old_evaluator.result());
+    EXPECT_EQUAL(old_evaluator.result(), EvalFixture::ref(expr, param_repo));
+    info = old_evaluator.find_all<DenseDotProductFunction>();
+    EXPECT_EQUAL(info.size(), 1u);
 };
 
 // this should not be possible to set up:
@@ -107,18 +115,29 @@ EvalFixture::ParamRepo make_params() {
 EvalFixture::ParamRepo param_repo = make_params();
 
 void assertOptimized(const vespalib::string &expr) {
-    EvalFixture fixture(prod_engine, expr, param_repo, true);
+    EvalFixture fixture(prod_factory, expr, param_repo, true);
     EXPECT_EQUAL(fixture.result(), EvalFixture::ref(expr, param_repo));
     auto info = fixture.find_all<DenseDotProductFunction>();
     ASSERT_EQUAL(info.size(), 1u);
     EXPECT_TRUE(info[0]->result_is_mutable());
+
+    EvalFixture old_fixture(old_engine, expr, param_repo, true);
+    EXPECT_EQUAL(old_fixture.result(), EvalFixture::ref(expr, param_repo));
+    info = old_fixture.find_all<DenseDotProductFunction>();
+    ASSERT_EQUAL(info.size(), 1u);
+    EXPECT_TRUE(info[0]->result_is_mutable());
 }
 
 void assertNotOptimized(const vespalib::string &expr) {
-    EvalFixture fixture(prod_engine, expr, param_repo, true);
+    EvalFixture fixture(prod_factory, expr, param_repo, true);
     EXPECT_EQUAL(fixture.result(), EvalFixture::ref(expr, param_repo));
     auto info = fixture.find_all<DenseDotProductFunction>();
     EXPECT_TRUE(info.empty());
+
+    EvalFixture old_fixture(old_engine, expr, param_repo, true);
+    EXPECT_EQUAL(old_fixture.result(), EvalFixture::ref(expr, param_repo));
+    info = old_fixture.find_all<DenseDotProductFunction>();
+    EXPECT_TRUE(info.empty());
 }
 
 TEST("require that dot product works with tensor function") {
diff --git a/eval/src/tests/instruction/dense_matmul_function/dense_matmul_function_test.cpp b/eval/src/tests/instruction/dense_matmul_function/dense_matmul_function_test.cpp
index bf379ff3d99..1269d82a1e0 100644
--- a/eval/src/tests/instruction/dense_matmul_function/dense_matmul_function_test.cpp
+++ b/eval/src/tests/instruction/dense_matmul_function/dense_matmul_function_test.cpp
@@ -1,5 +1,6 @@
 // Copyright 2020 Oath Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
+#include <vespa/eval/eval/fast_value.h>
 #include <vespa/eval/eval/operation.h>
 #include <vespa/eval/eval/tensor_function.h>
 #include <vespa/eval/eval/test/eval_fixture.h>
@@ -15,7 +16,8 @@ using namespace vespalib::eval;
 using namespace vespalib::eval::test;
 using namespace vespalib::eval::tensor_function;
 
-const TensorEngine &prod_engine = tensor::DefaultTensorEngine::ref();
+const TensorEngine &old_engine = tensor::DefaultTensorEngine::ref();
+const ValueBuilderFactory &prod_factory = FastValueBuilderFactory::get();
 
 EvalFixture::ParamRepo make_params() {
     return EvalFixture::ParamRepo()
@@ -32,8 +34,8 @@ void verify_optimized(const vespalib::string &expr,
                       size_t lhs_size, size_t common_size, size_t rhs_size,
                       bool lhs_inner, bool rhs_inner)
 {
-    EvalFixture slow_fixture(prod_engine, expr, param_repo, false);
-    EvalFixture fixture(prod_engine, expr, param_repo, true);
+    EvalFixture slow_fixture(prod_factory, expr, param_repo, false);
+    EvalFixture fixture(prod_factory, expr, param_repo, true);
     EXPECT_EQUAL(fixture.result(), EvalFixture::ref(expr, param_repo));
     EXPECT_EQUAL(fixture.result(), slow_fixture.result());
     auto info = fixture.find_all<DenseMatMulFunction>();
@@ -44,15 +46,35 @@ void verify_optimized(const vespalib::string &expr,
     EXPECT_EQUAL(info[0]->rhs_size(), rhs_size);
     EXPECT_EQUAL(info[0]->lhs_common_inner(), lhs_inner);
     EXPECT_EQUAL(info[0]->rhs_common_inner(), rhs_inner);
+
+    EvalFixture old_slow_fixture(old_engine, expr, param_repo, false);
+    EvalFixture old_fixture(old_engine, expr, param_repo, true);
+    EXPECT_EQUAL(old_fixture.result(), EvalFixture::ref(expr, param_repo));
+    EXPECT_EQUAL(old_fixture.result(), old_slow_fixture.result());
+    info = old_fixture.find_all<DenseMatMulFunction>();
+    ASSERT_EQUAL(info.size(), 1u);
+    EXPECT_TRUE(info[0]->result_is_mutable());
+    EXPECT_EQUAL(info[0]->lhs_size(), lhs_size);
+    EXPECT_EQUAL(info[0]->common_size(), common_size);
+    EXPECT_EQUAL(info[0]->rhs_size(), rhs_size);
+    EXPECT_EQUAL(info[0]->lhs_common_inner(), lhs_inner);
+    EXPECT_EQUAL(info[0]->rhs_common_inner(), rhs_inner);
 }
 
 void verify_not_optimized(const vespalib::string &expr) {
-    EvalFixture slow_fixture(prod_engine, expr, param_repo, false);
-    EvalFixture fixture(prod_engine, expr, param_repo, true);
+    EvalFixture slow_fixture(prod_factory, expr, param_repo, false);
+    EvalFixture fixture(prod_factory, expr, param_repo, true);
     EXPECT_EQUAL(fixture.result(), EvalFixture::ref(expr, param_repo));
     EXPECT_EQUAL(fixture.result(), slow_fixture.result());
     auto info = fixture.find_all<DenseMatMulFunction>();
     EXPECT_TRUE(info.empty());
+
+    EvalFixture old_slow_fixture(old_engine, expr, param_repo, false);
+    EvalFixture old_fixture(old_engine, expr, param_repo, true);
+    EXPECT_EQUAL(old_fixture.result(), EvalFixture::ref(expr, param_repo));
+    EXPECT_EQUAL(old_fixture.result(), old_slow_fixture.result());
+    info = old_fixture.find_all<DenseMatMulFunction>();
+    EXPECT_TRUE(info.empty());
 }
 
 TEST("require that matmul can be optimized") {
@@ -78,7 +100,7 @@ TEST("require that expressions similar to matmul are not optimized") {
 }
 
 TEST("require that xw product can be debug dumped") {
-    EvalFixture fixture(prod_engine, "reduce(a2d3*b5d3,sum,d)", param_repo, true);
+    EvalFixture fixture(prod_factory, "reduce(a2d3*b5d3,sum,d)", param_repo, true);
     auto info = fixture.find_all<DenseMatMulFunction>();
     ASSERT_EQUAL(info.size(), 1u);
     fprintf(stderr, "%s\n", info[0]->as_string().c_str());
diff --git a/eval/src/tests/instruction/dense_multi_matmul_function/dense_multi_matmul_function_test.cpp b/eval/src/tests/instruction/dense_multi_matmul_function/dense_multi_matmul_function_test.cpp
index ce9f599d27c..8f4a06b2335 100644
--- a/eval/src/tests/instruction/dense_multi_matmul_function/dense_multi_matmul_function_test.cpp
+++ b/eval/src/tests/instruction/dense_multi_matmul_function/dense_multi_matmul_function_test.cpp
@@ -1,5 +1,6 @@
 // Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
+#include <vespa/eval/eval/fast_value.h>
 #include <vespa/eval/eval/operation.h>
 #include <vespa/eval/eval/tensor_function.h>
 #include <vespa/eval/eval/test/eval_fixture.h>
@@ -15,7 +16,8 @@ using namespace vespalib::eval;
 using namespace vespalib::eval::test;
 using namespace vespalib::eval::tensor_function;
 
-const TensorEngine &prod_engine = tensor::DefaultTensorEngine::ref();
+const TensorEngine &old_engine = tensor::DefaultTensorEngine::ref();
+const ValueBuilderFactory &prod_factory = FastValueBuilderFactory::get();
 
 EvalFixture::ParamRepo make_params() {
     return EvalFixture::ParamRepo()
@@ -39,8 +41,8 @@ void verify_optimized(const vespalib::string &expr,
                       size_t lhs_size, size_t common_size, size_t rhs_size, size_t matmul_cnt,
                       bool lhs_inner, bool rhs_inner)
 {
-    EvalFixture slow_fixture(prod_engine, expr, param_repo, false);
-    EvalFixture fixture(prod_engine, expr, param_repo, true);
+    EvalFixture slow_fixture(prod_factory, expr, param_repo, false);
+    EvalFixture fixture(prod_factory, expr, param_repo, true);
     EXPECT_EQUAL(fixture.result(), EvalFixture::ref(expr, param_repo));
     EXPECT_EQUAL(fixture.result(), slow_fixture.result());
     auto info = fixture.find_all<DenseMultiMatMulFunction>();
@@ -52,15 +54,36 @@ void verify_optimized(const vespalib::string &expr,
     EXPECT_EQUAL(info[0]->matmul_cnt(), matmul_cnt);
     EXPECT_EQUAL(info[0]->lhs_common_inner(), lhs_inner);
     EXPECT_EQUAL(info[0]->rhs_common_inner(), rhs_inner);
+
+    EvalFixture old_slow_fixture(old_engine, expr, param_repo, false);
+    EvalFixture old_fixture(old_engine, expr, param_repo, true);
+    EXPECT_EQUAL(old_fixture.result(), EvalFixture::ref(expr, param_repo));
+    EXPECT_EQUAL(old_fixture.result(), old_slow_fixture.result());
+    info = old_fixture.find_all<DenseMultiMatMulFunction>();
+    ASSERT_EQUAL(info.size(), 1u);
+    EXPECT_TRUE(info[0]->result_is_mutable());
+    EXPECT_EQUAL(info[0]->lhs_size(), lhs_size);
+    EXPECT_EQUAL(info[0]->common_size(), common_size);
+    EXPECT_EQUAL(info[0]->rhs_size(), rhs_size);
+    EXPECT_EQUAL(info[0]->matmul_cnt(), matmul_cnt);
+    EXPECT_EQUAL(info[0]->lhs_common_inner(), lhs_inner);
+    EXPECT_EQUAL(info[0]->rhs_common_inner(), rhs_inner);
 }
 
 void verify_not_optimized(const vespalib::string &expr) {
-    EvalFixture slow_fixture(prod_engine, expr, param_repo, false);
-    EvalFixture fixture(prod_engine, expr, param_repo, true);
+    EvalFixture slow_fixture(prod_factory, expr, param_repo, false);
+    EvalFixture fixture(prod_factory, expr, param_repo, true);
     EXPECT_EQUAL(fixture.result(), EvalFixture::ref(expr, param_repo));
     EXPECT_EQUAL(fixture.result(), slow_fixture.result());
     auto info = fixture.find_all<DenseMultiMatMulFunction>();
     EXPECT_TRUE(info.empty());
+
+    EvalFixture old_slow_fixture(old_engine, expr, param_repo, false);
+    EvalFixture old_fixture(old_engine, expr, param_repo, true);
+    EXPECT_EQUAL(old_fixture.result(), EvalFixture::ref(expr, param_repo));
+    EXPECT_EQUAL(old_fixture.result(), old_slow_fixture.result());
+    info = old_fixture.find_all<DenseMultiMatMulFunction>();
+    EXPECT_TRUE(info.empty());
 }
 
 TEST("require that multi matmul can be optimized") {
@@ -110,7 +133,7 @@ TEST("require that multi matmul ignores trivial dimensions") {
 }
 
 TEST("require that multi matmul function can be debug dumped") {
-    EvalFixture fixture(prod_engine, "reduce(A2B1C3a2d3*A2B1C3b5d3,sum,d)", param_repo, true);
+    EvalFixture fixture(prod_factory, "reduce(A2B1C3a2d3*A2B1C3b5d3,sum,d)", param_repo, true);
     auto info = fixture.find_all<DenseMultiMatMulFunction>();
     ASSERT_EQUAL(info.size(), 1u);
     fprintf(stderr, "%s\n", info[0]->as_string().c_str());
diff --git a/eval/src/tests/instruction/dense_simple_expand_function/dense_simple_expand_function_test.cpp b/eval/src/tests/instruction/dense_simple_expand_function/dense_simple_expand_function_test.cpp
index 22c19fc4368..bf9b8a181aa 100644
--- a/eval/src/tests/instruction/dense_simple_expand_function/dense_simple_expand_function_test.cpp
+++ b/eval/src/tests/instruction/dense_simple_expand_function/dense_simple_expand_function_test.cpp
@@ -1,5 +1,6 @@
 // Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
+#include <vespa/eval/eval/fast_value.h>
 #include <vespa/eval/eval/tensor_function.h>
 #include <vespa/eval/eval/simple_tensor.h>
 #include <vespa/eval/eval/simple_tensor_engine.h>
@@ -16,7 +17,8 @@ using namespace vespalib::eval::tensor_function;
 
 using Inner = DenseSimpleExpandFunction::Inner;
 
-const TensorEngine &prod_engine = tensor::DefaultTensorEngine::ref();
+const TensorEngine &old_engine = tensor::DefaultTensorEngine::ref();
+const ValueBuilderFactory &prod_factory = FastValueBuilderFactory::get();
 
 EvalFixture::ParamRepo make_params() {
     return EvalFixture::ParamRepo()
@@ -36,8 +38,8 @@ EvalFixture::ParamRepo make_params() {
 EvalFixture::ParamRepo param_repo = make_params();
 
 void verify_optimized(const vespalib::string &expr, Inner inner) {
-    EvalFixture slow_fixture(prod_engine, expr, param_repo, false);
-    EvalFixture fixture(prod_engine, expr, param_repo, true, true);
+    EvalFixture slow_fixture(prod_factory, expr, param_repo, false);
+    EvalFixture fixture(prod_factory, expr, param_repo, true, true);
     EXPECT_EQ(fixture.result(), EvalFixture::ref(expr, param_repo));
     EXPECT_EQ(fixture.result(), slow_fixture.result());
     auto info = fixture.find_all<DenseSimpleExpandFunction>();
@@ -47,15 +49,34 @@ void verify_optimized(const vespalib::string &expr, Inner inner) {
     ASSERT_EQ(fixture.num_params(), 2);
     EXPECT_TRUE(!(fixture.get_param(0) == fixture.result()));
     EXPECT_TRUE(!(fixture.get_param(1) == fixture.result()));
+
+    EvalFixture old_slow_fixture(old_engine, expr, param_repo, false);
+    EvalFixture old_fixture(old_engine, expr, param_repo, true, true);
+    EXPECT_EQ(old_fixture.result(), EvalFixture::ref(expr, param_repo));
+    EXPECT_EQ(old_fixture.result(), old_slow_fixture.result());
+    info = old_fixture.find_all<DenseSimpleExpandFunction>();
+    ASSERT_EQ(info.size(), 1u);
+    EXPECT_TRUE(info[0]->result_is_mutable());
+    EXPECT_EQ(info[0]->inner(), inner);
+    ASSERT_EQ(old_fixture.num_params(), 2);
+    EXPECT_TRUE(!(old_fixture.get_param(0) == old_fixture.result()));
+    EXPECT_TRUE(!(old_fixture.get_param(1) == old_fixture.result()));
 }
 
 void verify_not_optimized(const vespalib::string &expr) {
-    EvalFixture slow_fixture(prod_engine, expr, param_repo, false);
-    EvalFixture fixture(prod_engine, expr, param_repo, true);
+    EvalFixture slow_fixture(prod_factory, expr, param_repo, false);
+    EvalFixture fixture(prod_factory, expr, param_repo, true);
     EXPECT_EQ(fixture.result(), EvalFixture::ref(expr, param_repo));
     EXPECT_EQ(fixture.result(), slow_fixture.result());
     auto info = fixture.find_all<DenseSimpleExpandFunction>();
     EXPECT_TRUE(info.empty());
+
+    EvalFixture old_slow_fixture(old_engine, expr, param_repo, false);
+    EvalFixture old_fixture(old_engine, expr, param_repo, true);
+    EXPECT_EQ(old_fixture.result(), EvalFixture::ref(expr, param_repo));
+    EXPECT_EQ(old_fixture.result(), old_slow_fixture.result());
+    info = old_fixture.find_all<DenseSimpleExpandFunction>();
+    EXPECT_TRUE(info.empty());
 }
 
 TEST(ExpandTest, simple_expand_is_optimized) {
diff --git a/eval/src/tests/instruction/dense_tensor_peek_function/dense_tensor_peek_function_test.cpp b/eval/src/tests/instruction/dense_tensor_peek_function/dense_tensor_peek_function_test.cpp
index b82c88d046f..df9271784b9 100644
--- a/eval/src/tests/instruction/dense_tensor_peek_function/dense_tensor_peek_function_test.cpp
+++ b/eval/src/tests/instruction/dense_tensor_peek_function/dense_tensor_peek_function_test.cpp
@@ -1,5 +1,6 @@
 // Copyright 2019 Oath Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
+#include <vespa/eval/eval/fast_value.h>
 #include <vespa/eval/eval/tensor_function.h>
 #include <vespa/eval/eval/test/eval_fixture.h>
 #include <vespa/eval/eval/test/tensor_model.hpp>
@@ -14,7 +15,8 @@ using namespace vespalib::eval;
 using namespace vespalib::eval::test;
 using namespace vespalib::eval::tensor_function;
 
-const TensorEngine &prod_engine = tensor::DefaultTensorEngine::ref();
+const TensorEngine &old_engine = tensor::DefaultTensorEngine::ref();
+const ValueBuilderFactory &prod_factory = FastValueBuilderFactory::get();
 
 EvalFixture::ParamRepo make_params() {
     return EvalFixture::ParamRepo()
@@ -31,7 +33,7 @@ EvalFixture::ParamRepo make_params() {
 EvalFixture::ParamRepo param_repo = make_params();
 
 void verify(const vespalib::string &expr, double expect, size_t expect_optimized_cnt, size_t expect_not_optimized_cnt) {
-    EvalFixture fixture(prod_engine, expr, param_repo, true);
+    EvalFixture fixture(prod_factory, expr, param_repo, true);
     auto expect_spec = TensorSpec("double").add({}, expect);
     EXPECT_EQUAL(EvalFixture::ref(expr, param_repo), expect_spec);
     EXPECT_EQUAL(fixture.result(), expect_spec);
@@ -41,6 +43,15 @@ void verify(const vespalib::string &expr, double expect, size_t expect_optimized
         EXPECT_TRUE(info[i]->result_is_mutable());
     }
     EXPECT_EQUAL(fixture.find_all<Peek>().size(), expect_not_optimized_cnt);
+
+    EvalFixture old_fixture(old_engine, expr, param_repo, true);
+    EXPECT_EQUAL(old_fixture.result(), expect_spec);
+    info = old_fixture.find_all<DenseTensorPeekFunction>();
+    EXPECT_EQUAL(info.size(), expect_optimized_cnt);
+    for (size_t i = 0; i < info.size(); ++i) {
+        EXPECT_TRUE(info[i]->result_is_mutable());
+    }
+    EXPECT_EQUAL(old_fixture.find_all<Peek>().size(), expect_not_optimized_cnt);
 }
 
 //-----------------------------------------------------------------------------