make one DistanceCalculator per NearestNeighborIterator instance

6 files changed, 23 insertions, 35 deletions

diff --git a/searchlib/src/tests/queryeval/nearest_neighbor/nearest_neighbor_test.cpp b/searchlib/src/tests/queryeval/nearest_neighbor/nearest_neighbor_test.cpp
index b9599a0c75d..f3545499231 100644
--- a/searchlib/src/tests/queryeval/nearest_neighbor/nearest_neighbor_test.cpp
+++ b/searchlib/src/tests/queryeval/nearest_neighbor/nearest_neighbor_test.cpp
@@ -126,11 +126,12 @@ SimpleResult find_matches(Fixture &env, const Value &qtv, double threshold = std
     auto dff = search::tensor::make_distance_function_factory(DistanceMetric::Euclidean, qtv.cells().type);
     auto df = dff->for_query_vector(qtv.cells());
     threshold = df->convert_threshold(threshold);
-    DistanceCalculator dist_calc(attr, std::move(df));
     NearestNeighborDistanceHeap dh(2);
     dh.set_distance_threshold(threshold);
     const GlobalFilter &filter = *env._global_filter;
-    auto search = NearestNeighborIterator::create(strict, tfmd, dist_calc, dh, filter);
+    auto search = NearestNeighborIterator::create(strict, tfmd,
+                                                  std::make_unique<DistanceCalculator>(attr, qtv),
+                                                  dh, filter);
     if (strict) {
         return SimpleResult().searchStrict(*search, attr.getNumDocs());
     } else {
@@ -253,10 +254,11 @@ std::vector<feature_t> get_rawscores(Fixture &env, const Value &qtv) {
     auto &tfmd = *(md->resolveTermField(0));
     auto &attr = *(env._attr);
     auto dff = search::tensor::make_distance_function_factory(DistanceMetric::Euclidean, qtv.cells().type);
-    DistanceCalculator dist_calc(attr, dff->for_query_vector(qtv.cells()));
     NearestNeighborDistanceHeap dh(2);
     auto dummy_filter = GlobalFilter::create();
-    auto search = NearestNeighborIterator::create(strict, tfmd, dist_calc, dh, *dummy_filter);
+    auto search = NearestNeighborIterator::create(strict, tfmd,
+                                                  std::make_unique<DistanceCalculator>(attr, qtv),
+                                                  dh, *dummy_filter);
     uint32_t limit = attr.getNumDocs();
     uint32_t docid = 1;
     search->initRange(docid, limit);
diff --git a/searchlib/src/vespa/searchlib/queryeval/nearest_neighbor_blueprint.cpp b/searchlib/src/vespa/searchlib/queryeval/nearest_neighbor_blueprint.cpp
index 87ddb8b6edc..62937129f37 100644
--- a/searchlib/src/vespa/searchlib/queryeval/nearest_neighbor_blueprint.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/nearest_neighbor_blueprint.cpp
@@ -133,7 +133,8 @@ NearestNeighborBlueprint::createLeafSearch(const search::fef::TermFieldMatchData
     default:
         ;
     }
-    return NearestNeighborIterator::create(strict, tfmd, *_distance_calc,
+    return NearestNeighborIterator::create(strict, tfmd,
+                                           std::make_unique<search::tensor::DistanceCalculator>(_attr_tensor, _query_tensor),
                                            _distance_heap, *_global_filter);
 }
 
diff --git a/searchlib/src/vespa/searchlib/queryeval/nearest_neighbor_iterator.cpp b/searchlib/src/vespa/searchlib/queryeval/nearest_neighbor_iterator.cpp
index 92c9a21db83..a71a8e6a49a 100644
--- a/searchlib/src/vespa/searchlib/queryeval/nearest_neighbor_iterator.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/nearest_neighbor_iterator.cpp
@@ -23,9 +23,8 @@ template <bool strict, bool has_filter>
 class NearestNeighborImpl : public NearestNeighborIterator
 {
 public:
-
     NearestNeighborImpl(Params params_in)
-        : NearestNeighborIterator(params_in),
+        : NearestNeighborIterator(std::move(params_in)),
           _lastScore(0.0)
     {
     }
@@ -53,7 +52,7 @@ public:
     }
 
     void doUnpack(uint32_t docId) override {
-        double score = params().distance_calc.function().to_rawscore(_lastScore);
+        double score = params().distance_calc->function().to_rawscore(_lastScore);
         params().tfmd.setRawScore(docId, score);
         params().distanceHeap.used(_lastScore);
     }
@@ -62,7 +61,7 @@ public:
 
 private:
     double computeDistance(uint32_t docId, double limit) {
-        return params().distance_calc.calc_with_limit(docId, limit);
+        return params().distance_calc->calc_with_limit(docId, limit);
     }
 
     double                 _lastScore;
@@ -75,14 +74,14 @@ namespace {
 
 template <bool has_filter>
 std::unique_ptr<NearestNeighborIterator>
-resolve_strict(bool strict, const NearestNeighborIterator::Params &params)
+resolve_strict(bool strict, NearestNeighborIterator::Params params)
 {
     if (strict) {
         using NNI = NearestNeighborImpl<true, has_filter>;
-        return std::make_unique<NNI>(params);
+        return std::make_unique<NNI>(std::move(params));
     } else {
         using NNI = NearestNeighborImpl<false, has_filter>;
-        return std::make_unique<NNI>(params);
+        return std::make_unique<NNI>(std::move(params));
     }
 }
 
@@ -92,15 +91,15 @@ std::unique_ptr<NearestNeighborIterator>
 NearestNeighborIterator::create(
         bool strict,
         fef::TermFieldMatchData &tfmd,
-        const search::tensor::DistanceCalculator &distance_calc,
+        std::unique_ptr<search::tensor::DistanceCalculator> distance_calc,
         NearestNeighborDistanceHeap &distanceHeap,
         const GlobalFilter &filter)
 {
-    Params params(tfmd, distance_calc, distanceHeap, filter);
+    Params params(tfmd, std::move(distance_calc), distanceHeap, filter);
     if (filter.is_active()) {
-        return resolve_strict<true>(strict, params);
+        return resolve_strict<true>(strict, std::move(params));
     } else  {
-        return resolve_strict<false>(strict, params);
+        return resolve_strict<false>(strict, std::move(params));
     }
 }
 
diff --git a/searchlib/src/vespa/searchlib/queryeval/nearest_neighbor_iterator.h b/searchlib/src/vespa/searchlib/queryeval/nearest_neighbor_iterator.h
index fe3f8d51d06..884f0f2f3eb 100644
--- a/searchlib/src/vespa/searchlib/queryeval/nearest_neighbor_iterator.h
+++ b/searchlib/src/vespa/searchlib/queryeval/nearest_neighbor_iterator.h
@@ -24,29 +24,29 @@ public:
 
     struct Params {
         fef::TermFieldMatchData &tfmd;
-        const search::tensor::DistanceCalculator &distance_calc;
+        std::unique_ptr<search::tensor::DistanceCalculator> distance_calc;
         NearestNeighborDistanceHeap &distanceHeap;
         const GlobalFilter &filter;
 
         Params(fef::TermFieldMatchData &tfmd_in,
-               const search::tensor::DistanceCalculator &distance_calc_in,
+               std::unique_ptr<search::tensor::DistanceCalculator> distance_calc_in,
                NearestNeighborDistanceHeap &distanceHeap_in,
                const GlobalFilter &filter_in)
           : tfmd(tfmd_in),
-            distance_calc(distance_calc_in),
+            distance_calc(std::move(distance_calc_in)),
             distanceHeap(distanceHeap_in),
             filter(filter_in)
         {}
     };
 
     NearestNeighborIterator(Params params_in)
-        : _params(params_in)
+        : _params(std::move(params_in))
     {}
 
     static std::unique_ptr<NearestNeighborIterator> create(
             bool strict,
             fef::TermFieldMatchData &tfmd,
-            const search::tensor::DistanceCalculator &distance_calc,
+            std::unique_ptr<search::tensor::DistanceCalculator> distance_calc,
             NearestNeighborDistanceHeap &distanceHeap,
             const GlobalFilter &filter);
 
diff --git a/searchlib/src/vespa/searchlib/tensor/distance_calculator.cpp b/searchlib/src/vespa/searchlib/tensor/distance_calculator.cpp
index 5759b4b74ea..f65c7103540 100644
--- a/searchlib/src/vespa/searchlib/tensor/distance_calculator.cpp
+++ b/searchlib/src/vespa/searchlib/tensor/distance_calculator.cpp
@@ -30,14 +30,6 @@ DistanceCalculator::DistanceCalculator(const tensor::ITensorAttribute& attr_tens
     assert(_dist_fun);
 }
 
-DistanceCalculator::DistanceCalculator(const tensor::ITensorAttribute& attr_tensor,
-                                       BoundDistanceFunction::UP function_in)
-    : _attr_tensor(attr_tensor),
-      _query_tensor(nullptr),
-      _dist_fun(std::move(function_in))
-{
-}
-
 DistanceCalculator::~DistanceCalculator() = default;
 
 namespace {
diff --git a/searchlib/src/vespa/searchlib/tensor/distance_calculator.h b/searchlib/src/vespa/searchlib/tensor/distance_calculator.h
index b65f4ff1868..f44bc0d33cf 100644
--- a/searchlib/src/vespa/searchlib/tensor/distance_calculator.h
+++ b/searchlib/src/vespa/searchlib/tensor/distance_calculator.h
@@ -29,12 +29,6 @@ public:
     DistanceCalculator(const tensor::ITensorAttribute& attr_tensor,
                        const vespalib::eval::Value& query_tensor_in);
 
-    /**
-     * Only used by unit tests where ownership of query tensor and distance function is handled outside.
-     */
-    DistanceCalculator(const tensor::ITensorAttribute& attr_tensor,
-                       BoundDistanceFunction::UP function_in);
-
     ~DistanceCalculator();
 
     const tensor::ITensorAttribute& attribute_tensor() const { return _attr_tensor; }