Add getStats and setTaskLimit to interface to make it easy to swap implementation.

Also make do with ISequenceHandlerInterface.

2 files changed, 37 insertions, 37 deletions

diff --git a/searchlib/src/tests/common/sequencedtaskexecutor/sequencedtaskexecutor_benchmark.cpp b/searchlib/src/tests/common/sequencedtaskexecutor/sequencedtaskexecutor_benchmark.cpp
index a51becfbf13..b2b15ded274 100644
--- a/searchlib/src/tests/common/sequencedtaskexecutor/sequencedtaskexecutor_benchmark.cpp
+++ b/searchlib/src/tests/common/sequencedtaskexecutor/sequencedtaskexecutor_benchmark.cpp
@@ -16,9 +16,9 @@ int main(int argc, char *argv[]) {
     if (argc > 2)
         numThreads = atoi(argv[2]);
 
-    SequencedTaskExecutor executor(numThreads);
+    auto executor = SequencedTaskExecutor::create(numThreads);
     for (unsigned long tid(0); tid < numTasks; tid++) {
-        executor.executeTask(ExecutorId(tid%numThreads), vespalib::makeLambdaTask([&counter] { counter++; }));
+        executor->executeTask(ExecutorId(tid%numThreads), vespalib::makeLambdaTask([&counter] { counter++; }));
     }
     return 0;
 }
diff --git a/searchlib/src/tests/common/sequencedtaskexecutor/sequencedtaskexecutor_test.cpp b/searchlib/src/tests/common/sequencedtaskexecutor/sequencedtaskexecutor_test.cpp
index fcc7fd7300d..c311a59a56c 100644
--- a/searchlib/src/tests/common/sequencedtaskexecutor/sequencedtaskexecutor_test.cpp
+++ b/searchlib/src/tests/common/sequencedtaskexecutor/sequencedtaskexecutor_test.cpp
@@ -17,9 +17,9 @@ namespace search::common {
 class Fixture
 {
 public:
-    SequencedTaskExecutor _threads;
+    std::unique_ptr<ISequencedTaskExecutor> _threads;
 
-    Fixture() : _threads(2) { }
+    Fixture() : _threads(SequencedTaskExecutor::create(2)) { }
 };
 
 
@@ -67,11 +67,11 @@ public:
 TEST_F("testExecute", Fixture) {
     std::shared_ptr<TestObj> tv(std::make_shared<TestObj>());
     EXPECT_EQUAL(0, tv->_val);
-    f._threads.execute(1, [=]() { tv->modify(0, 42); });
+    f._threads->execute(1, [=]() { tv->modify(0, 42); });
     tv->wait(1);
     EXPECT_EQUAL(0,  tv->_fail);
     EXPECT_EQUAL(42, tv->_val);
-    f._threads.sync();
+    f._threads->sync();
     EXPECT_EQUAL(0,  tv->_fail);
     EXPECT_EQUAL(42, tv->_val);
 }
@@ -81,12 +81,12 @@ TEST_F("require that task with same component id are serialized", Fixture)
 {
     std::shared_ptr<TestObj> tv(std::make_shared<TestObj>());
     EXPECT_EQUAL(0, tv->_val);
-    f._threads.execute(0, [=]() { usleep(2000); tv->modify(0, 14); });
-    f._threads.execute(0, [=]() { tv->modify(14, 42); });
+    f._threads->execute(0, [=]() { usleep(2000); tv->modify(0, 14); });
+    f._threads->execute(0, [=]() { tv->modify(14, 42); });
     tv->wait(2);
     EXPECT_EQUAL(0,  tv->_fail);
     EXPECT_EQUAL(42, tv->_val);
-    f._threads.sync();
+    f._threads->sync();
     EXPECT_EQUAL(0,  tv->_fail);
     EXPECT_EQUAL(42, tv->_val);
 }
@@ -97,15 +97,15 @@ TEST_F("require that task with different component ids are not serialized", Fixt
     for (tryCnt = 0; tryCnt < 100; ++tryCnt) {
         std::shared_ptr<TestObj> tv(std::make_shared<TestObj>());
         EXPECT_EQUAL(0, tv->_val);
-        f._threads.execute(0, [=]() { usleep(2000); tv->modify(0, 14); });
-        f._threads.execute(2, [=]() { tv->modify(14, 42); });
+        f._threads->execute(0, [=]() { usleep(2000); tv->modify(0, 14); });
+        f._threads->execute(2, [=]() { tv->modify(14, 42); });
         tv->wait(2);
         if (tv->_fail != 1) {
              continue;
         }
         EXPECT_EQUAL(1,  tv->_fail);
         EXPECT_EQUAL(14, tv->_val);
-        f._threads.sync();
+        f._threads->sync();
         EXPECT_EQUAL(1,  tv->_fail);
         EXPECT_EQUAL(14, tv->_val);
         break;
@@ -119,12 +119,12 @@ TEST_F("require that task with same string component id are serialized", Fixture
     std::shared_ptr<TestObj> tv(std::make_shared<TestObj>());
     EXPECT_EQUAL(0, tv->_val);
     auto test2 = [=]() { tv->modify(14, 42); };
-    f._threads.execute(f._threads.getExecutorId("0"), [=]() { usleep(2000); tv->modify(0, 14); });
-    f._threads.execute(f._threads.getExecutorId("0"), test2);
+    f._threads->execute(f._threads->getExecutorId("0"), [=]() { usleep(2000); tv->modify(0, 14); });
+    f._threads->execute(f._threads->getExecutorId("0"), test2);
     tv->wait(2);
     EXPECT_EQUAL(0,  tv->_fail);
     EXPECT_EQUAL(42, tv->_val);
-    f._threads.sync();
+    f._threads->sync();
     EXPECT_EQUAL(0,  tv->_fail);
     EXPECT_EQUAL(42, tv->_val);
 }
@@ -137,15 +137,15 @@ int detectSerializeFailure(Fixture &f, vespalib::stringref altComponentId, int t
     for (tryCnt = 0; tryCnt < tryLimit; ++tryCnt) {
         std::shared_ptr<TestObj> tv(std::make_shared<TestObj>());
         EXPECT_EQUAL(0, tv->_val);
-        f._threads.execute(f._threads.getExecutorId("0"), [=]() { usleep(2000); tv->modify(0, 14); });
-        f._threads.execute(f._threads.getExecutorId(altComponentId), [=]() { tv->modify(14, 42); });
+        f._threads->execute(f._threads->getExecutorId("0"), [=]() { usleep(2000); tv->modify(0, 14); });
+        f._threads->execute(f._threads->getExecutorId(altComponentId), [=]() { tv->modify(14, 42); });
         tv->wait(2);
         if (tv->_fail != 1) {
              continue;
         }
         EXPECT_EQUAL(1,  tv->_fail);
         EXPECT_EQUAL(14, tv->_val);
-        f._threads.sync();
+        f._threads->sync();
         EXPECT_EQUAL(1,  tv->_fail);
         EXPECT_EQUAL(14, tv->_val);
         break;
@@ -157,10 +157,10 @@ vespalib::string makeAltComponentId(Fixture &f)
 {
     int tryCnt = 0;
     char altComponentId[20];
-    ISequencedTaskExecutor::ExecutorId executorId0 = f._threads.getExecutorId("0");
+    ISequencedTaskExecutor::ExecutorId executorId0 = f._threads->getExecutorId("0");
     for (tryCnt = 1; tryCnt < 100; ++tryCnt) {
         sprintf(altComponentId, "%d", tryCnt);
-        if (f._threads.getExecutorId(altComponentId) == executorId0) {
+        if (f._threads->getExecutorId(altComponentId) == executorId0) {
             break;
         }
     }
@@ -193,9 +193,9 @@ TEST_F("require that execute works with const lambda", Fixture)
     std::vector<int> res;
     const auto lambda = [i, &res]() mutable
                         { res.push_back(i--); res.push_back(i--); };
-    f._threads.execute(0, lambda);
-    f._threads.execute(0, lambda);
-    f._threads.sync();
+    f._threads->execute(0, lambda);
+    f._threads->execute(0, lambda);
+    f._threads->sync();
     std::vector<int> exp({5, 4, 5, 4});
     EXPECT_EQUAL(exp, res);
     EXPECT_EQUAL(5, i);
@@ -208,9 +208,9 @@ TEST_F("require that execute works with reference to lambda", Fixture)
     auto lambda = [i, &res]() mutable
                   { res.push_back(i--); res.push_back(i--); };
     auto &lambdaref = lambda;
-    f._threads.execute(0, lambdaref);
-    f._threads.execute(0, lambdaref);
-    f._threads.sync();
+    f._threads->execute(0, lambdaref);
+    f._threads->execute(0, lambdaref);
+    f._threads->sync();
     std::vector<int> exp({5, 4, 5, 4});
     EXPECT_EQUAL(exp, res);
     EXPECT_EQUAL(5, i);
@@ -222,28 +222,28 @@ TEST_F("require that executeLambda works", Fixture)
     std::vector<int> res;
     const auto lambda = [i, &res]() mutable
                         { res.push_back(i--); res.push_back(i--); };
-    f._threads.executeLambda(ISequencedTaskExecutor::ExecutorId(0), lambda);
-    f._threads.sync();
+    f._threads->executeLambda(ISequencedTaskExecutor::ExecutorId(0), lambda);
+    f._threads->sync();
     std::vector<int> exp({5, 4});
     EXPECT_EQUAL(exp, res);
     EXPECT_EQUAL(5, i);
 }
 
 TEST("require that you get correct number of executors") {
-    SequencedTaskExecutor seven(7);
-    EXPECT_EQUAL(7u, seven.getNumExecutors());
+    auto seven = SequencedTaskExecutor::create(7);
+    EXPECT_EQUAL(7u, seven->getNumExecutors());
 }
 
 TEST("require that you distribute well") {
-    SequencedTaskExecutor seven(7);
-    EXPECT_EQUAL(7u, seven.getNumExecutors());
-    EXPECT_EQUAL(97u, seven.getComponentHashSize());
-    EXPECT_EQUAL(0u, seven.getComponentEffectiveHashSize());
+    auto seven = SequencedTaskExecutor::create(7);
+    EXPECT_EQUAL(7u, seven->getNumExecutors());
+    EXPECT_EQUAL(97u, seven->getComponentHashSize());
+    EXPECT_EQUAL(0u, seven->getComponentEffectiveHashSize());
     for (uint32_t id=0; id < 1000; id++) {
-        EXPECT_EQUAL((id%97)%7, seven.getExecutorId(id).getId());
+        EXPECT_EQUAL((id%97)%7, seven->getExecutorId(id).getId());
     }
-    EXPECT_EQUAL(97u, seven.getComponentHashSize());
-    EXPECT_EQUAL(97u, seven.getComponentEffectiveHashSize());
+    EXPECT_EQUAL(97u, seven->getComponentHashSize());
+    EXPECT_EQUAL(97u, seven->getComponentEffectiveHashSize());
 }
 
 }