diff options
Diffstat (limited to 'vespalib/src/tests/tensor')
38 files changed, 429 insertions, 1260 deletions
diff --git a/vespalib/src/tests/tensor/compact_tensor_builder/.gitignore b/vespalib/src/tests/tensor/compact_tensor_builder/.gitignore deleted file mode 100644 index 57abfa0f6a9..00000000000 --- a/vespalib/src/tests/tensor/compact_tensor_builder/.gitignore +++ /dev/null @@ -1 +0,0 @@ -vespalib_compact_tensor_builder_test_app diff --git a/vespalib/src/tests/tensor/compact_tensor_builder/CMakeLists.txt b/vespalib/src/tests/tensor/compact_tensor_builder/CMakeLists.txt deleted file mode 100644 index c9cd5c0387d..00000000000 --- a/vespalib/src/tests/tensor/compact_tensor_builder/CMakeLists.txt +++ /dev/null @@ -1,9 +0,0 @@ -# Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -vespa_add_executable(vespalib_compact_tensor_builder_test_app TEST - SOURCES - compact_tensor_builder_test.cpp - DEPENDS - vespalib - vespalib_vespalib_tensor -) -vespa_add_test(NAME vespalib_compact_tensor_builder_test_app COMMAND vespalib_compact_tensor_builder_test_app) diff --git a/vespalib/src/tests/tensor/compact_tensor_builder/FILES b/vespalib/src/tests/tensor/compact_tensor_builder/FILES deleted file mode 100644 index f31a47be268..00000000000 --- a/vespalib/src/tests/tensor/compact_tensor_builder/FILES +++ /dev/null @@ -1 +0,0 @@ -compact_tensor_builder_test.cpp diff --git a/vespalib/src/tests/tensor/compact_tensor_builder/compact_tensor_builder_test.cpp b/vespalib/src/tests/tensor/compact_tensor_builder/compact_tensor_builder_test.cpp deleted file mode 100644 index e8b5d3e141c..00000000000 --- a/vespalib/src/tests/tensor/compact_tensor_builder/compact_tensor_builder_test.cpp +++ /dev/null @@ -1,58 +0,0 @@ -// Copyright 2016 Yahoo Inc. 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/vespalib/tensor/compact/compact_tensor_builder.h> - -using namespace vespalib::tensor; - - -void -assertCellValue(double expValue, const TensorAddress &address, const CompactTensor::Cells &cells) -{ - CompactTensorAddressBuilder addressBuilder; - for (const auto &element : address.elements()) { - addressBuilder.add(element.dimension(), element.label()); - } - CompactTensorAddressRef addressRef(addressBuilder.getAddressRef()); - auto itr = cells.find(addressRef); - EXPECT_FALSE(itr == cells.end()); - EXPECT_EQUAL(expValue, itr->second); -} - -TEST("require that tensor can be constructed") -{ - CompactTensorBuilder builder; - builder.add_label(builder.define_dimension("a"), "1"). - add_label(builder.define_dimension("b"), "2").add_cell(10). - add_label(builder.define_dimension("c"), "3"). - add_label(builder.define_dimension("d"), "4").add_cell(20); - Tensor::UP tensor = builder.build(); - const CompactTensor &compactTensor = dynamic_cast<const CompactTensor &>(*tensor); - const CompactTensor::Cells &cells = compactTensor.cells(); - EXPECT_EQUAL(2u, cells.size()); - assertCellValue(10, TensorAddress({{"a","1"},{"b","2"}}), cells); - assertCellValue(20, TensorAddress({{"c","3"},{"d","4"}}), cells); -} - -TEST("require that dimensions are extracted") -{ - CompactTensorBuilder builder; - builder.define_dimension("c"); - builder.define_dimension("a"); - builder.define_dimension("b"); - builder. - add_label(builder.define_dimension("a"), "1"). - add_label(builder.define_dimension("b"), "2").add_cell(10). - add_label(builder.define_dimension("b"), "3"). - add_label(builder.define_dimension("c"), "4").add_cell(20); - Tensor::UP tensor = builder.build(); - const CompactTensor &compactTensor = dynamic_cast<const CompactTensor &>(*tensor); - const CompactTensor::Dimensions &dims = compactTensor.dimensions(); - EXPECT_EQUAL(3u, dims.size()); - EXPECT_EQUAL("a", dims[0]); - EXPECT_EQUAL("b", dims[1]); - EXPECT_EQUAL("c", dims[2]); - EXPECT_EQUAL("tensor(a{},b{},c{})", compactTensor.getType().to_spec()); -} - -TEST_MAIN() { TEST_RUN_ALL(); } diff --git a/vespalib/src/tests/tensor/compact_tensor_v2_builder/.gitignore b/vespalib/src/tests/tensor/compact_tensor_v2_builder/.gitignore deleted file mode 100644 index 22edb7555be..00000000000 --- a/vespalib/src/tests/tensor/compact_tensor_v2_builder/.gitignore +++ /dev/null @@ -1 +0,0 @@ -vespalib_compact_tensor_v2_builder_test_app diff --git a/vespalib/src/tests/tensor/compact_tensor_v2_builder/CMakeLists.txt b/vespalib/src/tests/tensor/compact_tensor_v2_builder/CMakeLists.txt deleted file mode 100644 index 2bddcd3f021..00000000000 --- a/vespalib/src/tests/tensor/compact_tensor_v2_builder/CMakeLists.txt +++ /dev/null @@ -1,9 +0,0 @@ -# Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -vespa_add_executable(vespalib_compact_tensor_v2_builder_test_app TEST - SOURCES - compact_tensor_v2_builder_test.cpp - DEPENDS - vespalib - vespalib_vespalib_tensor -) -vespa_add_test(NAME vespalib_compact_tensor_v2_builder_test_app COMMAND vespalib_compact_tensor_v2_builder_test_app) diff --git a/vespalib/src/tests/tensor/compact_tensor_v2_builder/FILES b/vespalib/src/tests/tensor/compact_tensor_v2_builder/FILES deleted file mode 100644 index 196c68833da..00000000000 --- a/vespalib/src/tests/tensor/compact_tensor_v2_builder/FILES +++ /dev/null @@ -1 +0,0 @@ -compact_tensor_v2_builder_test.cpp diff --git a/vespalib/src/tests/tensor/dense_tensor_address_combiner/CMakeLists.txt b/vespalib/src/tests/tensor/dense_tensor_address_combiner/CMakeLists.txt new file mode 100644 index 00000000000..65e7c711b19 --- /dev/null +++ b/vespalib/src/tests/tensor/dense_tensor_address_combiner/CMakeLists.txt @@ -0,0 +1,9 @@ +# Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +vespa_add_executable(vespalib_dense_tensor_address_combiner_test_app TEST + SOURCES + dense_tensor_address_combiner_test.cpp + DEPENDS + vespalib + vespalib_vespalib_tensor +) +vespa_add_test(NAME vespalib_dense_tensor_address_combiner_test_app COMMAND vespalib_dense_tensor_address_combiner_test_app) diff --git a/vespalib/src/tests/tensor/dense_tensor_address_combiner/FILES b/vespalib/src/tests/tensor/dense_tensor_address_combiner/FILES new file mode 100644 index 00000000000..0a49bd4647b --- /dev/null +++ b/vespalib/src/tests/tensor/dense_tensor_address_combiner/FILES @@ -0,0 +1 @@ +dense_tensor_address_combiner_test.cpp diff --git a/vespalib/src/tests/tensor/dense_tensor_address_combiner/dense_tensor_address_combiner_test.cpp b/vespalib/src/tests/tensor/dense_tensor_address_combiner/dense_tensor_address_combiner_test.cpp new file mode 100644 index 00000000000..1192469e006 --- /dev/null +++ b/vespalib/src/tests/tensor/dense_tensor_address_combiner/dense_tensor_address_combiner_test.cpp @@ -0,0 +1,36 @@ +// Copyright 2016 Yahoo Inc. 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/vespalib/tensor/dense/dense_tensor_address_combiner.h> +#include <vespa/vespalib/test/insertion_operators.h> + +using namespace vespalib::tensor; +using DimensionsMeta = DenseTensor::DimensionsMeta; + +std::ostream & +operator<<(std::ostream &out, const DenseTensor::DimensionMeta &dimMeta) +{ + out << dimMeta.dimension() << "[" << dimMeta.size() << "]"; + return out; +} + +DimensionsMeta +combine(const DimensionsMeta &lhs, const DimensionsMeta &rhs) +{ + return DenseTensorAddressCombiner::combineDimensions(lhs, rhs); +} + +TEST("require that dimensions can be combined") +{ + EXPECT_EQUAL(DimensionsMeta({{"a", 3}, {"b", 5}}), combine({{"a", 3}}, {{"b", 5}})); + EXPECT_EQUAL(DimensionsMeta({{"a", 3}, {"b", 5}}), combine({{"a", 3}, {"b", 5}}, {{"b", 5}})); + EXPECT_EQUAL(DimensionsMeta({{"a", 3}, {"b", 5}}), combine({{"a", 3}, {"b", 7}}, {{"b", 5}})); + EXPECT_EQUAL(DimensionsMeta({{"a", 3}, {"b", 11}, {"c", 5}, {"d", 7}, {"e", 17}}), + combine({{"a", 3}, {"c", 5}, {"d", 7}}, + {{"b", 11}, {"c", 13}, {"e", 17}})); + EXPECT_EQUAL(DimensionsMeta({{"a", 3}, {"b", 11}, {"c", 5}, {"d", 7}, {"e", 17}}), + combine({{"b", 11}, {"c", 13}, {"e", 17}}, + {{"a", 3}, {"c", 5}, {"d", 7}})); +} + +TEST_MAIN() { TEST_RUN_ALL(); } diff --git a/vespalib/src/tests/tensor/dense_tensor_builder/dense_tensor_builder_test.cpp b/vespalib/src/tests/tensor/dense_tensor_builder/dense_tensor_builder_test.cpp index 8478d46e1f4..595b3743625 100644 --- a/vespalib/src/tests/tensor/dense_tensor_builder/dense_tensor_builder_test.cpp +++ b/vespalib/src/tests/tensor/dense_tensor_builder/dense_tensor_builder_test.cpp @@ -4,11 +4,11 @@ #include <vespa/vespalib/testkit/test_kit.h> #include <vespa/vespalib/tensor/dense/dense_tensor_builder.h> #include <vespa/vespalib/util/exceptions.h> -#include <algorithm> using namespace vespalib::tensor; using vespalib::IllegalArgumentException; using Builder = DenseTensorBuilder; +using vespalib::eval::TensorSpec; void assertTensor(const DenseTensor::DimensionsMeta &expDims, @@ -20,33 +20,71 @@ assertTensor(const DenseTensor::DimensionsMeta &expDims, EXPECT_EQUAL(expCells, realTensor.cells()); } +void +assertTensorSpec(const TensorSpec &expSpec, const Tensor &tensor) +{ + TensorSpec actSpec = tensor.toSpec(); + EXPECT_EQUAL(expSpec, actSpec); +} + struct Fixture { Builder builder; }; +Tensor::UP +build1DTensor(Builder &builder) +{ + Builder::Dimension dimX = builder.defineDimension("x", 3); + builder.addLabel(dimX, 0).addCell(10). + addLabel(dimX, 1).addCell(11). + addLabel(dimX, 2).addCell(12); + return builder.build(); +} + TEST_F("require that 1d tensor can be constructed", Fixture) { - Builder::Dimension dimX = f.builder.defineDimension("x", 3); - f.builder.addLabel(dimX, 0).addCell(10). - addLabel(dimX, 1).addCell(11). - addLabel(dimX, 2).addCell(12); - assertTensor({{"x",3}}, {10,11,12}, - *f.builder.build()); + assertTensor({{"x",3}}, {10,11,12}, *build1DTensor(f.builder)); +} + +TEST_F("require that 1d tensor can be converted to tensor spec", Fixture) +{ + assertTensorSpec(TensorSpec("tensor(x[3])"). + add({{"x", 0}}, 10). + add({{"x", 1}}, 11). + add({{"x", 2}}, 12), + *build1DTensor(f.builder)); +} + +Tensor::UP +build2DTensor(Builder &builder) +{ + Builder::Dimension dimX = builder.defineDimension("x", 3); + Builder::Dimension dimY = builder.defineDimension("y", 2); + builder.addLabel(dimX, 0).addLabel(dimY, 0).addCell(10). + addLabel(dimX, 0).addLabel(dimY, 1).addCell(11). + addLabel(dimX, 1).addLabel(dimY, 0).addCell(12). + addLabel(dimX, 1).addLabel(dimY, 1).addCell(13). + addLabel(dimX, 2).addLabel(dimY, 0).addCell(14). + addLabel(dimX, 2).addLabel(dimY, 1).addCell(15); + return builder.build(); } TEST_F("require that 2d tensor can be constructed", Fixture) { - Builder::Dimension dimX = f.builder.defineDimension("x", 3); - Builder::Dimension dimY = f.builder.defineDimension("y", 2); - f.builder.addLabel(dimX, 0).addLabel(dimY, 0).addCell(10). - addLabel(dimX, 0).addLabel(dimY, 1).addCell(11). - addLabel(dimX, 1).addLabel(dimY, 0).addCell(12). - addLabel(dimX, 1).addLabel(dimY, 1).addCell(13). - addLabel(dimX, 2).addLabel(dimY, 0).addCell(14). - addLabel(dimX, 2).addLabel(dimY, 1).addCell(15); - assertTensor({{"x",3},{"y",2}}, {10,11,12,13,14,15}, - *f.builder.build()); + assertTensor({{"x",3},{"y",2}}, {10,11,12,13,14,15}, *build2DTensor(f.builder)); +} + +TEST_F("require that 2d tensor can be converted to tensor spec", Fixture) +{ + assertTensorSpec(TensorSpec("tensor(x[3],y[2])"). + add({{"x", 0},{"y", 0}}, 10). + add({{"x", 0},{"y", 1}}, 11). + add({{"x", 1},{"y", 0}}, 12). + add({{"x", 1},{"y", 1}}, 13). + add({{"x", 2},{"y", 0}}, 14). + add({{"x", 2},{"y", 1}}, 15), + *build2DTensor(f.builder)); } TEST_F("require that 3d tensor can be constructed", Fixture) @@ -189,7 +227,6 @@ TEST_F("require that already specified label throws exception", Fixture) "Label for dimension 'x' is already specified with value '0'"); } - TEST_F("require that dimensions are sorted", Fixture) { Builder::Dimension dimY = f.builder.defineDimension("y", 3); @@ -205,4 +242,9 @@ TEST_F("require that dimensions are sorted", Fixture) EXPECT_EQUAL("tensor(x[5],y[3])", denseTensor.getType().to_spec()); } + + + + + TEST_MAIN() { TEST_RUN_ALL(); } diff --git a/vespalib/src/tests/tensor/dense_tensor_operations/dense_tensor_operations_test.cpp b/vespalib/src/tests/tensor/dense_tensor_operations/dense_tensor_operations_test.cpp index aea81ad6b77..69642fb1658 100644 --- a/vespalib/src/tests/tensor/dense_tensor_operations/dense_tensor_operations_test.cpp +++ b/vespalib/src/tests/tensor/dense_tensor_operations/dense_tensor_operations_test.cpp @@ -212,76 +212,88 @@ template <typename FixtureType> void testTensorAdd(FixtureType &f) { - f.assertAdd({},{},{}, false); - f.assertAdd({ {{{"x",0}}, 8} }, - { {{{"x",0}}, 3} }, - { {{{"x",0}}, 5} }); - f.assertAdd({ {{{"x",0}}, -2} }, - { {{{"x",0}}, 3} }, - { {{{"x",0}}, -5} }); - f.assertAdd({ {{{"x",0}}, 10}, {{{"x",1}}, 16} }, - { {{{"x",0}}, 3}, {{{"x",1}}, 5} }, - { {{{"x",0}}, 7}, {{{"x",1}}, 11} }); - f.assertAdd({ {{{"x",0},{"y",0}}, 8} }, - { {{{"x",0},{"y",0}}, 3} }, - { {{{"x",0},{"y",0}}, 5} }); + TEST_DO(f.assertAdd({},{},{}, false)); + TEST_DO(f.assertAdd({ {{{"x",0}}, 8} }, + { {{{"x",0}}, 3} }, + { {{{"x",0}}, 5} })); + TEST_DO(f.assertAdd({ {{{"x",0}}, -2} }, + { {{{"x",0}}, 3} }, + { {{{"x",0}}, -5} })); + TEST_DO(f.assertAdd({ {{{"x",0}}, 10}, {{{"x",1}}, 16} }, + { {{{"x",0}}, 3}, {{{"x",1}}, 5} }, + { {{{"x",0}}, 7}, {{{"x",1}}, 11} })); + TEST_DO(f.assertAdd({ {{{"x",0},{"y",0}}, 8} }, + { {{{"x",0},{"y",0}}, 3} }, + { {{{"x",0},{"y",0}}, 5} })); + TEST_DO(f.assertAdd({ {{{"x",0}}, 3} }, + { {{{"x",0}}, 3} }, + { {{{"x",1}}, 5} })); } template <typename FixtureType> void testTensorSubtract(FixtureType &f) { - f.assertSubtract({},{},{}, false); - f.assertSubtract({ {{{"x",0}}, -2} }, - { {{{"x",0}}, 3} }, - { {{{"x",0}}, 5} }); - f.assertSubtract({ {{{"x",0}}, 8} }, - { {{{"x",0}}, 3} }, - { {{{"x",0}}, -5} }); - f.assertSubtract({ {{{"x",0}}, -4}, {{{"x",1}}, -6} }, - { {{{"x",0}}, 3}, {{{"x",1}}, 5} }, - { {{{"x",0}}, 7}, {{{"x",1}}, 11} }); - f.assertSubtract({ {{{"x",0},{"y",0}}, -2} }, - { {{{"x",0},{"y",0}}, 3} }, - { {{{"x",0},{"y",0}}, 5} }); + TEST_DO(f.assertSubtract({},{},{}, false)); + TEST_DO(f.assertSubtract({ {{{"x",0}}, -2} }, + { {{{"x",0}}, 3} }, + { {{{"x",0}}, 5} })); + TEST_DO(f.assertSubtract({ {{{"x",0}}, 8} }, + { {{{"x",0}}, 3} }, + { {{{"x",0}}, -5} })); + TEST_DO(f.assertSubtract({ {{{"x",0}}, -4}, {{{"x",1}}, -6} }, + { {{{"x",0}}, 3}, {{{"x",1}}, 5} }, + { {{{"x",0}}, 7}, {{{"x",1}}, 11} })); + TEST_DO(f.assertSubtract({ {{{"x",0},{"y",0}}, -2} }, + { {{{"x",0},{"y",0}}, 3} }, + { {{{"x",0},{"y",0}}, 5} })); + TEST_DO(f.assertSubtract({ {{{"x",0}}, -5} }, + { {{{"x",1}}, 3} }, + { {{{"x",0}}, 5} })); } template <typename FixtureType> void testTensorMin(FixtureType &f) { - f.assertMin({},{},{}, false); - f.assertMin({ {{{"x",0}}, 3} }, - { {{{"x",0}}, 3} }, - { {{{"x",0}}, 5} }); - f.assertMin({ {{{"x",0}}, -5} }, - { {{{"x",0}}, 3} }, - { {{{"x",0}}, -5} }); - f.assertMin({ {{{"x",0}}, 3}, {{{"x",1}}, 5} }, - { {{{"x",0}}, 3}, {{{"x",1}}, 5} }, - { {{{"x",0}}, 7}, {{{"x",1}}, 11} }); - f.assertMin({ {{{"x",0},{"y",0}}, 3} }, - { {{{"x",0},{"y",0}}, 3} }, - { {{{"x",0},{"y",0}}, 5} }); + TEST_DO(f.assertMin({},{},{}, false)); + TEST_DO(f.assertMin({ {{{"x",0}}, 3} }, + { {{{"x",0}}, 3} }, + { {{{"x",0}}, 5} })); + TEST_DO(f.assertMin({ {{{"x",0}}, -5} }, + { {{{"x",0}}, 3} }, + { {{{"x",0}}, -5} })); + TEST_DO(f.assertMin({ {{{"x",0}}, 3}, {{{"x",1}}, 5} }, + { {{{"x",0}}, 3}, {{{"x",1}}, 5} }, + { {{{"x",0}}, 7}, {{{"x",1}}, 11} })); + TEST_DO(f.assertMin({ {{{"x",0},{"y",0}}, 3} }, + { {{{"x",0},{"y",0}}, 3} }, + { {{{"x",0},{"y",0}}, 5} })); + TEST_DO(f.assertMin({ {{{"x",0}}, 0} }, + { {{{"x",1}}, 3} }, + { {{{"x",0}}, 5} })); } template <typename FixtureType> void testTensorMax(FixtureType &f) { - f.assertMax({},{},{}, false); - f.assertMax({ {{{"x",0}}, 5} }, - { {{{"x",0}}, 3} }, - { {{{"x",0}}, 5} }); - f.assertMax({ {{{"x",0}}, 3} }, - { {{{"x",0}}, 3} }, - { {{{"x",0}}, -5} }); - f.assertMax({ {{{"x",0}}, 7}, {{{"x",1}}, 11} }, - { {{{"x",0}}, 3}, {{{"x",1}}, 5} }, - { {{{"x",0}}, 7}, {{{"x",1}}, 11} }); - f.assertMax({ {{{"x",0},{"y",0}}, 5} }, - { {{{"x",0},{"y",0}}, 3} }, - { {{{"x",0},{"y",0}}, 5} }); + TEST_DO(f.assertMax({},{},{}, false)); + TEST_DO(f.assertMax({ {{{"x",0}}, 5} }, + { {{{"x",0}}, 3} }, + { {{{"x",0}}, 5} })); + TEST_DO(f.assertMax({ {{{"x",0}}, 3} }, + { {{{"x",0}}, 3} }, + { {{{"x",0}}, -5} })); + TEST_DO(f.assertMax({ {{{"x",0}}, 7}, {{{"x",1}}, 11} }, + { {{{"x",0}}, 3}, {{{"x",1}}, 5} }, + { {{{"x",0}}, 7}, {{{"x",1}}, 11} })); + TEST_DO(f.assertMax({ {{{"x",0},{"y",0}}, 5} }, + { {{{"x",0},{"y",0}}, 3} }, + { {{{"x",0},{"y",0}}, 5} })); + TEST_DO(f.assertMax({ {{{"x",0}}, 5} }, + { {{{"x",1}}, 3} }, + { {{{"x",0}}, 5} })); } template <typename FixtureType> diff --git a/vespalib/src/tests/tensor/join_tensor_addresses/.gitignore b/vespalib/src/tests/tensor/join_tensor_addresses/.gitignore deleted file mode 100644 index bcf856a9f59..00000000000 --- a/vespalib/src/tests/tensor/join_tensor_addresses/.gitignore +++ /dev/null @@ -1 +0,0 @@ -vespalib_join_tensor_addresses_test_app diff --git a/vespalib/src/tests/tensor/join_tensor_addresses/CMakeLists.txt b/vespalib/src/tests/tensor/join_tensor_addresses/CMakeLists.txt deleted file mode 100644 index 6923cbc1133..00000000000 --- a/vespalib/src/tests/tensor/join_tensor_addresses/CMakeLists.txt +++ /dev/null @@ -1,9 +0,0 @@ -# Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -vespa_add_executable(vespalib_join_tensor_addresses_test_app TEST - SOURCES - join_tensor_addresses_test.cpp - DEPENDS - vespalib - vespalib_vespalib_tensor -) -vespa_add_test(NAME vespalib_join_tensor_addresses_test_app COMMAND vespalib_join_tensor_addresses_test_app) diff --git a/vespalib/src/tests/tensor/join_tensor_addresses/FILES b/vespalib/src/tests/tensor/join_tensor_addresses/FILES deleted file mode 100644 index ad4ab2f6d87..00000000000 --- a/vespalib/src/tests/tensor/join_tensor_addresses/FILES +++ /dev/null @@ -1 +0,0 @@ -join_tensor_addresses_test.cpp diff --git a/vespalib/src/tests/tensor/join_tensor_addresses/join_tensor_addresses_test.cpp b/vespalib/src/tests/tensor/join_tensor_addresses/join_tensor_addresses_test.cpp deleted file mode 100644 index f00cd23e322..00000000000 --- a/vespalib/src/tests/tensor/join_tensor_addresses/join_tensor_addresses_test.cpp +++ /dev/null @@ -1,317 +0,0 @@ -// Copyright 2016 Yahoo Inc. 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/vespalib/stllike/hash_set.h> -#include <vespa/vespalib/tensor/tensor_address.h> -#include <vespa/vespalib/tensor/tensor_address_builder.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_address.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_address_builder.h> -#include <vespa/vespalib/tensor/tensor_address_element_iterator.h> -#include <vespa/vespalib/tensor/dimensions_vector_iterator.h> -#include <vespa/vespalib/tensor/join_tensor_addresses.h> - -using namespace vespalib::tensor; - -using TensorAddressMap = std::map<std::string, std::string>; -using TensorAddressElementVec = - std::vector<std::pair<std::string, std::string>>; - -namespace vespalib -{ - -std::ostream & -operator<<(std::ostream &out, const TensorAddressElementVec &vec) -{ - out << "{"; - bool first = true; - for (const auto &elem : vec) { - if (!first) { - out << ","; - } - out << "{\"" << elem.first << "\",\"" << elem.second << "\"}"; - first = false; - } - out << "}"; - return out; -}; - -} - - -class DummyAddressBuilder -{ - TensorAddressElementVec _elements; -public: - void add(vespalib::stringref dimension, vespalib::stringref label) - { - _elements.emplace_back(dimension, label); - } - - const TensorAddressElementVec &elements() const { return _elements; } - void clear() { } -}; - - -template <class TensorAddressT> struct FixtureBase; - -template <> struct FixtureBase<TensorAddress> -{ - using AddressType = TensorAddress; - using AddressBuilderType = TensorAddressBuilder; - - static TensorAddress create(TensorAddressBuilder &builder) { - return builder.build(); - } -}; - - -template <> struct FixtureBase<CompactTensorAddress> -{ - using AddressType = CompactTensorAddress; - using AddressBuilderType = CompactTensorAddressBuilder; - - vespalib::Stash _stash; - - CompactTensorAddress - create(CompactTensorAddressBuilder &builder) - { - CompactTensorAddressRef oldRef = builder.getAddressRef(); - CompactTensorAddressRef newRef(oldRef, _stash); - CompactTensorAddress ret; - ret.deserializeFromSparseAddressRef(newRef); - return ret; - } -}; - -template <> struct FixtureBase<CompactTensorAddressRef> -{ - using AddressType = CompactTensorAddressRef; - using AddressBuilderType = CompactTensorAddressBuilder; - - vespalib::Stash _stash; - - CompactTensorAddressRef - create(CompactTensorAddressBuilder &builder) - { - CompactTensorAddressRef oldRef = builder.getAddressRef(); - CompactTensorAddressRef newRef(oldRef, _stash); - return newRef; - } -}; - -template <class TensorAddressT> struct Fixture - : public FixtureBase<TensorAddressT> -{ - using Parent = FixtureBase<TensorAddressT>; - using AddressType = typename Parent::AddressType; - using AddressBuilderType = typename Parent::AddressBuilderType; - using Parent::create; - - AddressType - create(const TensorAddressMap &address_in) { - AddressBuilderType builder; - for (auto &element : address_in) { - builder.add(element.first, element.second); - } - return create(builder); - } - - void - verifyJoin3Way(bool exp, - const TensorAddressElementVec &expVec, - const DimensionsVector &commonDimensions, - const TensorAddressMap &lhsAddress_in, - const TensorAddressMap &rhsAddress_in) - { - AddressType expAddress = create(lhsAddress_in); - AddressType lhsAddress = create(lhsAddress_in); - AddressType rhsAddress = create(rhsAddress_in); - DummyAddressBuilder builder; - bool act = joinTensorAddresses<DummyAddressBuilder, - AddressType, AddressType> - (builder, commonDimensions, lhsAddress, rhsAddress); - EXPECT_EQUAL(exp, act); - if (exp) { - EXPECT_EQUAL(expVec, builder.elements()); - } - } - - void - verifyJoin2Way(bool exp, - const TensorAddressElementVec &expVec, - const DimensionsSet &commonDimensions, - const TensorAddressMap &lhsAddress_in, - const TensorAddressMap &rhsAddress_in) - { - AddressType expAddress = create(lhsAddress_in); - AddressType lhsAddress = create(lhsAddress_in); - AddressType rhsAddress = create(rhsAddress_in); - DummyAddressBuilder builder; - bool act = joinTensorAddresses<DummyAddressBuilder, - AddressType, AddressType> - (builder, commonDimensions, lhsAddress, rhsAddress); - EXPECT_EQUAL(exp, act); - if (exp) { - EXPECT_EQUAL(expVec, builder.elements()); - } - } - - void - verifyJoin(bool exp, - const TensorAddressElementVec &expVec, - const DimensionsVector &commonDimensions, - const TensorAddressMap &lhsAddress, - const TensorAddressMap &rhsAddress) - { - TEST_DO(verifyJoin3Way(exp, expVec, commonDimensions, - lhsAddress, rhsAddress)); - DimensionsSet commonDimensionsSet(commonDimensions.begin(), - commonDimensions.end()); - TEST_DO(verifyJoin2Way(exp, expVec, commonDimensionsSet, - lhsAddress, rhsAddress)); - } - - void - verifyJoin(const TensorAddressElementVec &expVec, - const DimensionsVector &commonDimensions, - const TensorAddressMap &lhsAddress, - const TensorAddressMap &rhsAddress) - { - verifyJoin(true, expVec, commonDimensions, lhsAddress, rhsAddress); - } - - void - verifyJoinFailure(const DimensionsVector &commonDimensions, - const TensorAddressMap &lhsAddress, - const TensorAddressMap &rhsAddress) - { - verifyJoin(false, {}, commonDimensions, lhsAddress, rhsAddress); - } - - void - verifyJoinFailureOnLabelMisMatch() - { - TEST_DO(verifyJoinFailure({"x", "y"}, - {{"x", "1"}, {"y", "2"}}, - {{"x", "1"}, {"y", "3"}})); - TEST_DO(verifyJoinFailure({"x", "y"}, - {{"x", "1"}, {"y", "2"}}, - {{"x", "2"}, {"y", "2"}})); - TEST_DO(verifyJoinFailure({"y"}, - {{"x", "1"}, {"y", "2"}}, - {{"y", "1"}, {"z", "3"}})); - TEST_DO(verifyJoinFailure({"y"}, - {{"y", "2"}, {"z", "3"}}, - {{"x", "1"}, {"y", "1"}})); - } - - void - verityJoinFailureOnMissingDimension() - { - TEST_DO(verifyJoinFailure({"x", "y"}, - {{"y", "2"}}, - {{"x", "2"}, {"y", "2"}})); - TEST_DO(verifyJoinFailure({"x", "y"}, - {{"x", "1"}, {"y", "2"}}, - {{"y", "2"}})); - TEST_DO(verifyJoinFailure({"x", "y"}, - {{"x", "1"}}, - {{"x", "2"}, {"y", "2"}})); - TEST_DO(verifyJoinFailure({"x", "y"}, - {{"x", "1"}, {"y", "2"}}, - {{"x", "2"}})); - TEST_DO(verifyJoinFailure({"x", "y", "z"}, - {{"x", "1"}, {"z", "3"}}, - {{"x", "2"}, {"y", "2"}, {"z", "3"}})); - TEST_DO(verifyJoinFailure({"x", "y", "z"}, - {{"x", "2"}, {"y", "2"}, {"z", "3"}}, - {{"x", "1"}, {"z", "3"}})); - } - - void - verifyJoinSuccessOnDisjunctDimensions() - { - TEST_DO(verifyJoin({}, {}, {}, {})); - TEST_DO(verifyJoin({{"x", "1"}, {"y", "2"}, {"z", "3"}, {"zz", "4"}}, - {}, - {{"x", "1"}, {"y", "2"}}, - {{"z", "3"}, {"zz", "4"}})); - TEST_DO(verifyJoin({{"x", "1"}, {"y", "2"}, {"z", "3"}, {"zz", "4"}}, - {}, - {{"z", "3"}, {"zz", "4"}}, - {{"x", "1"}, {"y", "2"}})); - TEST_DO(verifyJoin({{"x", "1"}, {"y", "2"}, {"z", "3"}, {"zz", "4"}}, - {}, - {{"x", "1"}, {"z", "3"}}, - {{"y", "2"}, {"zz", "4"}})); - TEST_DO(verifyJoin({{"x", "1"}, {"y", "2"}}, - {}, - {{"x", "1"}, {"y", "2"}}, - {})); - TEST_DO(verifyJoin({{"x", "1"}, {"y", "2"}}, - {}, - {}, - {{"x", "1"}, {"y", "2"}})); - TEST_DO(verifyJoin({{"x", "1"}, {"z", "3"}}, {"y"}, - {{"x", "1"}}, - {{"z", "3"}})); - TEST_DO(verifyJoin( {{"x", "1"}, {"z", "3"}}, {"y"}, - {{"z", "3"}}, - {{"x", "1"}})); - } - - void - verifyJoinSuccessOnOverlappingDimensions() - { - TEST_DO(verifyJoin({{"x", "1"}}, {"x"}, - {{"x", "1"}}, {{"x", "1"}})); - TEST_DO(verifyJoin({{"x", "1"}, {"y", "2"}, {"z", "3"}}, - {"x", "z"}, - {{"x", "1"}, {"y", "2"}, {"z", "3"}}, - {{"x", "1"}, {"z", "3"}})); - TEST_DO(verifyJoin({{"x", "1"}, {"y", "2"}, {"z", "3"}}, - {"x", "z"}, - {{"x", "1"}, {"y", "2"}, {"z", "3"}}, - {{"x", "1"}, {"z", "3"}})); - TEST_DO(verifyJoin( {{"x", "1"}, {"y", "2"}}, {"x", "y"}, - {{"x", "1"}, {"y", "2"}}, - {{"x", "1"}, {"y", "2"}})); - TEST_DO(verifyJoin({{"x", "1"}, {"y", "2"}, {"z", "3"}}, {"y"}, - {{"x", "1"}, {"y", "2"}}, - {{"y", "2"}, {"z", "3"}})); - TEST_DO(verifyJoin({{"x", "1"}, {"y", "2"}, {"z", "3"}}, {"y"}, - {{"y", "2"}, {"z", "3"}}, - {{"x", "1"}, {"y", "2"}})); - } - - void - verifyJoin() - { - verifyJoinSuccessOnDisjunctDimensions(); - verifyJoinSuccessOnOverlappingDimensions(); - verifyJoinFailureOnLabelMisMatch(); - verityJoinFailureOnMissingDimension(); - } - -}; - - -TEST_F("Test that Tensor address can be joined", Fixture<TensorAddress>) -{ - f.verifyJoin(); -} - -TEST_F("Test that compact Tensor address can be joined", - Fixture<CompactTensorAddress>) -{ - f.verifyJoin(); -} - - -TEST_F("Test that compact Tensor address ref can be joined", - Fixture<CompactTensorAddressRef>) -{ - f.verifyJoin(); -} - -TEST_MAIN() { TEST_RUN_ALL(); } diff --git a/vespalib/src/tests/tensor/simple_tensor_builder/.gitignore b/vespalib/src/tests/tensor/simple_tensor_builder/.gitignore deleted file mode 100644 index b8e9dc6dfc5..00000000000 --- a/vespalib/src/tests/tensor/simple_tensor_builder/.gitignore +++ /dev/null @@ -1 +0,0 @@ -vespalib_simple_tensor_builder_test_app diff --git a/vespalib/src/tests/tensor/simple_tensor_builder/CMakeLists.txt b/vespalib/src/tests/tensor/simple_tensor_builder/CMakeLists.txt deleted file mode 100644 index cd67231d418..00000000000 --- a/vespalib/src/tests/tensor/simple_tensor_builder/CMakeLists.txt +++ /dev/null @@ -1,9 +0,0 @@ -# Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -vespa_add_executable(vespalib_simple_tensor_builder_test_app TEST - SOURCES - simple_tensor_builder_test.cpp - DEPENDS - vespalib - vespalib_vespalib_tensor -) -vespa_add_test(NAME vespalib_simple_tensor_builder_test_app COMMAND vespalib_simple_tensor_builder_test_app) diff --git a/vespalib/src/tests/tensor/simple_tensor_builder/FILES b/vespalib/src/tests/tensor/simple_tensor_builder/FILES deleted file mode 100644 index e8940ccf5ef..00000000000 --- a/vespalib/src/tests/tensor/simple_tensor_builder/FILES +++ /dev/null @@ -1 +0,0 @@ -simple_tensor_builder_test.cpp diff --git a/vespalib/src/tests/tensor/simple_tensor_builder/simple_tensor_builder_test.cpp b/vespalib/src/tests/tensor/simple_tensor_builder/simple_tensor_builder_test.cpp deleted file mode 100644 index d43e1606d26..00000000000 --- a/vespalib/src/tests/tensor/simple_tensor_builder/simple_tensor_builder_test.cpp +++ /dev/null @@ -1,52 +0,0 @@ -// Copyright 2016 Yahoo Inc. 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/vespalib/tensor/simple/simple_tensor_builder.h> - -using namespace vespalib::tensor; - -void -assertCellValue(double expValue, const TensorAddress &address, const SimpleTensor::Cells &cells) -{ - auto itr = cells.find(address); - EXPECT_FALSE(itr == cells.end()); - EXPECT_EQUAL(expValue, itr->second); -} - -TEST("require that tensor can be constructed") -{ - SimpleTensorBuilder builder; - builder.add_label(builder.define_dimension("a"), "1"). - add_label(builder.define_dimension("b"), "2").add_cell(10). - add_label(builder.define_dimension("c"), "3"). - add_label(builder.define_dimension("d"), "4").add_cell(20); - Tensor::UP tensor = builder.build(); - const SimpleTensor &simpleTensor = dynamic_cast<const SimpleTensor &>(*tensor); - const SimpleTensor::Cells &cells = simpleTensor.cells(); - EXPECT_EQUAL(2u, cells.size()); - assertCellValue(10, TensorAddress({{"a","1"},{"b","2"}}), cells); - assertCellValue(20, TensorAddress({{"c","3"},{"d","4"}}), cells); -} - -TEST("require that dimensions are extracted") -{ - SimpleTensorBuilder builder; - builder.define_dimension("c"); - builder.define_dimension("a"); - builder.define_dimension("b"); - builder. - add_label(builder.define_dimension("a"), "1"). - add_label(builder.define_dimension("b"), "2").add_cell(10). - add_label(builder.define_dimension("b"), "3"). - add_label(builder.define_dimension("c"), "4").add_cell(20); - Tensor::UP tensor = builder.build(); - const SimpleTensor &simpleTensor = dynamic_cast<const SimpleTensor &>(*tensor); - const SimpleTensor::Dimensions &dims = simpleTensor.dimensions(); - EXPECT_EQUAL(3u, dims.size()); - EXPECT_EQUAL("a", dims[0]); - EXPECT_EQUAL("b", dims[1]); - EXPECT_EQUAL("c", dims[2]); - EXPECT_EQUAL("tensor(a{},b{},c{})", simpleTensor.getType().to_spec()); -} - -TEST_MAIN() { TEST_RUN_ALL(); } diff --git a/vespalib/src/tests/tensor/sparse_tensor_builder/.gitignore b/vespalib/src/tests/tensor/sparse_tensor_builder/.gitignore new file mode 100644 index 00000000000..e0316d190bb --- /dev/null +++ b/vespalib/src/tests/tensor/sparse_tensor_builder/.gitignore @@ -0,0 +1 @@ +vespalib_sparse_tensor_builder_test_app diff --git a/vespalib/src/tests/tensor/sparse_tensor_builder/CMakeLists.txt b/vespalib/src/tests/tensor/sparse_tensor_builder/CMakeLists.txt new file mode 100644 index 00000000000..c8ae7ece908 --- /dev/null +++ b/vespalib/src/tests/tensor/sparse_tensor_builder/CMakeLists.txt @@ -0,0 +1,9 @@ +# Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +vespa_add_executable(vespalib_sparse_tensor_builder_test_app TEST + SOURCES + sparse_tensor_builder_test.cpp + DEPENDS + vespalib + vespalib_vespalib_tensor +) +vespa_add_test(NAME vespalib_sparse_tensor_builder_test_app COMMAND vespalib_sparse_tensor_builder_test_app) diff --git a/vespalib/src/tests/tensor/sparse_tensor_builder/FILES b/vespalib/src/tests/tensor/sparse_tensor_builder/FILES new file mode 100644 index 00000000000..ad47666278e --- /dev/null +++ b/vespalib/src/tests/tensor/sparse_tensor_builder/FILES @@ -0,0 +1 @@ +sparse_tensor_builder_test.cpp diff --git a/vespalib/src/tests/tensor/compact_tensor_v2_builder/compact_tensor_v2_builder_test.cpp b/vespalib/src/tests/tensor/sparse_tensor_builder/sparse_tensor_builder_test.cpp index 7dc1e6c1117..39e82abec7d 100644 --- a/vespalib/src/tests/tensor/compact_tensor_v2_builder/compact_tensor_v2_builder_test.cpp +++ b/vespalib/src/tests/tensor/sparse_tensor_builder/sparse_tensor_builder_test.cpp @@ -1,17 +1,18 @@ // Copyright 2016 Yahoo Inc. 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/vespalib/tensor/compact/compact_tensor_v2_builder.h> +#include <vespa/vespalib/tensor/sparse/sparse_tensor_builder.h> +#include <vespa/vespalib/test/insertion_operators.h> using namespace vespalib::tensor; - +using vespalib::eval::TensorSpec; void assertCellValue(double expValue, const TensorAddress &address, const TensorDimensions &dimensions, - const CompactTensorV2::Cells &cells) + const SparseTensor::Cells &cells) { - CompactTensorV2AddressBuilder addressBuilder; + SparseTensorAddressBuilder addressBuilder; auto dimsItr = dimensions.cbegin(); auto dimsItrEnd = dimensions.cend(); for (const auto &element : address.elements()) { @@ -27,15 +28,16 @@ assertCellValue(double expValue, const TensorAddress &address, addressBuilder.add(""); ++dimsItr; } - CompactTensorAddressRef addressRef(addressBuilder.getAddressRef()); + SparseTensorAddressRef addressRef(addressBuilder.getAddressRef()); auto itr = cells.find(addressRef); EXPECT_FALSE(itr == cells.end()); EXPECT_EQUAL(expValue, itr->second); } -TEST("require that tensor can be constructed") +Tensor::UP +buildTensor() { - CompactTensorV2Builder builder; + SparseTensorBuilder builder; builder.define_dimension("c"); builder.define_dimension("d"); builder.define_dimension("a"); @@ -44,10 +46,15 @@ TEST("require that tensor can be constructed") add_label(builder.define_dimension("b"), "2").add_cell(10). add_label(builder.define_dimension("c"), "3"). add_label(builder.define_dimension("d"), "4").add_cell(20); - Tensor::UP tensor = builder.build(); - const CompactTensorV2 &compactTensor = dynamic_cast<const CompactTensorV2 &>(*tensor); - const TensorDimensions &dimensions = compactTensor.dimensions(); - const CompactTensorV2::Cells &cells = compactTensor.cells(); + return builder.build(); +} + +TEST("require that tensor can be constructed") +{ + Tensor::UP tensor = buildTensor(); + const SparseTensor &sparseTensor = dynamic_cast<const SparseTensor &>(*tensor); + const TensorDimensions &dimensions = sparseTensor.dimensions(); + const SparseTensor::Cells &cells = sparseTensor.cells(); EXPECT_EQUAL(2u, cells.size()); assertCellValue(10, TensorAddress({{"a","1"},{"b","2"}}), dimensions, cells); @@ -55,9 +62,19 @@ TEST("require that tensor can be constructed") dimensions, cells); } +TEST("require that tensor can be converted to tensor spec") +{ + Tensor::UP tensor = buildTensor(); + TensorSpec expSpec("tensor(a{},b{},c{},d{})"); + expSpec.add({{"a", "1"}, {"b", "2"}}, 10). + add({{"c", "3"}, {"d", "4"}}, 20); + TensorSpec actSpec = tensor->toSpec(); + EXPECT_EQUAL(expSpec, actSpec); +} + TEST("require that dimensions are extracted") { - CompactTensorV2Builder builder; + SparseTensorBuilder builder; builder.define_dimension("c"); builder.define_dimension("a"); builder.define_dimension("b"); @@ -67,13 +84,13 @@ TEST("require that dimensions are extracted") add_label(builder.define_dimension("b"), "3"). add_label(builder.define_dimension("c"), "4").add_cell(20); Tensor::UP tensor = builder.build(); - const CompactTensorV2 &compactTensor = dynamic_cast<const CompactTensorV2 &>(*tensor); - const TensorDimensions &dims = compactTensor.dimensions(); + const SparseTensor &sparseTensor = dynamic_cast<const SparseTensor &>(*tensor); + const TensorDimensions &dims = sparseTensor.dimensions(); EXPECT_EQUAL(3u, dims.size()); EXPECT_EQUAL("a", dims[0]); EXPECT_EQUAL("b", dims[1]); EXPECT_EQUAL("c", dims[2]); - EXPECT_EQUAL("tensor(a{},b{},c{})", compactTensor.getType().to_spec()); + EXPECT_EQUAL("tensor(a{},b{},c{})", sparseTensor.getType().to_spec()); } TEST_MAIN() { TEST_RUN_ALL(); } diff --git a/vespalib/src/tests/tensor/tensor/.gitignore b/vespalib/src/tests/tensor/tensor/.gitignore deleted file mode 100644 index 5682a3d5a74..00000000000 --- a/vespalib/src/tests/tensor/tensor/.gitignore +++ /dev/null @@ -1 +0,0 @@ -vespalib_tensor_test_app diff --git a/vespalib/src/tests/tensor/tensor/CMakeLists.txt b/vespalib/src/tests/tensor/tensor/CMakeLists.txt deleted file mode 100644 index bf902d3a71d..00000000000 --- a/vespalib/src/tests/tensor/tensor/CMakeLists.txt +++ /dev/null @@ -1,9 +0,0 @@ -# Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -vespa_add_executable(vespalib_tensor_test_app TEST - SOURCES - tensor_test.cpp - DEPENDS - vespalib - vespalib_vespalib_tensor -) -vespa_add_test(NAME vespalib_tensor_test_app COMMAND vespalib_tensor_test_app) diff --git a/vespalib/src/tests/tensor/tensor/FILES b/vespalib/src/tests/tensor/tensor/FILES deleted file mode 100644 index 6ece9b360b5..00000000000 --- a/vespalib/src/tests/tensor/tensor/FILES +++ /dev/null @@ -1 +0,0 @@ -tensor_test.cpp diff --git a/vespalib/src/tests/tensor/tensor/tensor_test.cpp b/vespalib/src/tests/tensor/tensor/tensor_test.cpp deleted file mode 100644 index df80e6cbf18..00000000000 --- a/vespalib/src/tests/tensor/tensor/tensor_test.cpp +++ /dev/null @@ -1,49 +0,0 @@ -// Copyright 2016 Yahoo Inc. 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/vespalib/tensor/simple/simple_tensor.h> -#include <vespa/vespalib/tensor/tensor_factory.h> -#include <vespa/vespalib/tensor/simple/simple_tensor_builder.h> - -using namespace vespalib::tensor; - -namespace -{ - -SimpleTensor::UP createTensor(const TensorCells &cells) -{ - SimpleTensorBuilder builder; - return SimpleTensor::UP(static_cast<SimpleTensor *> - (TensorFactory::create(cells, builder).release())); -} - -} - -void -assertCellValue(double expValue, const TensorAddress &address, const SimpleTensor::Cells &cells) -{ - auto itr = cells.find(address); - EXPECT_FALSE(itr == cells.end()); - EXPECT_EQUAL(expValue, itr->second); -} - -TEST("require that tensor can be constructed") -{ - SimpleTensor::UP tensor = createTensor({ {{{"a","1"},{"b","2"}},10}, {{{"c","3"},{"d","4"}},20} }); - const SimpleTensor::Cells &cells = tensor->cells(); - EXPECT_EQUAL(2u, cells.size()); - assertCellValue(10, TensorAddress({{"a","1"},{"b","2"}}), cells); - assertCellValue(20, TensorAddress({{"c","3"},{"d","4"}}), cells); -} - -TEST("require that dimensions are extracted") -{ - SimpleTensor::UP tensor = createTensor({ {{{"a","1"},{"b","2"}},10}, {{{"b","3"},{"c","4"}},20} }); - const SimpleTensor::Dimensions &dims = tensor->dimensions(); - EXPECT_EQUAL(3u, dims.size()); - EXPECT_EQUAL("a", dims[0]); - EXPECT_EQUAL("b", dims[1]); - EXPECT_EQUAL("c", dims[2]); -} - -TEST_MAIN() { TEST_RUN_ALL(); } diff --git a/vespalib/src/tests/tensor/tensor_address_element_iterator/.gitignore b/vespalib/src/tests/tensor/tensor_address_element_iterator/.gitignore deleted file mode 100644 index c28cf0c86f2..00000000000 --- a/vespalib/src/tests/tensor/tensor_address_element_iterator/.gitignore +++ /dev/null @@ -1 +0,0 @@ -vespalib_tensor_address_element_iterator_test_app diff --git a/vespalib/src/tests/tensor/tensor_address_element_iterator/CMakeLists.txt b/vespalib/src/tests/tensor/tensor_address_element_iterator/CMakeLists.txt deleted file mode 100644 index dad69af7ba3..00000000000 --- a/vespalib/src/tests/tensor/tensor_address_element_iterator/CMakeLists.txt +++ /dev/null @@ -1,9 +0,0 @@ -# Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -vespa_add_executable(vespalib_tensor_address_element_iterator_test_app TEST - SOURCES - tensor_address_element_iterator_test.cpp - DEPENDS - vespalib - vespalib_vespalib_tensor -) -vespa_add_test(NAME vespalib_tensor_address_element_iterator_test_app COMMAND vespalib_tensor_address_element_iterator_test_app) diff --git a/vespalib/src/tests/tensor/tensor_address_element_iterator/FILES b/vespalib/src/tests/tensor/tensor_address_element_iterator/FILES deleted file mode 100644 index b185a25973e..00000000000 --- a/vespalib/src/tests/tensor/tensor_address_element_iterator/FILES +++ /dev/null @@ -1 +0,0 @@ -tensor_address_element_iterator_test.cpp diff --git a/vespalib/src/tests/tensor/tensor_address_element_iterator/tensor_address_element_iterator_test.cpp b/vespalib/src/tests/tensor/tensor_address_element_iterator/tensor_address_element_iterator_test.cpp deleted file mode 100644 index 95fe166937d..00000000000 --- a/vespalib/src/tests/tensor/tensor_address_element_iterator/tensor_address_element_iterator_test.cpp +++ /dev/null @@ -1,343 +0,0 @@ -// Copyright 2016 Yahoo Inc. 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/vespalib/stllike/hash_set.h> -#include <vespa/vespalib/tensor/tensor_address.h> -#include <vespa/vespalib/tensor/tensor_address_builder.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_address.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_address_builder.h> -#include <vespa/vespalib/tensor/tensor_address_element_iterator.h> - -using namespace vespalib::tensor; - -using TensorAddressMap = std::map<std::string, std::string>; -using TensorAddressElementVec = - std::vector<std::pair<std::string, std::string>>; - -namespace vespalib -{ - -std::ostream & -operator<<(std::ostream &out, const TensorAddressElementVec &vec) -{ - out << "{"; - bool first = true; - for (const auto &elem : vec) { - if (!first) { - out << ","; - } - out << "{\"" << elem.first << "\",\"" << elem.second << "\"}"; - first = false; - } - out << "}"; - return out; -}; - -} - - -class DummyAddressBuilder -{ - TensorAddressElementVec _elements; -public: - void add(vespalib::stringref dimension, vespalib::stringref label) - { - _elements.emplace_back(dimension, label); - } - - const TensorAddressElementVec &elements() const { return _elements; } -}; - - -template <class TensorAddressT> struct FixtureBase; - -template <> struct FixtureBase<TensorAddress> -{ - using AddressType = TensorAddress; - using AddressBuilderType = TensorAddressBuilder; - - static TensorAddress create(TensorAddressBuilder &builder) { - return builder.build(); - } -}; - - -template <> struct FixtureBase<CompactTensorAddress> -{ - using AddressType = CompactTensorAddress; - using AddressBuilderType = CompactTensorAddressBuilder; - - vespalib::Stash _stash; - - CompactTensorAddress - create(CompactTensorAddressBuilder &builder) - { - CompactTensorAddressRef oldRef = builder.getAddressRef(); - CompactTensorAddressRef newRef(oldRef, _stash); - CompactTensorAddress ret; - ret.deserializeFromSparseAddressRef(newRef); - return ret; - } -}; - -template <> struct FixtureBase<CompactTensorAddressRef> -{ - using AddressType = CompactTensorAddressRef; - using AddressBuilderType = CompactTensorAddressBuilder; - - vespalib::Stash _stash; - - CompactTensorAddressRef - create(CompactTensorAddressBuilder &builder) - { - CompactTensorAddressRef oldRef = builder.getAddressRef(); - CompactTensorAddressRef newRef(oldRef, _stash); - return newRef; - } -}; - -template <class TensorAddressT> struct Fixture - : public FixtureBase<TensorAddressT> -{ - using Parent = FixtureBase<TensorAddressT>; - using AddressType = typename Parent::AddressType; - using AddressBuilderType = typename Parent::AddressBuilderType; - using Parent::create; - - AddressType - create(const TensorAddressMap &address_in) { - AddressBuilderType builder; - for (auto &element : address_in) { - builder.add(element.first, element.second); - } - return create(builder); - } - - void - verifyPlainIterate(const TensorAddressMap &address_in) - { - AddressType address = create(address_in); - TensorAddressElementIterator<AddressType> itr(address); - for (auto &element : address_in) { - EXPECT_TRUE(itr.valid()); - EXPECT_EQUAL(element.first, itr.dimension()); - EXPECT_EQUAL(element.second, itr.label()); - itr.next(); - } - EXPECT_FALSE(itr.valid()); - } - - - void - verifyPlainIterate() - { - TEST_DO(verifyPlainIterate({})); - TEST_DO(verifyPlainIterate({{"a", "1"}})); - TEST_DO(verifyPlainIterate({{"a", "1"}, {"b", "2"}})); - } - - void - verifyBeforeDimension(const TensorAddressMap &lhsAddress_in, - const TensorAddressMap &rhsAddress_in, - bool exp) - { - AddressType lhsAddress = create(lhsAddress_in); - TensorAddressElementIterator<AddressType> lhsItr(lhsAddress); - AddressType rhsAddress = create(rhsAddress_in); - TensorAddressElementIterator<AddressType> rhsItr(rhsAddress); - EXPECT_EQUAL(exp, lhsItr.beforeDimension(rhsItr)); - } - - void - verifyBeforeDimension() { - TEST_DO(verifyBeforeDimension({}, {}, false)); - TEST_DO(verifyBeforeDimension({}, {{"x", "1"}}, false)); - TEST_DO(verifyBeforeDimension({{"x", "1"}}, {}, true)); - TEST_DO(verifyBeforeDimension({{"x", "1"}}, {{"x", "2"}}, false)); - TEST_DO(verifyBeforeDimension({{"x", "1"}}, {{"y", "2"}}, true)); - TEST_DO(verifyBeforeDimension({{"y", "1"}}, {{"x", "2"}}, false)); - } - - void - verifyAtDimension(const TensorAddressMap &address_in, - vespalib::stringref dimension, - bool exp) - { - AddressType address = create(address_in); - TensorAddressElementIterator<AddressType> itr(address); - EXPECT_EQUAL(exp, itr.atDimension(dimension)); - } - - void - verifyAtDimension() - { - TEST_DO(verifyAtDimension({}, "x", false)); - TEST_DO(verifyAtDimension({{"x", "1"}}, "x", true)); - TEST_DO(verifyAtDimension({{"x", "1"}}, "y", false)); - TEST_DO(verifyAtDimension({{"y", "1"}}, "x", false)); - TEST_DO(verifyAtDimension({{"y", "1"}}, "y", true)); - } - - void - verifyAddElements(const TensorAddressMap &lhsAddress_in, - const TensorAddressMap &rhsAddress_in, - const TensorAddressElementVec &exp) - { - AddressType lhsAddress = create(lhsAddress_in); - TensorAddressElementIterator<AddressType> lhsItr(lhsAddress); - AddressType rhsAddress = create(rhsAddress_in); - TensorAddressElementIterator<AddressType> rhsItr(rhsAddress); - DummyAddressBuilder builder; - lhsItr.addElements(builder, rhsItr); - EXPECT_EQUAL(exp, builder.elements()); - } - - void verifyAddElements(const TensorAddressMap &address_in, - const TensorAddressElementVec &exp) - { - AddressType address = create(address_in); - TensorAddressElementIterator<AddressType> itr(address); - DummyAddressBuilder builder; - itr.addElements(builder); - EXPECT_EQUAL(exp, builder.elements()); - } - - void verifyAddElements(const TensorAddressMap &address_in, - const DimensionsSet &dimensions, - bool exp, - const TensorAddressElementVec &expVec) - { - AddressType address = create(address_in); - TensorAddressElementIterator<AddressType> itr(address); - DummyAddressBuilder builder; - EXPECT_EQUAL(exp, itr.addElements(builder, dimensions)); - EXPECT_EQUAL(expVec, builder.elements()); - } - - void verifyAddElements(const TensorAddressMap &lhsAddress_in, - const TensorAddressMap &rhsAddress_in, - const DimensionsSet &dimensions, - bool exp, - const TensorAddressElementVec &expVec) - { - AddressType lhsAddress = create(lhsAddress_in); - TensorAddressElementIterator<AddressType> lhsItr(lhsAddress); - AddressType rhsAddress = create(rhsAddress_in); - TensorAddressElementIterator<AddressType> rhsItr(rhsAddress); - DummyAddressBuilder builder; - ASSERT_TRUE(lhsItr.beforeDimension(rhsItr)); - EXPECT_EQUAL(exp, lhsItr.addElements(builder, dimensions, rhsItr)); - EXPECT_EQUAL(expVec, builder.elements()); - } - - void - verifyAddElements() - { - // Stop according to rhs iterator - TEST_DO(verifyAddElements({}, {}, {})); - TEST_DO(verifyAddElements({{"x", "1"}}, {}, {{"x", "1"}})); - TEST_DO(verifyAddElements({{"x", "1"}}, {{"x", "1"}}, {})); - TEST_DO(verifyAddElements({{"x", "1"}}, {{"y", "1"}}, {{"x", "1"}})); - TEST_DO(verifyAddElements({{"y", "1"}}, {{"x", "1"}}, {})); - TEST_DO(verifyAddElements({{"x", "1"}, {"y", "2"}}, {{"z", "1"}}, - {{"x", "1"}, {"y", "2"}})); - // Pass through everything - TEST_DO(verifyAddElements({}, {})); - TEST_DO(verifyAddElements({{"x", "1"}}, {{"x", "1"}})); - TEST_DO(verifyAddElements({{"x", "1"}, {"y", "2"}}, - {{"x", "1"}, {"y", "2"}})); - // Filter on dimension set - TEST_DO(verifyAddElements({}, {}, true, {})); - TEST_DO(verifyAddElements({{"x", "1"}}, {}, true, {{"x", "1"}})); - TEST_DO(verifyAddElements({{"x", "1"}, {"y", "2"}}, {}, true, - {{"x", "1"}, {"y", "2"}})); - TEST_DO(verifyAddElements({{"x", "1"}, {"y", "2"}}, {"y"}, false, - {{"x", "1"}})); - // Filter on dimension set and stop according to rhs iterator - TEST_DO(verifyAddElements({{"x", "1"}}, {}, {}, true, {{"x", "1"}})); - TEST_DO(verifyAddElements({{"x", "1"}, {"y", "2"}}, {}, {}, true, - {{"x", "1"}, {"y", "2"}})); - TEST_DO(verifyAddElements({{"x", "1"}, {"y", "2"}}, {{"y", "2"}}, {}, - true, {{"x", "1"}})); - TEST_DO(verifyAddElements({{"x", "1"}, {"y", "2"}}, {{"y", "2"}}, {"y"}, - true, {{"x", "1"}})); - TEST_DO(verifyAddElements({{"x", "1"}, {"y", "2"}}, {{"y", "2"}}, {"x"}, - false, {})); - } -}; - - -TEST_F("Test that Tensor address can be iterated", Fixture<TensorAddress>) -{ - f.verifyPlainIterate(); -} - -TEST_F("Test that compact Tensor address can be iterated", - Fixture<CompactTensorAddress>) -{ - f.verifyPlainIterate(); -} - - -TEST_F("Test that compact Tensor address ref can be iterated", - Fixture<CompactTensorAddressRef>) -{ - f.verifyPlainIterate(); -} - -TEST_F("Test that Tensor address works with beforeDimension", - Fixture<TensorAddress>) -{ - f.verifyBeforeDimension(); -} - -TEST_F("Test that compact Tensor address works with beforeDimension", - Fixture<CompactTensorAddress>) -{ - f.verifyBeforeDimension(); -} - -TEST_F("Test that compat Tensor address ref works with beforeDimension", - Fixture<CompactTensorAddressRef>) -{ - f.verifyBeforeDimension(); -} - -TEST_F("Test that Tensor address works with atDimension", - Fixture<TensorAddress>) -{ - f.verifyAtDimension(); -} - -TEST_F("Test that compact Tensor address works with atDimension", - Fixture<CompactTensorAddress>) -{ - f.verifyAtDimension(); -} - -TEST_F("Test that compat Tensor address ref works with atDimension", - Fixture<CompactTensorAddressRef>) -{ - f.verifyAtDimension(); -} - -TEST_F("Test that Tensor address works with addElements", - Fixture<TensorAddress>) -{ - f.verifyAddElements(); -} - -TEST_F("Test that compact Tensor address works with addElements", - Fixture<CompactTensorAddress>) -{ - f.verifyAddElements(); -} - -TEST_F("Test that compat Tensor address ref works with addElements", - Fixture<CompactTensorAddressRef>) -{ - f.verifyAddElements(); -} - - -TEST_MAIN() { TEST_RUN_ALL(); } diff --git a/vespalib/src/tests/tensor/tensor_conformance/tensor_conformance_test.cpp b/vespalib/src/tests/tensor/tensor_conformance/tensor_conformance_test.cpp index 91dea9fb0ce..238d0604ee7 100644 --- a/vespalib/src/tests/tensor/tensor_conformance/tensor_conformance_test.cpp +++ b/vespalib/src/tests/tensor/tensor_conformance/tensor_conformance_test.cpp @@ -8,12 +8,12 @@ using vespalib::eval::SimpleTensorEngine; using vespalib::eval::test::TensorConformance; using vespalib::tensor::DefaultTensorEngine; -TEST("require that reference tensor implementation passes conformance test") { - TEST_DO(TensorConformance::run_tests(SimpleTensorEngine::ref())); +TEST("require that reference tensor implementation passes all conformance tests") { + TEST_DO(TensorConformance::run_tests(SimpleTensorEngine::ref(), true)); } -IGNORE_TEST("require that production tensor implementation passes conformance test") { - TEST_DO(TensorConformance::run_tests(DefaultTensorEngine::ref())); +IGNORE_TEST("require that production tensor implementation passes non-mixed conformance tests") { + TEST_DO(TensorConformance::run_tests(DefaultTensorEngine::ref(), false)); } TEST_MAIN() { TEST_RUN_ALL(); } diff --git a/vespalib/src/tests/tensor/tensor_mapper/tensor_mapper_test.cpp b/vespalib/src/tests/tensor/tensor_mapper/tensor_mapper_test.cpp index 612b5366d77..6977a857944 100644 --- a/vespalib/src/tests/tensor/tensor_mapper/tensor_mapper_test.cpp +++ b/vespalib/src/tests/tensor/tensor_mapper/tensor_mapper_test.cpp @@ -2,12 +2,8 @@ #include <vespa/vespalib/testkit/test_kit.h> #include <vespa/vespalib/util/stringfmt.h> -#include <vespa/vespalib/tensor/simple/simple_tensor.h> -#include <vespa/vespalib/tensor/simple/simple_tensor_builder.h> -#include <vespa/vespalib/tensor/compact/compact_tensor.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_builder.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_v2.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_v2_builder.h> +#include <vespa/vespalib/tensor/sparse/sparse_tensor.h> +#include <vespa/vespalib/tensor/sparse/sparse_tensor_builder.h> #include <vespa/vespalib/tensor/dense/dense_tensor.h> #include <vespa/vespalib/tensor/dense/dense_tensor_builder.h> #include <vespa/vespalib/tensor/types.h> @@ -41,18 +37,8 @@ template <typename BuilderType> struct TensorTFromBuilder; template <> -struct TensorTFromBuilder<SimpleTensorBuilder> { - using TensorT = SimpleTensor; -}; - -template <> -struct TensorTFromBuilder<CompactTensorBuilder> { - using TensorT = CompactTensor; -}; - -template <> -struct TensorTFromBuilder<CompactTensorV2Builder> { - using TensorT = CompactTensorV2; +struct TensorTFromBuilder<SparseTensorBuilder> { + using TensorT = SparseTensor; }; template <typename BuilderType> @@ -130,9 +116,7 @@ struct Fixture : public FixtureBase } }; -using SimpleFixture = Fixture<SimpleTensorBuilder>; -using CompactFixture = Fixture<CompactTensorBuilder>; -using CompactV2Fixture = Fixture<CompactTensorV2Builder>; +using SparseFixture = Fixture<SparseTensorBuilder>; template <typename FixtureType> void @@ -208,17 +192,7 @@ testTensorMapper(FixtureType &f) { "x", "y" })); } -TEST_F("test tensor mapper for SimpleTensor", SimpleFixture) -{ - testTensorMapper(f); -} - -TEST_F("test tensor mapper for CompactTensor", CompactFixture) -{ - testTensorMapper(f); -} - -TEST_F("test tensor mapper for CompactTensorV2", CompactV2Fixture) +TEST_F("test tensor mapper for SparseTensor", SparseFixture) { testTensorMapper(f); } diff --git a/vespalib/src/tests/tensor/tensor_operations/tensor_operations_test.cpp b/vespalib/src/tests/tensor/tensor_operations/tensor_operations_test.cpp index 3948a6d68a6..5ad26e979c5 100644 --- a/vespalib/src/tests/tensor/tensor_operations/tensor_operations_test.cpp +++ b/vespalib/src/tests/tensor/tensor_operations/tensor_operations_test.cpp @@ -1,12 +1,8 @@ // Copyright 2016 Yahoo Inc. 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/vespalib/tensor/simple/simple_tensor.h> -#include <vespa/vespalib/tensor/simple/simple_tensor_builder.h> -#include <vespa/vespalib/tensor/compact/compact_tensor.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_builder.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_v2.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_v2_builder.h> +#include <vespa/vespalib/tensor/sparse/sparse_tensor.h> +#include <vespa/vespalib/tensor/sparse/sparse_tensor_builder.h> #include <vespa/vespalib/tensor/types.h> #include <vespa/vespalib/tensor/tensor_factory.h> #include <vespa/vespalib/tensor/tensor_function.h> @@ -124,6 +120,10 @@ struct Fixture void assertAdd(const TensorCells &exp, const TensorCells &lhs, const TensorCells &rhs, bool check_types = true) { assertAddImpl(*createTensor(exp), *createTensor(lhs), *createTensor(rhs), check_types); } + void assertAdd(const TensorCells &exp, const TensorDimensions &expDimensions, + const TensorCells &lhs, const TensorCells &rhs, bool check_types = true) { + assertAddImpl(*createTensor(exp, expDimensions), *createTensor(lhs), *createTensor(rhs), check_types); + } void assertSubtractImpl(const Tensor &exp, const Tensor &lhs, const Tensor &rhs, bool check_types) { MyInput input; function::Node_UP ir = function::subtract(function::input(lhs.getType(), input.add(lhs)), @@ -133,6 +133,9 @@ struct Fixture void assertSubtract(const TensorCells &exp, const TensorCells &lhs, const TensorCells &rhs, bool check_types = true) { assertSubtractImpl(*createTensor(exp), *createTensor(lhs), *createTensor(rhs), check_types); } + void assertSubtract(const TensorCells &exp, const TensorDimensions &expDimensions, const TensorCells &lhs, const TensorCells &rhs, bool check_types = true) { + assertSubtractImpl(*createTensor(exp, expDimensions), *createTensor(lhs), *createTensor(rhs), check_types); + } void assertMinImpl(const Tensor &exp, const Tensor &lhs, const Tensor &rhs, bool check_types) { MyInput input; function::Node_UP ir = function::min(function::input(lhs.getType(), input.add(lhs)), @@ -142,6 +145,9 @@ struct Fixture void assertMin(const TensorCells &exp, const TensorCells &lhs, const TensorCells &rhs, bool check_types = true) { assertMinImpl(*createTensor(exp), *createTensor(lhs), *createTensor(rhs), check_types); } + void assertMin(const TensorCells &exp, const TensorDimensions &expDimensions, const TensorCells &lhs, const TensorCells &rhs, bool check_types = true) { + assertMinImpl(*createTensor(exp, expDimensions), *createTensor(lhs), *createTensor(rhs), check_types); + } void assertMaxImpl(const Tensor &exp, const Tensor &lhs, const Tensor &rhs, bool check_types) { MyInput input; function::Node_UP ir = function::max(function::input(lhs.getType(), input.add(lhs)), @@ -151,6 +157,9 @@ struct Fixture void assertMax(const TensorCells &exp, const TensorCells &lhs, const TensorCells &rhs, bool check_types = true) { assertMaxImpl(*createTensor(exp), *createTensor(lhs), *createTensor(rhs), check_types); } + void assertMax(const TensorCells &exp, const TensorDimensions &expDimensions, const TensorCells &lhs, const TensorCells &rhs, bool check_types = true) { + assertMaxImpl(*createTensor(exp, expDimensions), *createTensor(lhs), *createTensor(rhs), check_types); + } void assertSumImpl(double exp, const Tensor &tensor) { MyInput input; function::Node_UP ir = function::sum(function::input(tensor.getType(), input.add(tensor))); @@ -221,9 +230,7 @@ struct Fixture } }; -using SimpleFixture = Fixture<SimpleTensorBuilder>; -using CompactFixture = Fixture<CompactTensorBuilder>; -using CompactV2Fixture = Fixture<CompactTensorV2Builder>; +using SparseFixture = Fixture<SparseTensorBuilder>; template <typename FixtureType> @@ -258,42 +265,42 @@ void testTensorAdd(FixtureType &f) { f.assertAdd({},{},{}, false); - f.assertAdd({ {{{"x","1"}}, 3}, {{{"x","2"}}, 5} }, - { {{{"x","1"}}, 3} }, - { {{{"x","2"}}, 5} }); - f.assertAdd({ {{{"x","1"}}, 8} }, - { {{{"x","1"}}, 3} }, - { {{{"x","1"}}, 5} }); - f.assertAdd({ {{{"x","1"}}, -2} }, - { {{{"x","1"}}, 3} }, - { {{{"x","1"}}, -5} }); - f.assertAdd({ {{{"x","1"}}, 0} }, - { {{{"x","1"}}, 3} }, - { {{{"x","1"}}, -3} }); - f.assertAdd({ {{{"x","1"}}, 3}, {{{"y","2"}}, 12}, {{{"z","3"}}, 11} }, - { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }, - { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }); - f.assertAdd({ {{{"x","1"}}, 3}, {{{"y","2"}}, 12}, {{{"z","3"}}, 11} }, - { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, - { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }); - f.assertAdd({ {{{"y","2"}}, 12}, {{{"z","3"}}, 11} }, - { {{{"y","2"}}, 5} }, - { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }); - f.assertAdd({ {{{"y","2"}}, 12}, {{{"z","3"}}, 11} }, - { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, - { {{{"y","2"}}, 5} }); - f.assertAdd({ {{{"x","1"}}, 3}, {{{"y","2"}}, 12} }, - { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }, - { {{{"y","2"}}, 7} }); - f.assertAdd({ {{{"x","1"}}, 3}, {{{"y","2"}}, 12} }, - { {{{"y","2"}}, 7} }, - { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }); - f.assertAdd({ {{{"x","1"}}, 3}, {{{"z","3"}}, 11} }, - { {{{"x","1"}}, 3} }, - { {{{"z","3"}}, 11} }); - f.assertAdd({ {{{"x","1"}}, 3}, {{{"z","3"}}, 11} }, - { {{{"z","3"}}, 11} }, - { {{{"x","1"}}, 3} }); + TEST_DO(f.assertAdd({}, { "x" }, + { {{{"x","1"}}, 3} }, + { {{{"x","2"}}, 5} })); + TEST_DO(f.assertAdd({ {{{"x","1"}}, 8} }, + { {{{"x","1"}}, 3} }, + { {{{"x","1"}}, 5} })); + TEST_DO(f.assertAdd({ {{{"x","1"}}, -2} }, + { {{{"x","1"}}, 3} }, + { {{{"x","1"}}, -5} })); + TEST_DO(f.assertAdd({ {{{"x","1"}}, 0} }, + { {{{"x","1"}}, 3} }, + { {{{"x","1"}}, -3} })); + TEST_DO(f.assertAdd({ {{{"x","1"},{"z","3"}}, 14}, {{{"y","2"}}, 12} }, + { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }, + { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} })); + TEST_DO(f.assertAdd({ {{{"x","1"},{"z","3"}}, 14}, {{{"y","2"}}, 12} }, + { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, + { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} })); + TEST_DO(f.assertAdd({ {{{"y","2"}}, 12} }, { "y", "z" }, + { {{{"y","2"}}, 5} }, + { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} })); + TEST_DO(f.assertAdd({ {{{"y","2"}}, 12} }, { "y", "z" }, + { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, + { {{{"y","2"}}, 5} })); + TEST_DO(f.assertAdd({ {{{"y","2"}}, 12} }, { "x", "y" }, + { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }, + { {{{"y","2"}}, 7} })); + TEST_DO(f.assertAdd({ {{{"y","2"}}, 12} }, { "x", "y" }, + { {{{"y","2"}}, 7} }, + { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} })); + TEST_DO(f.assertAdd({ {{{"x","1"},{"z","3"}}, 14} }, + { {{{"x","1"}}, 3} }, + { {{{"z","3"}}, 11} })); + TEST_DO(f.assertAdd({ {{{"x","1"},{"z","3"}}, 14} }, + { {{{"z","3"}}, 11} }, + { {{{"x","1"}}, 3} })); } template <typename FixtureType> @@ -301,42 +308,42 @@ void testTensorSubtract(FixtureType &f) { f.assertSubtract({},{},{}, false); - f.assertSubtract({ {{{"x","1"}}, 3}, {{{"x","2"}}, -5} }, - { {{{"x","1"}}, 3} }, - { {{{"x","2"}}, 5} }); - f.assertSubtract({ {{{"x","1"}}, -2} }, - { {{{"x","1"}}, 3} }, - { {{{"x","1"}}, 5} }); - f.assertSubtract({ {{{"x","1"}}, 8} }, - { {{{"x","1"}}, 3} }, - { {{{"x","1"}}, -5} }); - f.assertSubtract({ {{{"x","1"}}, 0} }, - { {{{"x","1"}}, 3} }, - { {{{"x","1"}}, 3} }); - f.assertSubtract({ {{{"x","1"}}, 3}, {{{"y","2"}},-2}, {{{"z","3"}},-11} }, - { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }, - { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }); - f.assertSubtract({ {{{"x","1"}},-3}, {{{"y","2"}}, 2}, {{{"z","3"}}, 11} }, - { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, - { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }); - f.assertSubtract({ {{{"y","2"}},-2}, {{{"z","3"}},-11} }, - { {{{"y","2"}}, 5} }, - { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }); - f.assertSubtract({ {{{"y","2"}}, 2}, {{{"z","3"}}, 11} }, - { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, - { {{{"y","2"}}, 5} }); - f.assertSubtract({ {{{"x","1"}}, 3}, {{{"y","2"}},-2} }, - { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }, - { {{{"y","2"}}, 7} }); - f.assertSubtract({ {{{"x","1"}},-3}, {{{"y","2"}}, 2} }, - { {{{"y","2"}}, 7} }, - { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }); - f.assertSubtract({ {{{"x","1"}}, 3}, {{{"z","3"}},-11} }, - { {{{"x","1"}}, 3} }, - { {{{"z","3"}}, 11} }); - f.assertSubtract({ {{{"x","1"}},-3}, {{{"z","3"}}, 11} }, - { {{{"z","3"}}, 11} }, - { {{{"x","1"}}, 3} }); + TEST_DO(f.assertSubtract({}, { "x" }, + { {{{"x","1"}}, 3} }, + { {{{"x","2"}}, 5} })); + TEST_DO(f.assertSubtract({ {{{"x","1"}}, -2} }, + { {{{"x","1"}}, 3} }, + { {{{"x","1"}}, 5} })); + TEST_DO(f.assertSubtract({ {{{"x","1"}}, 8} }, + { {{{"x","1"}}, 3} }, + { {{{"x","1"}}, -5} })); + TEST_DO(f.assertSubtract({ {{{"x","1"}}, 0} }, + { {{{"x","1"}}, 3} }, + { {{{"x","1"}}, 3} })); + TEST_DO(f.assertSubtract({ {{{"x","1"},{"z","3"}}, -8}, {{{"y","2"}},-2} }, + { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }, + { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} })); + TEST_DO(f.assertSubtract({ {{{"x","1"},{"z","3"}}, 8}, {{{"y","2"}}, 2} }, + { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, + { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} })); + TEST_DO(f.assertSubtract({ {{{"y","2"}},-2} }, { "y", "z" }, + { {{{"y","2"}}, 5} }, + { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} })); + TEST_DO(f.assertSubtract({ {{{"y","2"}}, 2} }, { "y", "z" }, + { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, + { {{{"y","2"}}, 5} })); + TEST_DO(f.assertSubtract({ {{{"y","2"}},-2} }, { "x", "y" }, + { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }, + { {{{"y","2"}}, 7} })); + TEST_DO(f.assertSubtract({ {{{"y","2"}}, 2} }, { "x", "y" }, + { {{{"y","2"}}, 7} }, + { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} })); + TEST_DO(f.assertSubtract({ {{{"x","1"},{"z","3"}}, -8} }, + { {{{"x","1"}}, 3} }, + { {{{"z","3"}}, 11} })); + TEST_DO(f.assertSubtract({ {{{"x","1"},{"z","3"}}, 8} }, + { {{{"z","3"}}, 11} }, + { {{{"x","1"}}, 3} })); } template <typename FixtureType> @@ -344,42 +351,42 @@ void testTensorMin(FixtureType &f) { f.assertMin({},{},{}, false); - f.assertMin({ {{{"x","1"}}, 3}, {{{"x","2"}}, 5} }, - { {{{"x","1"}}, 3} }, - { {{{"x","2"}}, 5} }); - f.assertMin({ {{{"x","1"}}, 3} }, - { {{{"x","1"}}, 3} }, - { {{{"x","1"}}, 5} }); - f.assertMin({ {{{"x","1"}}, -5} }, - { {{{"x","1"}}, 3} }, - { {{{"x","1"}}, -5} }); - f.assertMin({ {{{"x","1"}}, 3}, {{{"x","2"}}, 0} }, - { {{{"x","1"}}, 3} }, - { {{{"x","2"}}, 0} }); - f.assertMin({ {{{"x","1"}}, 3}, {{{"y","2"}}, 5}, {{{"z","3"}}, 11} }, - { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }, - { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }); - f.assertMin({ {{{"x","1"}}, 3}, {{{"y","2"}}, 5}, {{{"z","3"}}, 11} }, - { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, - { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }); - f.assertMin({ {{{"y","2"}}, 5}, {{{"z","3"}}, 11} }, - { {{{"y","2"}}, 5} }, - { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }); - f.assertMin({ {{{"y","2"}}, 5}, {{{"z","3"}}, 11} }, - { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, - { {{{"y","2"}}, 5} }); - f.assertMin({ {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }, - { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }, - { {{{"y","2"}}, 7} }); - f.assertMin({ {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }, - { {{{"y","2"}}, 7} }, - { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }); - f.assertMin({ {{{"x","1"}}, 3}, {{{"z","3"}}, 11} }, - { {{{"x","1"}}, 3} }, - { {{{"z","3"}}, 11} }); - f.assertMin({ {{{"x","1"}}, 3}, {{{"z","3"}}, 11} }, - { {{{"z","3"}}, 11} }, - { {{{"x","1"}}, 3} }); + TEST_DO(f.assertMin({}, { "x" }, + { {{{"x","1"}}, 3} }, + { {{{"x","2"}}, 5} })); + TEST_DO(f.assertMin({ {{{"x","1"}}, 3} }, + { {{{"x","1"}}, 3} }, + { {{{"x","1"}}, 5} })); + TEST_DO(f.assertMin({ {{{"x","1"}}, -5} }, + { {{{"x","1"}}, 3} }, + { {{{"x","1"}}, -5} })); + TEST_DO(f.assertMin({}, { "x" }, + { {{{"x","1"}}, 3} }, + { {{{"x","2"}}, 0} })); + TEST_DO(f.assertMin({ {{{"x","1"},{"z","3"}}, 3}, {{{"y","2"}}, 5} }, + { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }, + { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} })); + TEST_DO(f.assertMin({ {{{"x","1"},{"z","3"}}, 3}, {{{"y","2"}}, 5} }, + { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, + { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} })); + TEST_DO(f.assertMin({ {{{"y","2"}}, 5} }, { "y", "z" }, + { {{{"y","2"}}, 5} }, + { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} })); + TEST_DO(f.assertMin({ {{{"y","2"}}, 5} }, { "y", "z" }, + { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, + { {{{"y","2"}}, 5} })); + TEST_DO(f.assertMin({ {{{"y","2"}}, 5} }, { "x", "y" }, + { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }, + { {{{"y","2"}}, 7} })); + TEST_DO(f.assertMin({ {{{"y","2"}}, 5} }, { "x", "y" }, + { {{{"y","2"}}, 7} }, + { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} })); + TEST_DO(f.assertMin({ {{{"x","1"},{"z","3"}}, 3} }, + { {{{"x","1"}}, 3} }, + { {{{"z","3"}}, 11} })); + TEST_DO(f.assertMin({ {{{"x","1"},{"z","3"}}, 3} }, + { {{{"z","3"}}, 11} }, + { {{{"x","1"}}, 3} })); } template <typename FixtureType> @@ -387,45 +394,45 @@ void testTensorMax(FixtureType &f) { f.assertMax({},{},{}, false); - f.assertMax({ {{{"x","1"}}, 3}, {{{"x","2"}}, 5} }, - { {{{"x","1"}}, 3} }, - { {{{"x","2"}}, 5} }); - f.assertMax({ {{{"x","1"}}, 5} }, - { {{{"x","1"}}, 3} }, - { {{{"x","1"}}, 5} }); - f.assertMax({ {{{"x","1"}}, 3} }, - { {{{"x","1"}}, 3} }, - { {{{"x","1"}}, -5} }); - f.assertMax({ {{{"x","1"}}, 3}, {{{"x","2"}}, 0} }, - { {{{"x","1"}}, 3} }, - { {{{"x","2"}}, 0} }); - f.assertMax({ {{{"x","1"}}, 3}, {{{"x","2"}}, -5} }, - { {{{"x","1"}}, 3} }, - { {{{"x","2"}}, -5} }); - f.assertMax({ {{{"x","1"}}, 3}, {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, - { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }, - { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }); - f.assertMax({ {{{"x","1"}}, 3}, {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, - { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, - { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }); - f.assertMax({ {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, - { {{{"y","2"}}, 5} }, - { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }); - f.assertMax({ {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, - { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, - { {{{"y","2"}}, 5} }); - f.assertMax({ {{{"x","1"}}, 3}, {{{"y","2"}}, 7} }, - { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }, - { {{{"y","2"}}, 7} }); - f.assertMax({ {{{"x","1"}}, 3}, {{{"y","2"}}, 7} }, - { {{{"y","2"}}, 7} }, - { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }); - f.assertMax({ {{{"x","1"}}, 3}, {{{"z","3"}}, 11} }, - { {{{"x","1"}}, 3} }, - { {{{"z","3"}}, 11} }); - f.assertMax({ {{{"x","1"}}, 3}, {{{"z","3"}}, 11} }, - { {{{"z","3"}}, 11} }, - { {{{"x","1"}}, 3} }); + TEST_DO(f.assertMax({}, { "x" }, + { {{{"x","1"}}, 3} }, + { {{{"x","2"}}, 5} })); + TEST_DO(f.assertMax({ {{{"x","1"}}, 5} }, + { {{{"x","1"}}, 3} }, + { {{{"x","1"}}, 5} })); + TEST_DO(f.assertMax({ {{{"x","1"}}, 3} }, + { {{{"x","1"}}, 3} }, + { {{{"x","1"}}, -5} })); + TEST_DO(f.assertMax({}, { "x" }, + { {{{"x","1"}}, 3} }, + { {{{"x","2"}}, 0} })); + TEST_DO(f.assertMax({}, { "x" }, + { {{{"x","1"}}, 3} }, + { {{{"x","2"}}, -5} })); + TEST_DO(f.assertMax({ {{{"x","1"},{"z","3"}}, 11}, {{{"y","2"}}, 7} }, + { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }, + { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} })); + TEST_DO(f.assertMax({ {{{"x","1"},{"z","3"}}, 11}, {{{"y","2"}}, 7} }, + { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, + { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} })); + TEST_DO(f.assertMax({ {{{"y","2"}}, 7} }, { "y", "z" }, + { {{{"y","2"}}, 5} }, + { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} })); + TEST_DO(f.assertMax({ {{{"y","2"}}, 7} }, { "y", "z" }, + { {{{"y","2"}}, 7}, {{{"z","3"}}, 11} }, + { {{{"y","2"}}, 5} })); + TEST_DO(f.assertMax({ {{{"y","2"}}, 7} }, { "x", "y" }, + { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} }, + { {{{"y","2"}}, 7} })); + TEST_DO(f.assertMax({ {{{"y","2"}}, 7} }, { "x", "y" }, + { {{{"y","2"}}, 7} }, + { {{{"x","1"}}, 3}, {{{"y","2"}}, 5} })); + TEST_DO(f.assertMax({ {{{"x","1"},{"z","3"}}, 11} }, + { {{{"x","1"}}, 3} }, + { {{{"z","3"}}, 11} })); + TEST_DO(f.assertMax({ {{{"x","1"},{"z","3"}}, 11} }, + { {{{"z","3"}}, 11} }, + { {{{"x","1"}}, 3} })); } template <typename FixtureType> @@ -616,17 +623,7 @@ testAllTensorOperations(FixtureType &f) TEST_DO(testTensorSumDimension(f)); } -TEST_F("test tensor operations for SimpleTensor", SimpleFixture) -{ - testAllTensorOperations(f); -} - -TEST_F("test tensor operations for CompactTensor", CompactFixture) -{ - testAllTensorOperations(f); -} - -TEST_F("test tensor operations for CompactTensorV2", CompactV2Fixture) +TEST_F("test tensor operations for SparseTensor", SparseFixture) { testAllTensorOperations(f); } diff --git a/vespalib/src/tests/tensor/tensor_performance/tensor_performance_test.cpp b/vespalib/src/tests/tensor/tensor_performance/tensor_performance_test.cpp index 2b9370bb606..814f18c8cae 100644 --- a/vespalib/src/tests/tensor/tensor_performance/tensor_performance_test.cpp +++ b/vespalib/src/tests/tensor/tensor_performance/tensor_performance_test.cpp @@ -3,12 +3,8 @@ #include <vespa/vespalib/eval/function.h> #include <vespa/vespalib/eval/interpreted_function.h> #include <vespa/vespalib/eval/tensor_nodes.h> -#include <vespa/vespalib/tensor/compact/compact_tensor.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_builder.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_v2.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_v2_builder.h> -#include <vespa/vespalib/tensor/simple/simple_tensor.h> -#include <vespa/vespalib/tensor/simple/simple_tensor_builder.h> +#include <vespa/vespalib/tensor/sparse/sparse_tensor.h> +#include <vespa/vespalib/tensor/sparse/sparse_tensor_builder.h> #include <vespa/vespalib/tensor/dense/dense_tensor_builder.h> #include <vespa/vespalib/tensor/tensor.h> #include <vespa/vespalib/tensor/tensor_builder.h> @@ -57,9 +53,21 @@ void inject_params(const Function &function, const Params ¶ms, } } +std::vector<ValueType> extract_param_types(const Function &function, const Params ¶ms) { + std::vector<ValueType> result; + EXPECT_EQUAL(params.map.size(), function.num_params()); + for (size_t i = 0; i < function.num_params(); ++i) { + auto param = params.map.find(function.param_name(i)); + ASSERT_TRUE(param != params.map.end()); + result.push_back(param->second->type()); + } + return result; +} + double calculate_expression(const vespalib::string &expression, const Params ¶ms) { const Function function = Function::parse(expression); - const InterpretedFunction interpreted(tensor::DefaultTensorEngine::ref(), function); + const NodeTypes types(function, extract_param_types(function, params)); + const InterpretedFunction interpreted(tensor::DefaultTensorEngine::ref(), function, types); InterpretedFunction::Context context; inject_params(function, params, context); const Value &result = interpreted.eval(context); @@ -72,7 +80,8 @@ const Value &dummy_ranking(InterpretedFunction::Context &) { return dummy_result double benchmark_expression_us(const vespalib::string &expression, const Params ¶ms) { const Function function = Function::parse(expression); - const InterpretedFunction interpreted(tensor::DefaultTensorEngine::ref(), function); + const NodeTypes types(function, extract_param_types(function, params)); + const InterpretedFunction interpreted(tensor::DefaultTensorEngine::ref(), function, types); InterpretedFunction::Context context; inject_params(function, params, context); auto ranking = [&](){ interpreted.eval(context); }; @@ -86,7 +95,7 @@ tensor::Tensor::UP parse_tensor(const vespalib::string &tensor_str) { Function function = Function::parse(tensor_str); auto tensor = nodes::as<nodes::Tensor>(function.root()); ASSERT_TRUE(tensor); - SimpleTensorBuilder builder; + SparseTensorBuilder builder; for (const auto &cell: tensor->cells()) { for (const auto &dimension: cell.first) { builder.add_label(builder.define_dimension(dimension.first), dimension.second); @@ -117,8 +126,8 @@ TEST("SMOKETEST - require that model match benchmark expression produces expecte TEST("SMOKETEST - require that matrix product benchmark expression produces expected result") { Params params; - params.add("query", parse_tensor("{{x:0}:1.0}")); - params.add("document", parse_tensor("{{x:1}:2.0}")); + params.add("query", parse_tensor("{{x:0}:1.0,{x:1}:0.0}")); + params.add("document", parse_tensor("{{x:0}:0.0,{x:1}:2.0}")); params.add("model", parse_tensor("{{x:0,y:0}:1.0,{x:0,y:1}:2.0," " {x:1,y:0}:3.0,{x:1,y:1}:4.0}")); EXPECT_EQUAL(calculate_expression(matrix_product_expr, params), 17.0); @@ -226,22 +235,18 @@ tensor::Tensor::UP make_tensor_impl(const std::vector<DimensionSpec> &dimensions //----------------------------------------------------------------------------- -enum class BuilderType { DUMMY, SIMPLE, COMPACT, COMPACTV2, NUMBERDUMMY, +enum class BuilderType { DUMMY, SPARSE, NUMBERDUMMY, DENSE }; const BuilderType DUMMY = BuilderType::DUMMY; -const BuilderType SIMPLE = BuilderType::SIMPLE; -const BuilderType COMPACT = BuilderType::COMPACT; -const BuilderType COMPACTV2 = BuilderType::COMPACTV2; +const BuilderType SPARSE = BuilderType::SPARSE; const BuilderType NUMBERDUMMY = BuilderType::NUMBERDUMMY; const BuilderType DENSE = BuilderType::DENSE; const char *name(BuilderType type) { switch (type) { case BuilderType::DUMMY: return " dummy"; - case BuilderType::SIMPLE: return " simple"; - case BuilderType::COMPACT: return "compact"; - case BuilderType::COMPACTV2: return "compactv2"; + case BuilderType::SPARSE: return "sparse"; case BuilderType::NUMBERDUMMY: return "numberdummy"; case BuilderType::DENSE: return "dense"; } @@ -253,14 +258,8 @@ tensor::Tensor::UP make_tensor(BuilderType type, const std::vector<DimensionSpec case BuilderType::DUMMY: return make_tensor_impl<DummyBuilder, TensorBuilder, StringBinding> (dimensions); - case BuilderType::SIMPLE: - return make_tensor_impl<SimpleTensorBuilder, TensorBuilder, - StringBinding>(dimensions); - case BuilderType::COMPACT: - return make_tensor_impl<CompactTensorBuilder, TensorBuilder, - StringBinding>(dimensions); - case BuilderType::COMPACTV2: - return make_tensor_impl<CompactTensorV2Builder, TensorBuilder, + case BuilderType::SPARSE: + return make_tensor_impl<SparseTensorBuilder, TensorBuilder, StringBinding>(dimensions); case BuilderType::NUMBERDUMMY: return make_tensor_impl<DummyDenseTensorBuilder, @@ -289,7 +288,7 @@ double benchmark_build_us(BuilderType type, const std::vector<DimensionSpec> &sp TEST("benchmark create/destroy time for 1d tensors") { for (size_t size: {5, 10, 25, 50, 100, 250, 500}) { - for (auto type: {SIMPLE, COMPACT, COMPACTV2, DENSE}) { + for (auto type: {SPARSE, DENSE}) { double time_us = benchmark_build_us(type, {DimensionSpec("x", size)}); fprintf(stderr, "-- 1d tensor create/destroy (%s) with size %zu: %g us\n", name(type), size, time_us); } @@ -298,7 +297,7 @@ TEST("benchmark create/destroy time for 1d tensors") { TEST("benchmark create/destroy time for 2d tensors") { for (size_t size: {5, 10, 25, 50, 100}) { - for (auto type: {SIMPLE, COMPACT, COMPACTV2, DENSE}) { + for (auto type: {SPARSE, DENSE}) { double time_us = benchmark_build_us(type, {DimensionSpec("x", size), DimensionSpec("y", size)}); fprintf(stderr, "-- 2d tensor create/destroy (%s) with size %zux%zu: %g us\n", name(type), size, size, time_us); } @@ -309,7 +308,7 @@ TEST("benchmark create/destroy time for 2d tensors") { TEST("benchmark dot product using match") { for (size_t size: {10, 25, 50, 100, 250}) { - for (auto type: {SIMPLE, COMPACT, COMPACTV2, DENSE}) { + for (auto type: {SPARSE, DENSE}) { Params params; params.add("query", make_tensor(type, {DimensionSpec("x", size)})); params.add("document", make_tensor(type, {DimensionSpec("x", size)})); @@ -321,7 +320,7 @@ TEST("benchmark dot product using match") { TEST("benchmark dot product using multiply") { for (size_t size: {10, 25, 50, 100, 250}) { - for (auto type: {SIMPLE, COMPACT, COMPACTV2, DENSE}) { + for (auto type: {SPARSE, DENSE}) { Params params; params.add("query", make_tensor(type, {DimensionSpec("x", size)})); params.add("document", make_tensor(type, {DimensionSpec("x", size)})); @@ -335,7 +334,7 @@ TEST("benchmark model match") { for (size_t model_size: {25, 50, 100}) { for (size_t vector_size: {5, 10, 25, 50, 100}) { if (vector_size <= model_size) { - for (auto type: {SIMPLE, COMPACT, COMPACTV2}) { + for (auto type: {SPARSE}) { Params params; params.add("query", make_tensor(type, {DimensionSpec("x", vector_size)})); params.add("document", make_tensor(type, {DimensionSpec("y", vector_size)})); @@ -351,14 +350,10 @@ TEST("benchmark model match") { TEST("benchmark matrix product") { for (size_t vector_size: {5, 10, 25, 50}) { size_t matrix_size = vector_size * 2; - for (auto type: {SIMPLE, COMPACT, COMPACTV2, DENSE}) { + for (auto type: {SPARSE, DENSE}) { Params params; - size_t document_size = vector_size; - if (type == DENSE) { - document_size = matrix_size; - } - params.add("query", make_tensor(type, {DimensionSpec("x", vector_size, vector_size)})); - params.add("document", make_tensor(type, {DimensionSpec("x", document_size)})); + params.add("query", make_tensor(type, {DimensionSpec("x", matrix_size)})); + params.add("document", make_tensor(type, {DimensionSpec("x", matrix_size)})); params.add("model", make_tensor(type, {DimensionSpec("x", matrix_size), DimensionSpec("y", matrix_size)})); double time_us = benchmark_expression_us(matrix_product_expr, params); fprintf(stderr, "-- matrix product (%s) %zu + %zu vs %zux%zu: %g us\n", name(type), vector_size, vector_size, matrix_size, matrix_size, time_us); diff --git a/vespalib/src/tests/tensor/tensor_serialization/tensor_serialization_test.cpp b/vespalib/src/tests/tensor/tensor_serialization/tensor_serialization_test.cpp index 6a4fcefba9c..d1d713c2987 100644 --- a/vespalib/src/tests/tensor/tensor_serialization/tensor_serialization_test.cpp +++ b/vespalib/src/tests/tensor/tensor_serialization/tensor_serialization_test.cpp @@ -1,12 +1,8 @@ // Copyright 2016 Yahoo Inc. 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/vespalib/tensor/simple/simple_tensor.h> -#include <vespa/vespalib/tensor/simple/simple_tensor_builder.h> -#include <vespa/vespalib/tensor/compact/compact_tensor.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_builder.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_v2.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_v2_builder.h> +#include <vespa/vespalib/tensor/sparse/sparse_tensor.h> +#include <vespa/vespalib/tensor/sparse/sparse_tensor_builder.h> #include <vespa/vespalib/tensor/types.h> #include <vespa/vespalib/tensor/default_tensor.h> #include <vespa/vespalib/tensor/tensor_factory.h> @@ -101,9 +97,7 @@ struct Fixture } }; -using SimpleFixture = Fixture<SimpleTensorBuilder>; -using CompactFixture = Fixture<CompactTensorBuilder>; -using CompactV2Fixture = Fixture<CompactTensorV2Builder>; +using SparseFixture = Fixture<SparseTensorBuilder>; template <typename FixtureType> @@ -140,17 +134,7 @@ testTensorSerialization(FixtureType &f) { {{{"x","1"}}, 3} }, {"x", "y"})); } -TEST_F("test tensor serialization for SimpleTensor", SimpleFixture) -{ - testTensorSerialization(f); -} - -TEST_F("test tensor serialization for CompactTensor", CompactFixture) -{ - testTensorSerialization(f); -} - -TEST_F("test tensor serialization for CompactTensorV2", CompactV2Fixture) +TEST_F("test tensor serialization for SparseTensor", SparseFixture) { testTensorSerialization(f); } diff --git a/vespalib/src/tests/tensor/tensor_slime_serialization/tensor_slime_serialization_test.cpp b/vespalib/src/tests/tensor/tensor_slime_serialization/tensor_slime_serialization_test.cpp index f53b42c433e..f3005a21730 100644 --- a/vespalib/src/tests/tensor/tensor_slime_serialization/tensor_slime_serialization_test.cpp +++ b/vespalib/src/tests/tensor/tensor_slime_serialization/tensor_slime_serialization_test.cpp @@ -1,12 +1,8 @@ // Copyright 2016 Yahoo Inc. 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/vespalib/tensor/simple/simple_tensor.h> -#include <vespa/vespalib/tensor/simple/simple_tensor_builder.h> -#include <vespa/vespalib/tensor/compact/compact_tensor.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_builder.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_v2.h> -#include <vespa/vespalib/tensor/compact/compact_tensor_v2_builder.h> +#include <vespa/vespalib/tensor/sparse/sparse_tensor.h> +#include <vespa/vespalib/tensor/sparse/sparse_tensor_builder.h> #include <vespa/vespalib/tensor/types.h> #include <vespa/vespalib/tensor/default_tensor.h> #include <vespa/vespalib/tensor/tensor_factory.h> @@ -46,20 +42,10 @@ struct Fixture template <> uint32_t -Fixture<SimpleTensorBuilder>::getTensorTypeId() { return 0u; } +Fixture<SparseTensorBuilder>::getTensorTypeId() { return 2u; } -template <> -uint32_t -Fixture<CompactTensorBuilder>::getTensorTypeId() { return 1u; } -template <> -uint32_t -Fixture<CompactTensorV2Builder>::getTensorTypeId() { return 2u; } - - -using SimpleFixture = Fixture<SimpleTensorBuilder>; -using CompactFixture = Fixture<CompactTensorBuilder>; -using CompactV2Fixture = Fixture<CompactTensorV2Builder>; +using SparseFixture = Fixture<SparseTensorBuilder>; namespace { @@ -128,17 +114,7 @@ testTensorSlimeSerialization(FixtureType &f) {"x", "y"})); } -TEST_F("test tensor slime serialization for SimpleTensor", SimpleFixture) -{ - testTensorSlimeSerialization(f); -} - -TEST_F("test tensor slime serialization for CompactTensor", CompactFixture) -{ - testTensorSlimeSerialization(f); -} - -TEST_F("test tensor slime serialization for CompactTensorV2", CompactV2Fixture) +TEST_F("test tensor slime serialization for SparseTensor", SparseFixture) { testTensorSlimeSerialization(f); } |