Merge pull request #4995 from vespa-engine/havardpe/gc-deprecated-tests

gc deprecated tests

5 files changed, 0 insertions, 318 deletions

diff --git a/eval/CMakeLists.txt b/eval/CMakeLists.txt
index 8378af53098..3e0c0a12a4f 100644
--- a/eval/CMakeLists.txt
+++ b/eval/CMakeLists.txt
@@ -27,7 +27,6 @@ vespa_define_module(
     src/tests/tensor/dense_dot_product_function
     src/tests/tensor/dense_tensor_address_combiner
     src/tests/tensor/dense_tensor_builder
-    src/tests/tensor/dense_tensor_function_optimizer
     src/tests/tensor/dense_xw_product_function
     src/tests/tensor/vector_from_doubles_function
     src/tests/tensor/sparse_tensor_builder
diff --git a/eval/src/tests/eval/interpreted_function/interpreted_function_test.cpp b/eval/src/tests/eval/interpreted_function/interpreted_function_test.cpp
index 6b11e2e7034..714eb870b3e 100644
--- a/eval/src/tests/eval/interpreted_function/interpreted_function_test.cpp
+++ b/eval/src/tests/eval/interpreted_function/interpreted_function_test.cpp
@@ -154,156 +154,6 @@ TEST("require that basic addition works") {
 
 //-----------------------------------------------------------------------------
 
-struct InnerProduct {
-    const TensorEngine &engine;
-    Function            function;
-    TensorSpec          a;
-    TensorSpec          b;
-    TensorSpec          expect;
-    NodeTypes           types;
-    InterpretedFunction interpreted;
-    ~InnerProduct() {}
-    InnerProduct(const vespalib::string &expr)
-        : engine(DefaultTensorEngine::ref()),
-          function(Function::parse({"a", "b"}, expr)),
-          a("null"), b("null"), expect("null"),
-          types(),
-          interpreted(engine, function, types) {}
-    InnerProduct(const vespalib::string &expr,
-              TensorSpec a_in,
-              TensorSpec b_in,
-              TensorSpec expect_in)
-        : engine(DefaultTensorEngine::ref()),
-          function(Function::parse(expr)),
-          a(a_in), b(b_in), expect(expect_in),
-          types(function, {ValueType::from_spec(a.type()), ValueType::from_spec(b.type())}),
-          interpreted(engine, function, types) {}
-    void verify_optimized() const {
-        EXPECT_LESS(interpreted.program_size(), 4u);
-        InterpretedFunction::Context ctx(interpreted);
-        Value::UP va = engine.from_spec(a);
-        Value::UP vb = engine.from_spec(b);
-        SimpleObjectParams params({*va,*vb});
-        const Value &result = interpreted.eval(ctx, params);
-        EXPECT_EQUAL(engine.to_spec(result), expect);
-    }
-    void verify_not_optimized() const {
-        EXPECT_EQUAL(4u, interpreted.program_size());
-    }
-};
-
-struct UntypedIP : InnerProduct {
-    UntypedIP(const vespalib::string &expr) : InnerProduct(expr) {
-        a = TensorSpec("double").add({}, 2.0);
-        b = TensorSpec("double").add({}, 3.0);
-        expect = TensorSpec("double").add({}, 6.0);
-    }
-};
-
-struct DotProduct : InnerProduct {
-    DotProduct(const vespalib::string &expr)
-        : InnerProduct(expr,
-                       TensorSpec("tensor(x[3])")
-                       .add({{"x", 0}}, 5.0)
-                       .add({{"x", 1}}, 3.0)
-                       .add({{"x", 2}}, 2.0),
-                       TensorSpec("tensor(x[3])")
-                       .add({{"x", 0}}, 7.0)
-                       .add({{"x", 1}}, 11.0)
-                       .add({{"x", 2}}, 13.0),
-                       TensorSpec("double")
-                       .add({}, (5.0 * 7.0) + (3.0 * 11.0) + (2.0 * 13.0))) {}
-};
-
-struct XW : InnerProduct {
-    XW(const vespalib::string &expr)
-        : InnerProduct(expr,
-                       TensorSpec("tensor(x[2])")
-                       .add({{"x", 0}},  1.0)
-                       .add({{"x", 1}},  2.0),
-                       TensorSpec("tensor(x[2],y[3])")
-                       .add({{"y", 0},{"x", 0}},  3.0)
-                       .add({{"y", 0},{"x", 1}},  5.0)
-                       .add({{"y", 1},{"x", 0}},  7.0)
-                       .add({{"y", 1},{"x", 1}}, 11.0)
-                       .add({{"y", 2},{"x", 0}}, 13.0)
-                       .add({{"y", 2},{"x", 1}}, 17.0),
-                       TensorSpec("tensor(y[3])")
-                       .add({{"y", 0}}, (1.0 *  3.0) + (2.0 *  5.0))
-                       .add({{"y", 1}}, (1.0 *  7.0) + (2.0 * 11.0))
-                       .add({{"y", 2}}, (1.0 * 13.0) + (2.0 * 17.0))) {}
-};
-
-struct MatMul : InnerProduct {
-    MatMul(const vespalib::string &expr)
-        : InnerProduct(expr,
-                       TensorSpec("tensor(x[2],y[2])")
-                       .add({{"x", 0},{"y", 0}},  1.0)
-                       .add({{"x", 0},{"y", 1}},  2.0)
-                       .add({{"x", 1},{"y", 0}},  3.0)
-                       .add({{"x", 1},{"y", 1}},  5.0),
-                       TensorSpec("tensor(y[2],z[2])")
-                       .add({{"y", 0},{"z", 0}},  7.0)
-                       .add({{"y", 0},{"z", 1}}, 11.0)
-                       .add({{"y", 1},{"z", 0}}, 13.0)
-                       .add({{"y", 1},{"z", 1}}, 17.0),
-                       TensorSpec("tensor(x[2],z[2])")
-                       .add({{"x", 0},{"z", 0}}, (1.0 *  7.0) + (2.0 * 13.0))
-                       .add({{"x", 0},{"z", 1}}, (1.0 * 11.0) + (2.0 * 17.0))
-                       .add({{"x", 1},{"z", 0}}, (3.0 *  7.0) + (5.0 * 13.0))
-                       .add({{"x", 1},{"z", 1}}, (3.0 * 11.0) + (5.0 * 17.0))) {}
-};
-
-TEST("require that inner product is not optimized for unknown types") {
-    TEST_DO(UntypedIP("reduce(a*b,sum)").verify_not_optimized());
-    TEST_DO(UntypedIP("reduce(join(a,b,f(x,y)(x*y)),sum)").verify_not_optimized());
-}
-
-TEST("require that dot product works with tensor function") {
-    TEST_DO(DotProduct("reduce(a*b,sum)").verify_optimized());
-    TEST_DO(DotProduct("reduce(join(a,b,f(x,y)(x*y)),sum)").verify_optimized());
-    TEST_DO(DotProduct("reduce(b*a,sum)").verify_optimized());
-    TEST_DO(DotProduct("reduce(join(b,a,f(x,y)(x*y)),sum)").verify_optimized());
-    TEST_DO(DotProduct("reduce(join(a,b,f(x,y)(y*x)),sum)").verify_optimized());
-    TEST_DO(DotProduct("reduce(join(b,a,f(x,y)(y*x)),sum)").verify_optimized());
-    TEST_DO(DotProduct("reduce(a*b,sum,x)").verify_optimized());
-    TEST_DO(DotProduct("reduce(join(a,b,f(x,y)(x*y)),sum,x)").verify_optimized());
-    TEST_DO(DotProduct("reduce(b*a,sum,x)").verify_optimized());
-    TEST_DO(DotProduct("reduce(join(b,a,f(x,y)(x*y)),sum,x)").verify_optimized());
-    TEST_DO(DotProduct("reduce(join(a,b,f(x,y)(y*x)),sum,x)").verify_optimized());
-    TEST_DO(DotProduct("reduce(join(b,a,f(x,y)(y*x)),sum,x)").verify_optimized());
-}
-
-TEST("require that vector matrix multiplication works with tensor function") {
-    TEST_DO(XW("reduce(a*b,sum,x)").verify_optimized());
-    TEST_DO(XW("reduce(join(a,b,f(x,y)(x*y)),sum,x)").verify_optimized());
-    TEST_DO(XW("reduce(b*a,sum,x)").verify_optimized());
-    TEST_DO(XW("reduce(join(b,a,f(x,y)(x*y)),sum,x)").verify_optimized());
-    TEST_DO(XW("reduce(join(a,b,f(x,y)(y*x)),sum,x)").verify_optimized());
-    TEST_DO(XW("reduce(join(b,a,f(x,y)(y*x)),sum,x)").verify_optimized());
-}
-
-TEST("require that matrix multiplication is not optimized (yet)") {
-    TEST_DO(MatMul("reduce(a*b,sum,y)").verify_not_optimized());
-    TEST_DO(MatMul("reduce(join(a,b,f(x,y)(x*y)),sum,y)").verify_not_optimized());
-    TEST_DO(MatMul("reduce(b*a,sum,y)").verify_not_optimized());
-    TEST_DO(MatMul("reduce(join(b,a,f(x,y)(x*y)),sum,y)").verify_not_optimized());
-    TEST_DO(MatMul("reduce(join(a,b,f(x,y)(y*x)),sum,y)").verify_not_optimized());
-    TEST_DO(MatMul("reduce(join(b,a,f(x,y)(y*x)),sum,y)").verify_not_optimized());
-}
-
-TEST("require that expressions similar to inner product are not optimized") {
-    TEST_DO(DotProduct("reduce(a*b,prod)").verify_not_optimized());
-    TEST_DO(DotProduct("reduce(a*b,max)").verify_not_optimized());
-    TEST_DO(DotProduct("reduce(a+b,sum)").verify_not_optimized());
-    TEST_DO(DotProduct("reduce(join(a,b,f(x,y)(x+y)),sum)").verify_not_optimized());
-    TEST_DO(DotProduct("reduce(join(a,b,f(x,y)(x*x)),sum)").verify_not_optimized());
-    TEST_DO(DotProduct("reduce(join(a,b,f(x,y)(y*y)),sum)").verify_not_optimized());
-    TEST_DO(DotProduct("reduce(join(a,b,f(x,y)(x*y*1)),sum)").verify_not_optimized());
-}
-
-//-----------------------------------------------------------------------------
-
 TEST("require that functions with non-compilable lambdas cannot be interpreted") {
     auto good_map = Function::parse("map(a,f(x)(x+1))");
     auto good_join = Function::parse("join(a,b,f(x,y)(x+y))");
diff --git a/eval/src/tests/tensor/dense_tensor_function_optimizer/CMakeLists.txt b/eval/src/tests/tensor/dense_tensor_function_optimizer/CMakeLists.txt
deleted file mode 100644
index 3a95ef776d7..00000000000
--- a/eval/src/tests/tensor/dense_tensor_function_optimizer/CMakeLists.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-# Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-vespa_add_executable(eval_dense_tensor_function_optimizer_test_app TEST
-    SOURCES
-    dense_tensor_function_optimizer_test.cpp
-    DEPENDS
-    vespaeval
-)
-vespa_add_test(NAME eval_dense_tensor_function_optimizer_test_app COMMAND eval_dense_tensor_function_optimizer_test_app)
diff --git a/eval/src/tests/tensor/dense_tensor_function_optimizer/FILES b/eval/src/tests/tensor/dense_tensor_function_optimizer/FILES
deleted file mode 100644
index 3c4ec2f1753..00000000000
--- a/eval/src/tests/tensor/dense_tensor_function_optimizer/FILES
+++ /dev/null
@@ -1 +0,0 @@
-dense_tensor_function_compiler_test.cpp
diff --git a/eval/src/tests/tensor/dense_tensor_function_optimizer/dense_tensor_function_optimizer_test.cpp b/eval/src/tests/tensor/dense_tensor_function_optimizer/dense_tensor_function_optimizer_test.cpp
deleted file mode 100644
index 269a1e265c5..00000000000
--- a/eval/src/tests/tensor/dense_tensor_function_optimizer/dense_tensor_function_optimizer_test.cpp
+++ /dev/null
@@ -1,158 +0,0 @@
-// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-
-#include <vespa/vespalib/testkit/test_kit.h>
-#include <vespa/eval/tensor/dense/dense_dot_product_function.h>
-#include <vespa/eval/tensor/dense/dense_xw_product_function.h>
-#include <vespa/eval/eval/operation.h>
-
-using namespace vespalib::eval;
-using namespace vespalib::eval::operation;
-using namespace vespalib::eval::tensor_function;
-using namespace vespalib::tensor;
-using vespalib::Stash;
-
-//-----------------------------------------------------------------------------
-
-const TensorFunction &
-optimizeDotProduct(const vespalib::string &lhsType,
-                  const vespalib::string &rhsType,
-                  Stash &stash)
-{
-    const Node &reduceNode = reduce(join(inject(ValueType::from_spec(lhsType), 1, stash),
-                                         inject(ValueType::from_spec(rhsType), 3, stash),
-                                         Mul::f, stash),
-                                    Aggr::SUM, {}, stash);
-    return DenseDotProductFunction::optimize(reduceNode, stash);
-}
-
-void assertParam(const TensorFunction &node, size_t expect_idx) {
-    auto inject = as<Inject>(node);
-    ASSERT_TRUE(inject);
-    EXPECT_EQUAL(inject->param_idx(), expect_idx);
-}
-
-void
-assertOptimizedDotProduct(const vespalib::string &lhsType,
-                          const vespalib::string &rhsType)
-{
-    Stash stash;
-    const TensorFunction &func = optimizeDotProduct(lhsType, rhsType, stash);
-    const DenseDotProductFunction *dotProduct = as<DenseDotProductFunction>(func);
-    ASSERT_TRUE(dotProduct);
-    TEST_DO(assertParam(dotProduct->lhs(), 1));
-    TEST_DO(assertParam(dotProduct->rhs(), 3));
-}
-
-void
-assertNotOptimizedDotProduct(const vespalib::string &lhsType,
-                            const vespalib::string &rhsType)
-{
-    Stash stash;
-    const TensorFunction &func = optimizeDotProduct(lhsType, rhsType, stash);
-    const Reduce *reduce = as<Reduce>(func);
-    EXPECT_TRUE(reduce);
-}
-
-//-----------------------------------------------------------------------------
-
-const TensorFunction &
-optimizeXWProduct(const vespalib::string &lhsType,
-                 const vespalib::string &rhsType,
-                 const vespalib::string &dim,
-                 Stash &stash)
-{
-    const Node &reduceNode = reduce(join(inject(ValueType::from_spec(lhsType), 1, stash),
-                                         inject(ValueType::from_spec(rhsType), 3, stash),
-                                         Mul::f, stash),
-                                    Aggr::SUM, {dim}, stash);
-    return DenseXWProductFunction::optimize(reduceNode, stash);
-}
-
-void
-assertOptimizedXWProduct(const vespalib::string &vecTypeStr,
-                        const vespalib::string &matTypeStr,
-                        const vespalib::string &dim)
-{
-    Stash stash;
-    const TensorFunction &func = optimizeXWProduct(vecTypeStr, matTypeStr, dim, stash);
-    const TensorFunction &inv_func = optimizeXWProduct(matTypeStr, vecTypeStr, dim, stash);
-    const DenseXWProductFunction *xwProduct = as<DenseXWProductFunction>(func);
-    const DenseXWProductFunction *inv_xwProduct = as<DenseXWProductFunction>(inv_func);
-    ValueType vecType = ValueType::from_spec(vecTypeStr);
-    ValueType matType = ValueType::from_spec(matTypeStr);
-    size_t common_idx = matType.dimension_index(vecType.dimensions()[0].name);
-    ASSERT_TRUE(xwProduct);
-    ASSERT_TRUE(inv_xwProduct);
-    ASSERT_TRUE(common_idx != ValueType::Dimension::npos);
-    TEST_DO(assertParam(xwProduct->lhs(), 1));
-    TEST_DO(assertParam(inv_xwProduct->lhs(), 3));
-    TEST_DO(assertParam(xwProduct->rhs(), 3));
-    TEST_DO(assertParam(inv_xwProduct->rhs(), 1));
-    EXPECT_EQUAL(xwProduct->vectorSize(), vecType.dimensions()[0].size);
-    EXPECT_EQUAL(inv_xwProduct->vectorSize(), vecType.dimensions()[0].size);
-    EXPECT_EQUAL(xwProduct->resultSize(), matType.dimensions()[1 - common_idx].size);
-    EXPECT_EQUAL(inv_xwProduct->resultSize(), matType.dimensions()[1 - common_idx].size);
-    EXPECT_EQUAL(xwProduct->matrixHasCommonDimensionInnermost(), (common_idx == 1));
-    EXPECT_EQUAL(inv_xwProduct->matrixHasCommonDimensionInnermost(), (common_idx == 1));
-}
-
-void
-assertNotOptimizedXWProduct(const vespalib::string &vecType,
-                           const vespalib::string &matType,
-                           const vespalib::string &dim)
-{
-    Stash stash;
-    const TensorFunction &func = optimizeXWProduct(vecType, matType, dim, stash);
-    const TensorFunction &inv_func = optimizeXWProduct(matType, vecType, dim, stash);
-    const Reduce *reduce = as<Reduce>(func);
-    const Reduce *inv_reduce = as<Reduce>(inv_func);
-    EXPECT_TRUE(reduce);
-    EXPECT_TRUE(inv_reduce);
-}
-
-//-----------------------------------------------------------------------------
-
-TEST("require that dot product with compatible dimensions is optimized")
-{
-    TEST_DO(assertOptimizedDotProduct("tensor(x[5])", "tensor(x[5])"));
-    TEST_DO(assertOptimizedDotProduct("tensor(x[3])", "tensor(x[5])"));
-    TEST_DO(assertOptimizedDotProduct("tensor(x[5])", "tensor(x[3])"));
-    TEST_DO(assertOptimizedDotProduct("tensor(x[])",  "tensor(x[5])"));
-    TEST_DO(assertOptimizedDotProduct("tensor(x[5])", "tensor(x[])"));
-    TEST_DO(assertOptimizedDotProduct("tensor(x[])",  "tensor(x[])"));
-}
-
-TEST("require that dot product with incompatible dimensions is NOT optimized")
-{
-    TEST_DO(assertNotOptimizedDotProduct("tensor(x[5])",      "tensor(y[5])"));
-    TEST_DO(assertNotOptimizedDotProduct("tensor(y[5])",      "tensor(x[5])"));
-    TEST_DO(assertNotOptimizedDotProduct("tensor(y[])",       "tensor(x[])"));
-    TEST_DO(assertNotOptimizedDotProduct("tensor(x[5])",      "tensor(x[5],y[7])"));
-    TEST_DO(assertNotOptimizedDotProduct("tensor(x[5],y[7])", "tensor(x[5],y[7])"));
-}
-
-//-----------------------------------------------------------------------------
-
-TEST("require that xw products with compatible dimensions are optimized") {
-    TEST_DO(assertOptimizedXWProduct("tensor(x[3])", "tensor(x[3],y[4])", "x"));
-    TEST_DO(assertOptimizedXWProduct("tensor(y[4])", "tensor(x[3],y[4])", "y"));
-}
-
-TEST("require that xw products with incompatible dimensions are not optimized") {
-    TEST_DO(assertNotOptimizedXWProduct("tensor(x[3])", "tensor(x[3],y[4])", "y"));
-    TEST_DO(assertNotOptimizedXWProduct("tensor(x[])",  "tensor(x[3],y[4])", "x"));
-    TEST_DO(assertNotOptimizedXWProduct("tensor(x[3])", "tensor(x[],y[4])",  "x"));
-    TEST_DO(assertNotOptimizedXWProduct("tensor(x[3])", "tensor(x[3],y[])",  "x"));
-    TEST_DO(assertNotOptimizedXWProduct("tensor(x[2])", "tensor(x[3],y[4])", "x"));
-    TEST_DO(assertNotOptimizedXWProduct("tensor(x[4])", "tensor(x[3],y[4])", "x"));
-    TEST_DO(assertNotOptimizedXWProduct("tensor(x[3])", "tensor(y[3],z[4])", "x"));
-    TEST_DO(assertNotOptimizedXWProduct("tensor(x[3])", "tensor(y[3],z[4])", "y"));
-    TEST_DO(assertNotOptimizedXWProduct("tensor(x[3])", "tensor(y[3],z[4])", "z"));
-    TEST_DO(assertNotOptimizedXWProduct("tensor(y[4])", "tensor(x[3],y[4])", "x"));
-    TEST_DO(assertNotOptimizedXWProduct("tensor(y[3])", "tensor(x[3],y[4])", "y"));
-    TEST_DO(assertNotOptimizedXWProduct("tensor(y[5])", "tensor(x[3],y[4])", "y"));
-}
-
-//-----------------------------------------------------------------------------
-
-TEST_MAIN() { TEST_RUN_ALL(); }