Merge pull request #20420 from vespa-engine/toregge/add-compaction-spec

Add CompactionSpec.

16 files changed, 70 insertions, 42 deletions

diff --git a/searchlib/src/tests/attribute/multi_value_mapping/multi_value_mapping_test.cpp b/searchlib/src/tests/attribute/multi_value_mapping/multi_value_mapping_test.cpp
index 8b1906573d4..bddaa4f4e31 100644
--- a/searchlib/src/tests/attribute/multi_value_mapping/multi_value_mapping_test.cpp
+++ b/searchlib/src/tests/attribute/multi_value_mapping/multi_value_mapping_test.cpp
@@ -14,6 +14,8 @@
 LOG_SETUP("multivaluemapping_test");
 
 using vespalib::datastore::ArrayStoreConfig;
+using vespalib::datastore::CompactionSpec;
+using vespalib::datastore::CompactionStrategy;
 
 template <typename EntryT>
 void
@@ -142,7 +144,9 @@ public:
     }
 
     void compactWorst() {
-        _mvMapping->compactWorst(true, false);
+        CompactionSpec compaction_spec(true, false);
+        CompactionStrategy compaction_strategy;
+        _mvMapping->compactWorst(compaction_spec, compaction_strategy);
         _attr->commit();
         _attr->incGeneration();
     }
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 c35aba92c56..bb2d750eade 100644
--- a/searchlib/src/tests/tensor/hnsw_index/hnsw_index_test.cpp
+++ b/searchlib/src/tests/tensor/hnsw_index/hnsw_index_test.cpp
@@ -6,6 +6,7 @@
 #include <vespa/searchlib/tensor/hnsw_index.h>
 #include <vespa/searchlib/tensor/random_level_generator.h>
 #include <vespa/searchlib/tensor/inv_log_level_generator.h>
+#include <vespa/vespalib/datastore/compaction_spec.h>
 #include <vespa/vespalib/datastore/compaction_strategy.h>
 #include <vespa/vespalib/gtest/gtest.h>
 #include <vespa/vespalib/util/generationhandler.h>
@@ -21,6 +22,7 @@ using namespace search::tensor;
 using namespace vespalib::slime;
 using vespalib::Slime;
 using search::BitVector;
+using vespalib::datastore::CompactionSpec;
 using vespalib::datastore::CompactionStrategy;
 
 template <typename FloatType>
@@ -628,8 +630,10 @@ TEST_F(HnswIndexTest, hnsw_graph_is_compacted)
     for (uint32_t i = 0; i < 10; ++i) {
         mem_1 = mem_2;
         // Forced compaction to move things around
-        index->compact_link_arrays(true, false);
-        index->compact_level_arrays(true, false);
+        CompactionSpec compaction_spec(true, false);
+        CompactionStrategy compaction_strategy;
+        index->compact_link_arrays(compaction_spec, compaction_strategy);
+        index->compact_level_arrays(compaction_spec, compaction_strategy);
         commit();
         index->update_stat();
         mem_2 = commit_and_update_stat();
diff --git a/searchlib/src/vespa/searchlib/attribute/enumstore.h b/searchlib/src/vespa/searchlib/attribute/enumstore.h
index a140a529c7d..12871c967ff 100644
--- a/searchlib/src/vespa/searchlib/attribute/enumstore.h
+++ b/searchlib/src/vespa/searchlib/attribute/enumstore.h
@@ -201,7 +201,7 @@ public:
     void free_unused_values(IndexList to_remove);
     vespalib::MemoryUsage update_stat() override;
     std::unique_ptr<EnumIndexRemapper> consider_compact_values(const CompactionStrategy& compaction_strategy) override;
-    std::unique_ptr<EnumIndexRemapper> compact_worst_values(bool compact_memory, bool compact_address_space) override;
+    std::unique_ptr<EnumIndexRemapper> compact_worst_values(CompactionSpec compaction_spec, const CompactionStrategy& compaction_strategy) override;
     bool consider_compact_dictionary(const CompactionStrategy& compaction_strategy) override;
     uint64_t get_compaction_count() const override {
         return _store.get_data_store().get_compaction_count();
diff --git a/searchlib/src/vespa/searchlib/attribute/enumstore.hpp b/searchlib/src/vespa/searchlib/attribute/enumstore.hpp
index 897a2153b2b..2c985d2edf5 100644
--- a/searchlib/src/vespa/searchlib/attribute/enumstore.hpp
+++ b/searchlib/src/vespa/searchlib/attribute/enumstore.hpp
@@ -236,16 +236,17 @@ EnumStoreT<EntryT>::consider_compact_values(const CompactionStrategy& compaction
     bool compact_memory = compaction_strategy.should_compact_memory(used_bytes, dead_bytes);
     bool compact_address_space = compaction_strategy.should_compact_address_space(used_address_space, dead_address_space);
     if (compact_memory || compact_address_space) {
-        return compact_worst_values(compact_memory, compact_address_space);
+        CompactionSpec compaction_spec(compact_memory, compact_address_space);
+        return compact_worst_values(compaction_spec, compaction_strategy);
     }
     return std::unique_ptr<IEnumStore::EnumIndexRemapper>();
 }
 
 template <typename EntryT>
 std::unique_ptr<IEnumStore::EnumIndexRemapper>
-EnumStoreT<EntryT>::compact_worst_values(bool compact_memory, bool compact_address_space)
+EnumStoreT<EntryT>::compact_worst_values(CompactionSpec compaction_spec, const CompactionStrategy& compaction_strategy)
 {
-    return _store.compact_worst(compact_memory, compact_address_space);
+    return _store.compact_worst(compaction_spec, compaction_strategy);
 }
 
 template <typename EntryT>
@@ -258,13 +259,13 @@ EnumStoreT<EntryT>::consider_compact_dictionary(const CompactionStrategy& compac
     if (compaction_strategy.should_compact_memory(_cached_dictionary_btree_usage.usedBytes(),
                                                   _cached_dictionary_btree_usage.deadBytes()))
     {
-        _dict->compact_worst(true, false);
+        _dict->compact_worst(true, false, compaction_strategy);
         return true;
     }
     if (compaction_strategy.should_compact_memory(_cached_dictionary_hash_usage.usedBytes(),
                                                   _cached_dictionary_hash_usage.deadBytes()))
     {
-        _dict->compact_worst(false, true);
+        _dict->compact_worst(false, true, compaction_strategy);
         return true;
     }
     return false;
diff --git a/searchlib/src/vespa/searchlib/attribute/i_enum_store.h b/searchlib/src/vespa/searchlib/attribute/i_enum_store.h
index 8b122286211..558cc275f38 100644
--- a/searchlib/src/vespa/searchlib/attribute/i_enum_store.h
+++ b/searchlib/src/vespa/searchlib/attribute/i_enum_store.h
@@ -10,6 +10,7 @@
 
 namespace vespalib::datastore {
 
+class CompactionSpec;
 class CompactionStrategy;
 class DataStoreBase;
 
@@ -30,6 +31,7 @@ public:
     using Index = enumstore::Index;
     using InternalIndex = enumstore::InternalIndex;
     using IndexVector = enumstore::IndexVector;
+    using CompactionSpec = vespalib::datastore::CompactionSpec;
     using CompactionStrategy = vespalib::datastore::CompactionStrategy;
     using EnumHandle = enumstore::EnumHandle;
     using EnumVector = enumstore::EnumVector;
@@ -53,7 +55,7 @@ public:
     virtual vespalib::MemoryUsage get_dictionary_memory_usage() const = 0;
     virtual vespalib::MemoryUsage update_stat() = 0;
     virtual std::unique_ptr<EnumIndexRemapper> consider_compact_values(const CompactionStrategy& compaction_strategy) = 0;
-    virtual std::unique_ptr<EnumIndexRemapper> compact_worst_values(bool compact_memory, bool compact_address_space) = 0;
+    virtual std::unique_ptr<EnumIndexRemapper> compact_worst_values(CompactionSpec compaction_spec, const CompactionStrategy& compaction_strategy) = 0;
     virtual bool consider_compact_dictionary(const CompactionStrategy& compaction_strategy) = 0;
     virtual uint64_t get_compaction_count() const = 0;
     // Should only be used by unit tests.
diff --git a/searchlib/src/vespa/searchlib/attribute/multi_value_mapping.h b/searchlib/src/vespa/searchlib/attribute/multi_value_mapping.h
index 9720e88543d..81abaa05a45 100644
--- a/searchlib/src/vespa/searchlib/attribute/multi_value_mapping.h
+++ b/searchlib/src/vespa/searchlib/attribute/multi_value_mapping.h
@@ -44,7 +44,7 @@ public:
 
     void doneLoadFromMultiValue() { _store.setInitializing(false); }
 
-    void compactWorst(bool compactMemory, bool compactAddressSpace) override;
+    void compactWorst(CompactionSpec compactionSpec, const CompactionStrategy& compaction_strategy) override;
 
     vespalib::AddressSpace getAddressSpaceUsage() const override;
     vespalib::MemoryUsage getArrayStoreMemoryUsage() const override;
diff --git a/searchlib/src/vespa/searchlib/attribute/multi_value_mapping.hpp b/searchlib/src/vespa/searchlib/attribute/multi_value_mapping.hpp
index 25065a200e9..fb81a60cb13 100644
--- a/searchlib/src/vespa/searchlib/attribute/multi_value_mapping.hpp
+++ b/searchlib/src/vespa/searchlib/attribute/multi_value_mapping.hpp
@@ -53,9 +53,9 @@ MultiValueMapping<EntryT,RefT>::replace(uint32_t docId, ConstArrayRef values)
 
 template <typename EntryT, typename RefT>
 void
-MultiValueMapping<EntryT,RefT>::compactWorst(bool compactMemory, bool compactAddressSpace)
+MultiValueMapping<EntryT,RefT>::compactWorst(CompactionSpec compaction_spec, const CompactionStrategy& compaction_strategy)
 {
-    vespalib::datastore::ICompactionContext::UP compactionContext(_store.compactWorst(compactMemory, compactAddressSpace));
+    vespalib::datastore::ICompactionContext::UP compactionContext(_store.compactWorst(compaction_spec, compaction_strategy));
     if (compactionContext) {
         compactionContext->compact(vespalib::ArrayRef<EntryRef>(&_indices[0], _indices.size()));
     }
diff --git a/searchlib/src/vespa/searchlib/attribute/multi_value_mapping_base.cpp b/searchlib/src/vespa/searchlib/attribute/multi_value_mapping_base.cpp
index 5e9c5758865..b44b2236f8f 100644
--- a/searchlib/src/vespa/searchlib/attribute/multi_value_mapping_base.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/multi_value_mapping_base.cpp
@@ -1,6 +1,7 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include "multi_value_mapping_base.h"
+#include <vespa/vespalib/datastore/compaction_spec.h>
 #include <vespa/vespalib/datastore/compaction_strategy.h>
 #include <cassert>
 
@@ -86,7 +87,8 @@ MultiValueMappingBase::considerCompact(const CompactionStrategy &compactionStrat
     bool compactMemory = compactionStrategy.should_compact_memory(usedBytes, deadBytes);
     bool compactAddressSpace = compactionStrategy.should_compact_address_space(usedArrays, deadArrays);
     if (compactMemory || compactAddressSpace) {
-        compactWorst(compactMemory, compactAddressSpace);
+        CompactionSpec compaction_spec(compactMemory, compactAddressSpace);
+        compactWorst(compaction_spec, compactionStrategy);
         return true;
     }
     return false;
diff --git a/searchlib/src/vespa/searchlib/attribute/multi_value_mapping_base.h b/searchlib/src/vespa/searchlib/attribute/multi_value_mapping_base.h
index 64c602e3c29..0034878fea6 100644
--- a/searchlib/src/vespa/searchlib/attribute/multi_value_mapping_base.h
+++ b/searchlib/src/vespa/searchlib/attribute/multi_value_mapping_base.h
@@ -7,7 +7,10 @@
 #include <vespa/vespalib/util/rcuvector.h>
 #include <functional>
 
-namespace vespalib::datastore { class CompactionStrategy; }
+namespace vespalib::datastore {
+class CompactionSpec;
+class CompactionStrategy;
+}
 
 namespace search::attribute {
 
@@ -17,6 +20,7 @@ namespace search::attribute {
 class MultiValueMappingBase
 {
 public:
+    using CompactionSpec = vespalib::datastore::CompactionSpec;
     using CompactionStrategy = vespalib::datastore::CompactionStrategy;
     using EntryRef = vespalib::datastore::EntryRef;
     using RefVector = vespalib::RcuVectorBase<EntryRef>;
@@ -52,7 +56,7 @@ public:
 
     uint32_t getNumKeys() const { return _indices.size(); }
     uint32_t getCapacityKeys() const { return _indices.capacity(); }
-    virtual void compactWorst(bool compatMemory, bool compactAddressSpace) = 0;
+    virtual void compactWorst(CompactionSpec compaction_spec, const CompactionStrategy& compaction_strategy) = 0;
     bool considerCompact(const CompactionStrategy &compactionStrategy);
 };
 
diff --git a/searchlib/src/vespa/searchlib/attribute/postingstore.cpp b/searchlib/src/vespa/searchlib/attribute/postingstore.cpp
index 8ed8a0cfbee..8c4b8a66a7d 100644
--- a/searchlib/src/vespa/searchlib/attribute/postingstore.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/postingstore.cpp
@@ -7,6 +7,7 @@
 #include <vespa/vespalib/btree/btreeiterator.hpp>
 #include <vespa/vespalib/btree/btreerootbase.cpp>
 #include <vespa/vespalib/datastore/datastore.hpp>
+#include <vespa/vespalib/datastore/compaction_spec.h>
 #include <vespa/vespalib/datastore/entry_ref_filter.h>
 #include <vespa/vespalib/datastore/buffer_type.hpp>
 
@@ -724,9 +725,9 @@ PostingStore<DataT>::move(std::vector<EntryRef>& refs)
 
 template <typename DataT>
 void
-PostingStore<DataT>::compact_worst_btree_nodes()
+PostingStore<DataT>::compact_worst_btree_nodes(const CompactionStrategy& compaction_strategy)
 {
-    auto to_hold = this->start_compact_worst_btree_nodes();
+    auto to_hold = this->start_compact_worst_btree_nodes(compaction_strategy);
     EntryRefFilter filter(RefType::numBuffers(), RefType::offset_bits);
     // Only look at buffers containing bitvectors and btree roots
     filter.add_buffers(this->_treeType.get_active_buffers());
@@ -738,9 +739,10 @@ PostingStore<DataT>::compact_worst_btree_nodes()
 
 template <typename DataT>
 void
-PostingStore<DataT>::compact_worst_buffers()
+PostingStore<DataT>::compact_worst_buffers(CompactionSpec compaction_spec, const CompactionStrategy& compaction_strategy)
 {
-    auto to_hold = this->start_compact_worst_buffers();
+
+    auto to_hold = this->start_compact_worst_buffers(compaction_spec, compaction_strategy);
     bool compact_btree_roots = false;
     EntryRefFilter filter(RefType::numBuffers(), RefType::offset_bits);
     filter.add_buffers(to_hold);
@@ -769,7 +771,7 @@ PostingStore<DataT>::consider_compact_worst_btree_nodes(const CompactionStrategy
         return false;
     }
     if (compaction_strategy.should_compact_memory(_cached_allocator_memory_usage.usedBytes(), _cached_allocator_memory_usage.deadBytes())) {
-        compact_worst_btree_nodes();
+        compact_worst_btree_nodes(compaction_strategy);
         return true;
     }
     return false;
@@ -783,7 +785,8 @@ PostingStore<DataT>::consider_compact_worst_buffers(const CompactionStrategy& co
         return false;
     }
     if (compaction_strategy.should_compact_memory(_cached_store_memory_usage.usedBytes(), _cached_store_memory_usage.deadBytes())) {
-        compact_worst_buffers();
+        CompactionSpec compaction_spec(true, false);
+        compact_worst_buffers(compaction_spec, compaction_strategy);
         return true;
     }
     return false;
diff --git a/searchlib/src/vespa/searchlib/attribute/postingstore.h b/searchlib/src/vespa/searchlib/attribute/postingstore.h
index e5506babb7f..58097194f50 100644
--- a/searchlib/src/vespa/searchlib/attribute/postingstore.h
+++ b/searchlib/src/vespa/searchlib/attribute/postingstore.h
@@ -77,6 +77,7 @@ public:
     typedef typename Parent::AggregatedType AggregatedType;
     typedef typename Parent::BTreeTypeRefPair BTreeTypeRefPair;
     typedef typename Parent::Builder Builder;
+    using CompactionSpec = vespalib::datastore::CompactionSpec;
     using CompactionStrategy = vespalib::datastore::CompactionStrategy;
     typedef vespalib::datastore::EntryRef EntryRef;
     typedef std::less<uint32_t> CompareT;
@@ -191,8 +192,8 @@ public:
     void move_btree_nodes(const std::vector<EntryRef> &refs);
     void move(std::vector<EntryRef>& refs);
 
-    void compact_worst_btree_nodes();
-    void compact_worst_buffers();
+    void compact_worst_btree_nodes(const CompactionStrategy& compaction_strategy);
+    void compact_worst_buffers(CompactionSpec compaction_spec, const CompactionStrategy& compaction_strategy);
     bool consider_compact_worst_btree_nodes(const CompactionStrategy& compaction_strategy);
     bool consider_compact_worst_buffers(const CompactionStrategy& compaction_strategy);
 private:
diff --git a/searchlib/src/vespa/searchlib/attribute/reference_attribute.cpp b/searchlib/src/vespa/searchlib/attribute/reference_attribute.cpp
index eb822313d61..0a84da7c769 100644
--- a/searchlib/src/vespa/searchlib/attribute/reference_attribute.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/reference_attribute.cpp
@@ -24,6 +24,7 @@ namespace search::attribute {
 using document::DocumentId;
 using document::GlobalId;
 using document::IdParseException;
+using vespalib::datastore::CompactionSpec;
 
 namespace {
 
@@ -295,16 +296,17 @@ ReferenceAttribute::consider_compact_values(const CompactionStrategy &compaction
     size_t dead_bytes = _cached_unique_store_values_memory_usage.deadBytes();
     bool compact_memory = compactionStrategy.should_compact_memory(used_bytes, dead_bytes);
     if (compact_memory) {
-        compact_worst_values();
+        compact_worst_values(compactionStrategy);
         return true;
     }
     return false;
 }
 
 void
-ReferenceAttribute::compact_worst_values()
+ReferenceAttribute::compact_worst_values(const CompactionStrategy& compaction_strategy)
 {
-    auto remapper(_store.compact_worst(true, true));
+    CompactionSpec compaction_spec(true, true);
+    auto remapper(_store.compact_worst(compaction_spec, compaction_strategy));
     if (remapper) {
         remapper->remap(vespalib::ArrayRef<EntryRef>(&_indices[0], _indices.size()));
         remapper->done();
@@ -321,7 +323,7 @@ ReferenceAttribute::consider_compact_dictionary(const CompactionStrategy &compac
     if (compaction_strategy.should_compact_memory(_cached_unique_store_dictionary_memory_usage.usedBytes(),
                                                   _cached_unique_store_dictionary_memory_usage.deadBytes()))
     {
-        dictionary.compact_worst(true, true);
+        dictionary.compact_worst(true, true, compaction_strategy);
         return true;
     }
     return false;
diff --git a/searchlib/src/vespa/searchlib/attribute/reference_attribute.h b/searchlib/src/vespa/searchlib/attribute/reference_attribute.h
index 23e75f973e5..237a0f1ddd7 100644
--- a/searchlib/src/vespa/searchlib/attribute/reference_attribute.h
+++ b/searchlib/src/vespa/searchlib/attribute/reference_attribute.h
@@ -58,7 +58,7 @@ private:
     uint64_t getUniqueValueCount() const override;
 
     bool consider_compact_values(const CompactionStrategy &compactionStrategy);
-    void compact_worst_values();
+    void compact_worst_values(const CompactionStrategy& compaction_strategy);
     bool consider_compact_dictionary(const CompactionStrategy& compaction_strategy);
     IndicesCopyVector getIndicesCopy(uint32_t size) const;
     void removeReverseMapping(EntryRef oldRef, uint32_t lid);
diff --git a/searchlib/src/vespa/searchlib/tensor/hnsw_index.cpp b/searchlib/src/vespa/searchlib/tensor/hnsw_index.cpp
index 5e3a3856a4f..2c01472a067 100644
--- a/searchlib/src/vespa/searchlib/tensor/hnsw_index.cpp
+++ b/searchlib/src/vespa/searchlib/tensor/hnsw_index.cpp
@@ -532,18 +532,18 @@ HnswIndex::trim_hold_lists(generation_t first_used_gen)
 }
 
 void
-HnswIndex::compact_level_arrays(bool compact_memory, bool compact_address_space)
+HnswIndex::compact_level_arrays(CompactionSpec compaction_spec, const CompactionStrategy& compaction_strategy)
 {
-    auto context = _graph.nodes.compactWorst(compact_memory, compact_address_space);
+    auto context = _graph.nodes.compactWorst(compaction_spec, compaction_strategy);
     uint32_t doc_id_limit = _graph.node_refs.size();
     vespalib::ArrayRef<AtomicEntryRef> refs(&_graph.node_refs[0], doc_id_limit);
     context->compact(refs);
 }
 
 void
-HnswIndex::compact_link_arrays(bool compact_memory, bool compact_address_space)
+HnswIndex::compact_link_arrays(CompactionSpec compaction_spec, const CompactionStrategy& compaction_strategy)
 {
-    auto context = _graph.links.compactWorst(compact_memory, compact_address_space);
+    auto context = _graph.links.compactWorst(compaction_spec, compaction_strategy);
     uint32_t doc_id_limit = _graph.node_refs.size();
     for (uint32_t doc_id = 1; doc_id < doc_id_limit; ++doc_id) {
         EntryRef level_ref = _graph.node_refs[doc_id].load_relaxed();
@@ -557,7 +557,7 @@ HnswIndex::compact_link_arrays(bool compact_memory, bool compact_address_space)
 namespace {
 
 bool
-consider_compact_arrays(const CompactionStrategy& compaction_strategy, vespalib::MemoryUsage& memory_usage, vespalib::AddressSpace& address_space_usage, std::function<void(bool,bool)> compact_arrays)
+consider_compact_arrays(const CompactionStrategy& compaction_strategy, vespalib::MemoryUsage& memory_usage, vespalib::AddressSpace& address_space_usage, std::function<void(vespalib::datastore::CompactionSpec, const CompactionStrategy&)> compact_arrays)
 {
     size_t used_bytes = memory_usage.usedBytes();
     size_t dead_bytes = memory_usage.deadBytes();
@@ -566,7 +566,8 @@ consider_compact_arrays(const CompactionStrategy& compaction_strategy, vespalib:
     size_t dead_address_space = address_space_usage.dead();
     bool compact_address_space = compaction_strategy.should_compact_address_space(used_address_space, dead_address_space);
     if (compact_memory || compact_address_space) {
-        compact_arrays(compact_memory, compact_address_space);
+        vespalib::datastore::CompactionSpec compaction_spec(compact_memory, compact_address_space);
+        compact_arrays(compaction_spec, compaction_strategy);
         return true;
     }
     return false;
@@ -578,16 +579,16 @@ bool
 HnswIndex::consider_compact_level_arrays(const CompactionStrategy& compaction_strategy)
 {
     return consider_compact_arrays(compaction_strategy, _cached_level_arrays_memory_usage, _cached_level_arrays_address_space_usage,
-                                   [this](bool compact_memory, bool compact_address_space)
-                                   { compact_level_arrays(compact_memory, compact_address_space); });
+                                   [this](CompactionSpec compaction_spec, const CompactionStrategy& compaction_strategy_fwd)
+                                   { compact_level_arrays(compaction_spec, compaction_strategy_fwd); });
 }
 
 bool
 HnswIndex::consider_compact_link_arrays(const CompactionStrategy& compaction_strategy)
 {
     return consider_compact_arrays(compaction_strategy, _cached_link_arrays_memory_usage, _cached_link_arrays_address_space_usage,
-                                   [this](bool compact_memory, bool compact_address_space)
-                                   { compact_link_arrays(compact_memory, compact_address_space); });
+                                   [this](CompactionSpec compaction_spec, const CompactionStrategy& compaction_strategy_fwd)
+                                   { compact_link_arrays(compaction_spec, compaction_strategy_fwd); });
 }
 
 bool
diff --git a/searchlib/src/vespa/searchlib/tensor/hnsw_index.h b/searchlib/src/vespa/searchlib/tensor/hnsw_index.h
index d8f3c4c97fa..5b5f9382517 100644
--- a/searchlib/src/vespa/searchlib/tensor/hnsw_index.h
+++ b/searchlib/src/vespa/searchlib/tensor/hnsw_index.h
@@ -171,8 +171,8 @@ public:
     void remove_document(uint32_t docid) override;
     void transfer_hold_lists(generation_t current_gen) override;
     void trim_hold_lists(generation_t first_used_gen) override;
-    void compact_level_arrays(bool compact_memory, bool compact_addreess_space);
-    void compact_link_arrays(bool compact_memory, bool compact_address_space);
+    void compact_level_arrays(CompactionSpec compaction_spec, const CompactionStrategy& compaction_strategy);
+    void compact_link_arrays(CompactionSpec compaction_spec, const CompactionStrategy& compaction_strategy);
     bool consider_compact_level_arrays(const CompactionStrategy& compaction_strategy);
     bool consider_compact_link_arrays(const CompactionStrategy& compaction_strategy);
     bool consider_compact(const CompactionStrategy& compaction_strategy) override;
diff --git a/searchlib/src/vespa/searchlib/tensor/nearest_neighbor_index.h b/searchlib/src/vespa/searchlib/tensor/nearest_neighbor_index.h
index ad83ab2b8ef..c1fa4da05d1 100644
--- a/searchlib/src/vespa/searchlib/tensor/nearest_neighbor_index.h
+++ b/searchlib/src/vespa/searchlib/tensor/nearest_neighbor_index.h
@@ -12,7 +12,10 @@
 
 class FastOS_FileInterface;
 
-namespace vespalib::datastore { class CompactionStrategy; }
+namespace vespalib::datastore {
+class CompactionSpec;
+class CompactionStrategy;
+}
 namespace vespalib::slime { struct Inserter; }
 
 namespace search::fileutil { class LoadedBuffer; }
@@ -32,6 +35,7 @@ class NearestNeighborIndexSaver;
  */
 class NearestNeighborIndex {
 public:
+    using CompactionSpec = vespalib::datastore::CompactionSpec;
     using CompactionStrategy = vespalib::datastore::CompactionStrategy;
     using generation_t = vespalib::GenerationHandler::generation_t;
     struct Neighbor {