Add benchmark for distance functions

17 files changed, 152 insertions, 31 deletions

diff --git a/searchlib/src/tests/tensor/distance_functions/CMakeLists.txt b/searchlib/src/tests/tensor/distance_functions/CMakeLists.txt
index e1a54f7883a..92ad9ae2648 100644
--- a/searchlib/src/tests/tensor/distance_functions/CMakeLists.txt
+++ b/searchlib/src/tests/tensor/distance_functions/CMakeLists.txt
@@ -7,3 +7,10 @@ vespa_add_executable(searchlib_distance_functions_test_app TEST
     GTest::GTest
 )
 vespa_add_test(NAME searchlib_distance_functions_test_app COMMAND searchlib_distance_functions_test_app)
+
+vespa_add_executable(searchlib_distance_functions_benchmark_app TEST
+    SOURCES
+    distance_functions_benchmark.cpp
+    DEPENDS
+    searchlib
+)
diff --git a/searchlib/src/tests/tensor/distance_functions/distance_functions_benchmark.cpp b/searchlib/src/tests/tensor/distance_functions/distance_functions_benchmark.cpp
new file mode 100644
index 00000000000..f633ea05a5a
--- /dev/null
+++ b/searchlib/src/tests/tensor/distance_functions/distance_functions_benchmark.cpp
@@ -0,0 +1,115 @@
+// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+#include <vespa/eval/eval/typed_cells.h>
+#include <vespa/searchlib/common/geo_gcd.h>
+#include <vespa/searchlib/tensor/distance_functions.h>
+#include <vespa/searchlib/tensor/distance_function_factory.h>
+#include <vespa/searchlib/tensor/mips_distance_transform.h>
+#include <vespa/vespalib/util/time.h>
+#include <vespa/vespalib/util/classname.h>
+
+using namespace search::tensor;
+using vespalib::eval::Int8Float;
+using vespalib::BFloat16;
+using vespalib::eval::TypedCells;
+using search::attribute::DistanceMetric;
+
+size_t npos = std::string::npos;
+
+void run_calc(size_t iterations, TypedCells b, const BoundDistanceFunction & df) __attribute_noinline__;
+void run_calc_with_limit(size_t iterations, TypedCells b, const BoundDistanceFunction & df) __attribute_noinline__;
+
+void
+run_calc(size_t iterations, TypedCells b, const BoundDistanceFunction & df) {
+    vespalib::steady_time start = vespalib::steady_clock::now();
+    for (size_t i(0); i < iterations; i++) {
+        df.calc(b);
+    }
+    vespalib::duration used = vespalib::steady_clock::now() - start;
+    printf("%s::calc: Time used = %1.3f\n", vespalib::getClassName(df).c_str(), vespalib::to_s(used));
+}
+
+void
+run_calc_with_limit(size_t iterations, TypedCells b, const BoundDistanceFunction & df) {
+    vespalib::steady_time start = vespalib::steady_clock::now();
+    for (size_t i(0); i < iterations; i++) {
+        df.calc_with_limit(b, std::numeric_limits<double>::max());
+    }
+    vespalib::duration used = vespalib::steady_clock::now() - start;
+    printf("%s::calc_with_limit: Time used = %1.3f\n", vespalib::getClassName(df).c_str(), vespalib::to_s(used));
+}
+
+template<typename T>
+void benchmark(size_t iterations, size_t elems) __attribute_noinline__;
+
+template<typename T>
+void benchmark(size_t iterations, size_t elems, const DistanceFunctionFactory & df) {
+    std::vector<T> av, bv;
+    srand(7);
+    av.reserve(elems);
+    bv.reserve(elems);
+    for (size_t i(0); i < elems; i++) {
+        av.push_back(rand());
+        bv.push_back(rand());
+    }
+    TypedCells a_cells(av), b_cells(bv);
+
+    run_calc(iterations, b_cells, *df.for_query_vector(a_cells));
+    run_calc_with_limit(iterations, b_cells, *df.for_query_vector(a_cells));
+}
+
+template<typename T>
+void benchmark(size_t iterations, size_t elems, const std::string & dist_functions) {
+    if (dist_functions.find("euclid") != npos) {
+        benchmark<T>(iterations, elems, EuclideanDistanceFunctionFactory<T>());
+    }
+    if (dist_functions.find("angular") != npos) {
+        if (std::is_same<T, double>() || std::is_same<T, float>()) {
+            benchmark<T>(iterations, elems, AngularDistanceFunctionFactory<T>());
+        }
+    }
+    if (dist_functions.find("prenorm") != npos) {
+        if (std::is_same<T, double>() || std::is_same<T, float>()) {
+            benchmark<T>(iterations, elems, PrenormalizedAngularDistanceFunctionFactory<T>());
+        }
+    }
+    if (dist_functions.find("mips") != npos) {
+        if (std::is_same<T, double>() || std::is_same<T, float>() || std::is_same<T, Int8Float>()) {
+            benchmark<T>(iterations, elems, MipsDistanceFunctionFactory<T>());
+        }
+    }
+}
+
+void
+benchmark(size_t iterations, size_t elems, const std::string & dist_functions, const std::string & data_types) {
+    if (data_types.find("double") != npos) {
+        benchmark<double>(iterations, elems, dist_functions);
+    }
+    if (data_types.find("float32") != npos) {
+        benchmark<float>(iterations, elems, dist_functions);
+    }
+    if (data_types.find("bfloat16") != npos) {
+        benchmark<BFloat16>(iterations, elems, dist_functions);
+    }
+    if (data_types.find("float8") != npos) {
+        benchmark<Int8Float>(iterations, elems, dist_functions);
+    }
+}
+
+int
+main(int argc, char *argv[]) {
+    size_t num_iterations = 10000000;
+    size_t num_elems = 1024;
+    std::string dist_functions = "angular euclid prenorm mips";
+    std::string data_types = "double float32 bfloat16 float8";
+    if (argc > 1) { num_iterations = atol(argv[1]); }
+    if (argc > 2) { num_elems = atol(argv[2]); }
+    if (argc > 3) { dist_functions = argv[3]; }
+    if (argc > 4) { data_types = argv[4]; }
+
+    printf("Benchmarking %ld iterations with vector length %ld with distance functions '%s' for data types '%s'\n",
+           num_iterations, num_elems, dist_functions.c_str(), data_types.c_str());
+    benchmark(num_iterations, num_elems, dist_functions, data_types);
+
+    return 0;
+}
\ No newline at end of file
diff --git a/searchlib/src/tests/tensor/hnsw_index/hnsw_index_test.cpp b/searchlib/src/tests/tensor/hnsw_index/hnsw_index_test.cpp
index a1cf86c95cc..97b88bc787a 100644
--- a/searchlib/src/tests/tensor/hnsw_index/hnsw_index_test.cpp
+++ b/searchlib/src/tests/tensor/hnsw_index/hnsw_index_test.cpp
@@ -111,7 +111,7 @@ class MyBoundDistanceFunction : public BoundDistanceFunction {
     std::unique_ptr<BoundDistanceFunction> _real;
 
 public:
-    MyBoundDistanceFunction(std::unique_ptr<BoundDistanceFunction> real)
+    explicit MyBoundDistanceFunction(std::unique_ptr<BoundDistanceFunction> real)
         : _real(std::move(real))
     {
     }
@@ -147,19 +147,19 @@ class MyDistanceFunctionFactory : public DistanceFunctionFactory
 {
     std::unique_ptr<DistanceFunctionFactory> _real;
 public:
-    MyDistanceFunctionFactory(std::unique_ptr<DistanceFunctionFactory> real)
+    explicit MyDistanceFunctionFactory(std::unique_ptr<DistanceFunctionFactory> real)
         : _real(std::move(real))
     {
     }
 
     ~MyDistanceFunctionFactory() override;
 
-    std::unique_ptr<BoundDistanceFunction> for_query_vector(TypedCells lhs) override {
+    std::unique_ptr<BoundDistanceFunction> for_query_vector(TypedCells lhs) const override {
         EXPECT_FALSE(lhs.non_existing_attribute_value());
         return std::make_unique<MyBoundDistanceFunction>(_real->for_query_vector(lhs));
     }
 
-    std::unique_ptr<BoundDistanceFunction> for_insertion_vector(TypedCells lhs) override {
+    std::unique_ptr<BoundDistanceFunction> for_insertion_vector(TypedCells lhs) const override {
         EXPECT_FALSE(lhs.non_existing_attribute_value());
         return std::make_unique<MyBoundDistanceFunction>(_real->for_insertion_vector(lhs));
     }
diff --git a/searchlib/src/vespa/searchlib/tensor/angular_distance.cpp b/searchlib/src/vespa/searchlib/tensor/angular_distance.cpp
index af99260979d..ef40381c807 100644
--- a/searchlib/src/vespa/searchlib/tensor/angular_distance.cpp
+++ b/searchlib/src/vespa/searchlib/tensor/angular_distance.cpp
@@ -70,14 +70,14 @@ template class BoundAngularDistance<double>;
 
 template <typename FloatType>
 BoundDistanceFunction::UP
-AngularDistanceFunctionFactory<FloatType>::for_query_vector(TypedCells lhs) {
+AngularDistanceFunctionFactory<FloatType>::for_query_vector(TypedCells lhs) const {
     using DFT = BoundAngularDistance<FloatType>;
     return std::make_unique<DFT>(lhs);
 }
 
 template <typename FloatType>
 BoundDistanceFunction::UP
-AngularDistanceFunctionFactory<FloatType>::for_insertion_vector(TypedCells lhs) {
+AngularDistanceFunctionFactory<FloatType>::for_insertion_vector(TypedCells lhs) const {
     using DFT = BoundAngularDistance<FloatType>;
     return std::make_unique<DFT>(lhs);
 }
diff --git a/searchlib/src/vespa/searchlib/tensor/angular_distance.h b/searchlib/src/vespa/searchlib/tensor/angular_distance.h
index 5e0a060e060..aa51f58b3cd 100644
--- a/searchlib/src/vespa/searchlib/tensor/angular_distance.h
+++ b/searchlib/src/vespa/searchlib/tensor/angular_distance.h
@@ -15,8 +15,8 @@ template <typename FloatType>
 class AngularDistanceFunctionFactory : public DistanceFunctionFactory {
 public:
     AngularDistanceFunctionFactory() = default;
-    BoundDistanceFunction::UP for_query_vector(TypedCells lhs) override;
-    BoundDistanceFunction::UP for_insertion_vector(TypedCells lhs) override;
+    BoundDistanceFunction::UP for_query_vector(TypedCells lhs) const override;
+    BoundDistanceFunction::UP for_insertion_vector(TypedCells lhs) const override;
 };
 
 }
diff --git a/searchlib/src/vespa/searchlib/tensor/distance_function_factory.h b/searchlib/src/vespa/searchlib/tensor/distance_function_factory.h
index 356366d6a77..3b0a0ac91fd 100644
--- a/searchlib/src/vespa/searchlib/tensor/distance_function_factory.h
+++ b/searchlib/src/vespa/searchlib/tensor/distance_function_factory.h
@@ -17,8 +17,8 @@ struct DistanceFunctionFactory {
     using TypedCells = vespalib::eval::TypedCells;
     DistanceFunctionFactory() noexcept = default;
     virtual ~DistanceFunctionFactory() = default;
-    virtual BoundDistanceFunction::UP for_query_vector(TypedCells lhs) = 0;
-    virtual BoundDistanceFunction::UP for_insertion_vector(TypedCells lhs) = 0;
+    virtual BoundDistanceFunction::UP for_query_vector(TypedCells lhs) const = 0;
+    virtual BoundDistanceFunction::UP for_insertion_vector(TypedCells lhs) const = 0;
     using UP = std::unique_ptr<DistanceFunctionFactory>;
 };
 
diff --git a/searchlib/src/vespa/searchlib/tensor/euclidean_distance.cpp b/searchlib/src/vespa/searchlib/tensor/euclidean_distance.cpp
index a7e421a4679..c2867ef6f7a 100644
--- a/searchlib/src/vespa/searchlib/tensor/euclidean_distance.cpp
+++ b/searchlib/src/vespa/searchlib/tensor/euclidean_distance.cpp
@@ -63,14 +63,14 @@ template class BoundEuclideanDistance<double>;
 
 template <typename FloatType>
 BoundDistanceFunction::UP
-EuclideanDistanceFunctionFactory<FloatType>::for_query_vector(TypedCells lhs) {
+EuclideanDistanceFunctionFactory<FloatType>::for_query_vector(TypedCells lhs) const {
     using DFT = BoundEuclideanDistance<FloatType>;
     return std::make_unique<DFT>(lhs);
 }
 
 template <typename FloatType>
 BoundDistanceFunction::UP
-EuclideanDistanceFunctionFactory<FloatType>::for_insertion_vector(TypedCells lhs) {
+EuclideanDistanceFunctionFactory<FloatType>::for_insertion_vector(TypedCells lhs) const {
     using DFT = BoundEuclideanDistance<FloatType>;
     return std::make_unique<DFT>(lhs);
 }
diff --git a/searchlib/src/vespa/searchlib/tensor/euclidean_distance.h b/searchlib/src/vespa/searchlib/tensor/euclidean_distance.h
index 8c39a12bf86..78460c93307 100644
--- a/searchlib/src/vespa/searchlib/tensor/euclidean_distance.h
+++ b/searchlib/src/vespa/searchlib/tensor/euclidean_distance.h
@@ -15,8 +15,8 @@ template <typename FloatType>
 class EuclideanDistanceFunctionFactory : public DistanceFunctionFactory {
 public:
     EuclideanDistanceFunctionFactory() noexcept = default;
-    BoundDistanceFunction::UP for_query_vector(TypedCells lhs) override;
-    BoundDistanceFunction::UP for_insertion_vector(TypedCells lhs) override;
+    BoundDistanceFunction::UP for_query_vector(TypedCells lhs) const override;
+    BoundDistanceFunction::UP for_insertion_vector(TypedCells lhs) const override;
 };
 
 }
diff --git a/searchlib/src/vespa/searchlib/tensor/geo_degrees_distance.cpp b/searchlib/src/vespa/searchlib/tensor/geo_degrees_distance.cpp
index f5484f40271..a8a48ae4116 100644
--- a/searchlib/src/vespa/searchlib/tensor/geo_degrees_distance.cpp
+++ b/searchlib/src/vespa/searchlib/tensor/geo_degrees_distance.cpp
@@ -82,12 +82,12 @@ public:
 };
 
 BoundDistanceFunction::UP
-GeoDistanceFunctionFactory::for_query_vector(TypedCells lhs) {
+GeoDistanceFunctionFactory::for_query_vector(TypedCells lhs) const {
     return std::make_unique<BoundGeoDistance>(lhs);
 }
 
 BoundDistanceFunction::UP
-GeoDistanceFunctionFactory::for_insertion_vector(TypedCells lhs) {
+GeoDistanceFunctionFactory::for_insertion_vector(TypedCells lhs) const {
     return std::make_unique<BoundGeoDistance>(lhs);
 }
 
diff --git a/searchlib/src/vespa/searchlib/tensor/geo_degrees_distance.h b/searchlib/src/vespa/searchlib/tensor/geo_degrees_distance.h
index 1464898421b..a85e31e8ecc 100644
--- a/searchlib/src/vespa/searchlib/tensor/geo_degrees_distance.h
+++ b/searchlib/src/vespa/searchlib/tensor/geo_degrees_distance.h
@@ -14,8 +14,8 @@ namespace search::tensor {
 class GeoDistanceFunctionFactory : public DistanceFunctionFactory {
 public:
     GeoDistanceFunctionFactory() = default;
-    BoundDistanceFunction::UP for_query_vector(TypedCells lhs) override;
-    BoundDistanceFunction::UP for_insertion_vector(TypedCells lhs) override;
+    BoundDistanceFunction::UP for_query_vector(TypedCells lhs) const override;
+    BoundDistanceFunction::UP for_insertion_vector(TypedCells lhs) const override;
 };
 
 }
diff --git a/searchlib/src/vespa/searchlib/tensor/hamming_distance.cpp b/searchlib/src/vespa/searchlib/tensor/hamming_distance.cpp
index 7f29a100492..7ea2e440a51 100644
--- a/searchlib/src/vespa/searchlib/tensor/hamming_distance.cpp
+++ b/searchlib/src/vespa/searchlib/tensor/hamming_distance.cpp
@@ -49,14 +49,14 @@ public:
 
 template <typename FloatType>
 BoundDistanceFunction::UP
-HammingDistanceFunctionFactory<FloatType>::for_query_vector(TypedCells lhs) {
+HammingDistanceFunctionFactory<FloatType>::for_query_vector(TypedCells lhs) const {
     using DFT = BoundHammingDistance<FloatType>;
     return std::make_unique<DFT>(lhs);
 }
 
 template <typename FloatType>
 BoundDistanceFunction::UP
-HammingDistanceFunctionFactory<FloatType>::for_insertion_vector(TypedCells lhs) {
+HammingDistanceFunctionFactory<FloatType>::for_insertion_vector(TypedCells lhs) const {
     using DFT = BoundHammingDistance<FloatType>;
     return std::make_unique<DFT>(lhs);
 }
diff --git a/searchlib/src/vespa/searchlib/tensor/hamming_distance.h b/searchlib/src/vespa/searchlib/tensor/hamming_distance.h
index 6e7f96e1e2f..2e3b75cc61f 100644
--- a/searchlib/src/vespa/searchlib/tensor/hamming_distance.h
+++ b/searchlib/src/vespa/searchlib/tensor/hamming_distance.h
@@ -16,8 +16,8 @@ template <typename FloatType>
 class HammingDistanceFunctionFactory : public DistanceFunctionFactory {
 public:
     HammingDistanceFunctionFactory() = default;
-    BoundDistanceFunction::UP for_query_vector(TypedCells lhs) override;
-    BoundDistanceFunction::UP for_insertion_vector(TypedCells lhs) override;
+    BoundDistanceFunction::UP for_query_vector(TypedCells lhs) const override;
+    BoundDistanceFunction::UP for_insertion_vector(TypedCells lhs) const override;
 };
 
 }
diff --git a/searchlib/src/vespa/searchlib/tensor/mips_distance_transform.cpp b/searchlib/src/vespa/searchlib/tensor/mips_distance_transform.cpp
index c42242d8dc8..fa47187fec9 100644
--- a/searchlib/src/vespa/searchlib/tensor/mips_distance_transform.cpp
+++ b/searchlib/src/vespa/searchlib/tensor/mips_distance_transform.cpp
@@ -76,13 +76,13 @@ public:
 
 template<typename FloatType>
 BoundDistanceFunction::UP
-MipsDistanceFunctionFactory<FloatType>::for_query_vector(TypedCells lhs) {
+MipsDistanceFunctionFactory<FloatType>::for_query_vector(TypedCells lhs) const {
     return std::make_unique<BoundMipsDistanceFunction<FloatType, false>>(lhs, *_sq_norm_store);
 }
 
 template<typename FloatType>
 BoundDistanceFunction::UP
-MipsDistanceFunctionFactory<FloatType>::for_insertion_vector(TypedCells lhs) {
+MipsDistanceFunctionFactory<FloatType>::for_insertion_vector(TypedCells lhs) const {
     return std::make_unique<BoundMipsDistanceFunction<FloatType, true>>(lhs, *_sq_norm_store);
 };
 
diff --git a/searchlib/src/vespa/searchlib/tensor/mips_distance_transform.h b/searchlib/src/vespa/searchlib/tensor/mips_distance_transform.h
index 67a6eb58de0..336511ab78f 100644
--- a/searchlib/src/vespa/searchlib/tensor/mips_distance_transform.h
+++ b/searchlib/src/vespa/searchlib/tensor/mips_distance_transform.h
@@ -62,8 +62,8 @@ public:
     MipsDistanceFunctionFactory() noexcept = default;
     ~MipsDistanceFunctionFactory() override = default;
 
-    BoundDistanceFunction::UP for_query_vector(TypedCells lhs) override;
-    BoundDistanceFunction::UP for_insertion_vector(TypedCells lhs) override;
+    BoundDistanceFunction::UP for_query_vector(TypedCells lhs) const override;
+    BoundDistanceFunction::UP for_insertion_vector(TypedCells lhs) const override;
 };
 
 }
diff --git a/searchlib/src/vespa/searchlib/tensor/prenormalized_angular_distance.cpp b/searchlib/src/vespa/searchlib/tensor/prenormalized_angular_distance.cpp
index 4bc90001227..58e92cbe2d4 100644
--- a/searchlib/src/vespa/searchlib/tensor/prenormalized_angular_distance.cpp
+++ b/searchlib/src/vespa/searchlib/tensor/prenormalized_angular_distance.cpp
@@ -62,14 +62,14 @@ template class BoundPrenormalizedAngularDistance<double>;
 
 template <typename FloatType>
 BoundDistanceFunction::UP
-PrenormalizedAngularDistanceFunctionFactory<FloatType>::for_query_vector(TypedCells lhs) {
+PrenormalizedAngularDistanceFunctionFactory<FloatType>::for_query_vector(TypedCells lhs) const {
     using DFT = BoundPrenormalizedAngularDistance<FloatType>;
     return std::make_unique<DFT>(lhs);
 }
 
 template <typename FloatType>
 BoundDistanceFunction::UP
-PrenormalizedAngularDistanceFunctionFactory<FloatType>::for_insertion_vector(TypedCells lhs) {
+PrenormalizedAngularDistanceFunctionFactory<FloatType>::for_insertion_vector(TypedCells lhs) const {
     using DFT = BoundPrenormalizedAngularDistance<FloatType>;
     return std::make_unique<DFT>(lhs);
 }
diff --git a/searchlib/src/vespa/searchlib/tensor/prenormalized_angular_distance.h b/searchlib/src/vespa/searchlib/tensor/prenormalized_angular_distance.h
index 7e3a8c2c676..6a791e0b6ec 100644
--- a/searchlib/src/vespa/searchlib/tensor/prenormalized_angular_distance.h
+++ b/searchlib/src/vespa/searchlib/tensor/prenormalized_angular_distance.h
@@ -14,8 +14,8 @@ template <typename FloatType>
 class PrenormalizedAngularDistanceFunctionFactory : public DistanceFunctionFactory {
 public:
     PrenormalizedAngularDistanceFunctionFactory() = default;
-    BoundDistanceFunction::UP for_query_vector(TypedCells lhs) override;
-    BoundDistanceFunction::UP for_insertion_vector(TypedCells lhs) override;
+    BoundDistanceFunction::UP for_query_vector(TypedCells lhs) const override;
+    BoundDistanceFunction::UP for_insertion_vector(TypedCells lhs) const override;
 };
 
 }
diff --git a/vespalib/src/tests/util/hamming/hamming_benchmark.cpp b/vespalib/src/tests/util/hamming/hamming_benchmark.cpp
index 347c935f5b7..2600ec217aa 100644
--- a/vespalib/src/tests/util/hamming/hamming_benchmark.cpp
+++ b/vespalib/src/tests/util/hamming/hamming_benchmark.cpp
@@ -4,7 +4,6 @@
 #include <vector>
 #include <cinttypes>
 #include <cstdlib>
-#include <cstdint>
 #include <cstdio>
 
 using namespace vespalib;