- Use the wakeupservice as main source for frequent regular wakeups.

- Keep a self wakeup of 100ms
- Avoid using default arguments to be able to find callsite.

3 files changed, 35 insertions, 10 deletions

diff --git a/staging_vespalib/src/vespa/vespalib/util/sequencedtaskexecutor.cpp b/staging_vespalib/src/vespa/vespalib/util/sequencedtaskexecutor.cpp
index 7c4711b6802..db27c13463f 100644
--- a/staging_vespalib/src/vespa/vespalib/util/sequencedtaskexecutor.cpp
+++ b/staging_vespalib/src/vespa/vespalib/util/sequencedtaskexecutor.cpp
@@ -40,8 +40,23 @@ find(uint16_t key, const uint16_t values[], size_t numValues) {
 }
 
 std::unique_ptr<ISequencedTaskExecutor>
-SequencedTaskExecutor::create(vespalib::Runnable::init_fun_t func, uint32_t threads, uint32_t taskLimit,
-                              OptimizeFor optimize, uint32_t kindOfWatermark, duration reactionTime)
+SequencedTaskExecutor::create(Runnable::init_fun_t func, uint32_t threads) {
+    return create(func, threads, 1000);
+}
+
+std::unique_ptr<ISequencedTaskExecutor>
+SequencedTaskExecutor::create(Runnable::init_fun_t func, uint32_t threads, uint32_t taskLimit) {
+    return create(func, threads, taskLimit, OptimizeFor::LATENCY);
+}
+
+std::unique_ptr<ISequencedTaskExecutor>
+SequencedTaskExecutor::create(Runnable::init_fun_t func, uint32_t threads, uint32_t taskLimit, OptimizeFor optimize) {
+    return create(func, threads, taskLimit, optimize, 0);
+}
+
+std::unique_ptr<ISequencedTaskExecutor>
+SequencedTaskExecutor::create(Runnable::init_fun_t func, uint32_t threads, uint32_t taskLimit,
+                              OptimizeFor optimize, uint32_t kindOfWatermark)
 {
     if (optimize == OptimizeFor::ADAPTIVE) {
         size_t num_strands = std::min(taskLimit, threads*32);
@@ -52,7 +67,7 @@ SequencedTaskExecutor::create(vespalib::Runnable::init_fun_t func, uint32_t thre
         for (uint32_t id = 0; id < threads; ++id) {
             if (optimize == OptimizeFor::THROUGHPUT) {
                 uint32_t watermark = kindOfWatermark == 0 ? taskLimit / 2 : kindOfWatermark;
-                executors.push_back(std::make_unique<SingleExecutor>(func, taskLimit, watermark, reactionTime));
+                executors.push_back(std::make_unique<SingleExecutor>(func, taskLimit, watermark, 100ms));
             } else {
                 executors.push_back(std::make_unique<BlockingThreadStackExecutor>(1, stackSize, taskLimit, func));
             }
diff --git a/staging_vespalib/src/vespa/vespalib/util/sequencedtaskexecutor.h b/staging_vespalib/src/vespa/vespalib/util/sequencedtaskexecutor.h
index db0723d16c8..f6d86ec51fb 100644
--- a/staging_vespalib/src/vespa/vespalib/util/sequencedtaskexecutor.h
+++ b/staging_vespalib/src/vespa/vespalib/util/sequencedtaskexecutor.h
@@ -30,13 +30,23 @@ public:
     ExecutorStats getStats() override;
     void wakeup() override;
 
-    /*
-     * Note that if you choose Optimize::THROUGHPUT, you must ensure only a single producer, or synchronize on the outside.
-     *
-     */
+#if 0
+    static std::unique_ptr<ISequencedTaskExecutor>
+    create(Runnable::init_fun_t func, uint32_t threads, uint32_t taskLimit = 1000,
+           OptimizeFor optimize = OptimizeFor::LATENCY, uint32_t kindOfWatermark = 0) {
+        return create(func, threads, taskLimit, optimize, kindOfWatermark, 100ms);
+    }
+
+#endif
+    static std::unique_ptr<ISequencedTaskExecutor>
+    create(Runnable::init_fun_t func, uint32_t threads);
+    static std::unique_ptr<ISequencedTaskExecutor>
+    create(Runnable::init_fun_t func, uint32_t threads, uint32_t taskLimit);
+    static std::unique_ptr<ISequencedTaskExecutor>
+    create(Runnable::init_fun_t func, uint32_t threads, uint32_t taskLimit, OptimizeFor optimize);
     static std::unique_ptr<ISequencedTaskExecutor>
-    create(vespalib::Runnable::init_fun_t, uint32_t threads, uint32_t taskLimit = 1000,
-           OptimizeFor optimize = OptimizeFor::LATENCY, uint32_t kindOfWatermark = 0, duration reactionTime = 10ms);
+    create(Runnable::init_fun_t func, uint32_t threads, uint32_t taskLimit,
+           OptimizeFor optimize, uint32_t kindOfWatermark);
     /**
      * For testing only
      */
diff --git a/staging_vespalib/src/vespa/vespalib/util/singleexecutor.cpp b/staging_vespalib/src/vespa/vespalib/util/singleexecutor.cpp
index af95918ccab..b25bc1a6377 100644
--- a/staging_vespalib/src/vespa/vespalib/util/singleexecutor.cpp
+++ b/staging_vespalib/src/vespa/vespalib/util/singleexecutor.cpp
@@ -7,7 +7,7 @@
 namespace vespalib {
 
 SingleExecutor::SingleExecutor(init_fun_t func, uint32_t taskLimit)
-    : SingleExecutor(func, taskLimit, taskLimit/10, 5ms)
+    : SingleExecutor(func, taskLimit, taskLimit/10, 100ms)
 { } 
 
 SingleExecutor::SingleExecutor(init_fun_t func, uint32_t taskLimit, uint32_t watermark, duration reactionTime)