- Let LidReuseDelayer be owned by FeedView and configured only at construction time.

- No need for ILidReuseDelayer interface.
- Update test to reflect that no extra task is dispatched in master thread for reconfiguraion of lid reuse delayer.

1 files changed, 28 insertions, 29 deletions

diff --git a/searchcore/src/tests/proton/documentmetastore/lidreusedelayer/lidreusedelayer_test.cpp b/searchcore/src/tests/proton/documentmetastore/lidreusedelayer/lidreusedelayer_test.cpp
index 25668f56753..f86829c5b13 100644
--- a/searchcore/src/tests/proton/documentmetastore/lidreusedelayer/lidreusedelayer_test.cpp
+++ b/searchcore/src/tests/proton/documentmetastore/lidreusedelayer/lidreusedelayer_test.cpp
@@ -108,7 +108,7 @@ public:
     bool
     assertWork(uint32_t expRemoveCompleteCount,
                uint32_t expRemoveBatchCompleteCount,
-               uint32_t expRemoveCompleteLids)
+               uint32_t expRemoveCompleteLids) const
     {
         if (!EXPECT_EQUAL(expRemoveCompleteCount, _removeCompleteCount)) {
             return false;
@@ -127,18 +127,20 @@ public:
 class Fixture
 {
 public:
+    using LidReuseDelayer = documentmetastore::LidReuseDelayer;
+    using LidReuseDelayerConfig = documentmetastore::LidReuseDelayerConfig;
     vespalib::ThreadStackExecutor _sharedExecutor;
     ExecutorThreadingService _writeServiceReal;
     test::ThreadingServiceObserver _writeService;
     MyMetaStore _store;
-    documentmetastore::LidReuseDelayer _lidReuseDelayer;
+    std::unique_ptr<LidReuseDelayer> _lidReuseDelayer;
 
     Fixture()
         : _sharedExecutor(1, 0x10000),
           _writeServiceReal(_sharedExecutor),
           _writeService(_writeServiceReal),
           _store(),
-          _lidReuseDelayer(_writeService, _store)
+          _lidReuseDelayer(std::make_unique<LidReuseDelayer>(_writeService, _store, LidReuseDelayerConfig()))
     {
     }
 
@@ -177,7 +179,7 @@ public:
     delayReuse(uint32_t lid)
     {
         bool res = false;
-        runInMaster([&] () { res = _lidReuseDelayer.delayReuse(lid); } );
+        runInMaster([&] () { res = _lidReuseDelayer->delayReuse(lid); } );
         return res;
     }
 
@@ -185,22 +187,21 @@ public:
     delayReuse(const std::vector<uint32_t> &lids)
     {
         bool res = false;
-        runInMaster([&] () { res = _lidReuseDelayer.delayReuse(lids); });
+        runInMaster([&] () { res = _lidReuseDelayer->delayReuse(lids); });
         return res;
     }
 
-    void setImmediateCommit(bool immediateCommit) {
-        runInMaster([&] () { _lidReuseDelayer.
-                                    setImmediateCommit(immediateCommit); } );
-    }
-
-    void setHasIndexedOrAttributeFields(bool hasIndexedOrAttributeFields) {
-        runInMaster([&] () { _lidReuseDelayer.
-                                    setHasIndexedOrAttributeFields(hasIndexedOrAttributeFields); } );
+    void
+    configureLidReuseDelayer(bool immediateCommit, bool hasIndexedOrAttributeFields) {
+        runInMaster([&] () {
+            _lidReuseDelayer = std::make_unique<LidReuseDelayer>(_writeService, _store,
+                                                                 LidReuseDelayerConfig(immediateCommit ? vespalib::duration::zero() : 1ms,
+                                                                                       hasIndexedOrAttributeFields));
+        } );
     }
 
     void commit() {
-        runInMaster([&] () { cycleLids(_lidReuseDelayer.getReuseLids()); });
+        runInMaster([&] () { cycleLids(_lidReuseDelayer->getReuseLids()); });
     }
 
     void
@@ -225,7 +226,7 @@ public:
 
 TEST_F("require that nothing happens before free list is active", Fixture)
 {
-    f.setHasIndexedOrAttributeFields(true);
+    f.configureLidReuseDelayer(true, true);
     EXPECT_FALSE(f.delayReuse(4));
     EXPECT_FALSE(f.delayReuse({ 5, 6}));
     EXPECT_TRUE(f._store.assertWork(0, 0, 0));
@@ -236,7 +237,7 @@ TEST_F("require that nothing happens before free list is active", Fixture)
 TEST_F("require that single lid is delayed", Fixture)
 {
     f._store._freeListActive = true;
-    f.setHasIndexedOrAttributeFields(true);
+    f.configureLidReuseDelayer(true, true);
     EXPECT_TRUE(f.delayReuse(4));
     f.scheduleDelayReuseLid(4);
     EXPECT_TRUE(f._store.assertWork(1, 0, 1));
@@ -247,7 +248,7 @@ TEST_F("require that single lid is delayed", Fixture)
 TEST_F("require that lid vector is delayed", Fixture)
 {
     f._store._freeListActive = true;
-    f.setHasIndexedOrAttributeFields(true);
+    f.configureLidReuseDelayer(true, true);
     EXPECT_TRUE(f.delayReuse({ 5, 6, 7}));
     f.scheduleDelayReuseLids({ 5, 6, 7});
     EXPECT_TRUE(f._store.assertWork(0, 1, 3));
@@ -258,45 +259,43 @@ TEST_F("require that lid vector is delayed", Fixture)
 TEST_F("require that reuse can be batched", Fixture)
 {
     f._store._freeListActive = true;
-    f.setHasIndexedOrAttributeFields(true);
-    f.setImmediateCommit(false);
+    f.configureLidReuseDelayer(false, true);
     EXPECT_FALSE(f.delayReuse(4));
     EXPECT_FALSE(f.delayReuse({ 5, 6, 7}));
     EXPECT_TRUE(f._store.assertWork(0, 0, 0));
-    EXPECT_TRUE(assertThreadObserver(4, 0, 0, f._writeService));
+    EXPECT_TRUE(assertThreadObserver(3, 0, 0, f._writeService));
     f.commit();
     EXPECT_TRUE(f._store.assertWork(0, 1, 4));
-    EXPECT_TRUE(assertThreadObserver(6, 1, 0, f._writeService));
+    EXPECT_TRUE(assertThreadObserver(5, 1, 0, f._writeService));
     EXPECT_FALSE(f.delayReuse(8));
     EXPECT_FALSE(f.delayReuse({ 9, 10}));
     EXPECT_TRUE(f._store.assertWork(0, 1, 4));
-    EXPECT_TRUE(assertThreadObserver(8, 1, 0, f._writeService));
+    EXPECT_TRUE(assertThreadObserver(7, 1, 0, f._writeService));
 }
 
 
 TEST_F("require that single element array is optimized", Fixture)
 {
     f._store._freeListActive = true;
-    f.setHasIndexedOrAttributeFields(true);
-    f.setImmediateCommit(false);
+    f.configureLidReuseDelayer(false, true);
     EXPECT_FALSE(f.delayReuse({ 4}));
     EXPECT_TRUE(f._store.assertWork(0, 0, 0));
-    EXPECT_TRUE(assertThreadObserver(3, 0, 0, f._writeService));
+    EXPECT_TRUE(assertThreadObserver(2, 0, 0, f._writeService));
     f.commit();
-    f.setImmediateCommit(true);
+    f.configureLidReuseDelayer(true, true);
     EXPECT_TRUE(f._store.assertWork(1, 0, 1));
-    EXPECT_TRUE(assertThreadObserver(6, 1, 0, f._writeService));
+    EXPECT_TRUE(assertThreadObserver(5, 1, 0, f._writeService));
     EXPECT_TRUE(f.delayReuse({ 8}));
     f.scheduleDelayReuseLids({ 8});
     EXPECT_TRUE(f._store.assertWork(2, 0, 2));
-    EXPECT_TRUE(assertThreadObserver(9, 2, 0, f._writeService));
+    EXPECT_TRUE(assertThreadObserver(8, 2, 0, f._writeService));
 }
 
 
 TEST_F("require that lids are reused faster with no indexed fields", Fixture)
 {
     f._store._freeListActive = true;
-    f.setHasIndexedOrAttributeFields(false);
+    f.configureLidReuseDelayer(true, false);
     EXPECT_FALSE(f.delayReuse(4));
     EXPECT_TRUE(f._store.assertWork(1, 0, 1));
     EXPECT_TRUE(assertThreadObserver(2, 0, 0, f._writeService));