Ignore semiunbound-tasklimit. Use tasklimit instead.

5 files changed, 8 insertions, 32 deletions

diff --git a/searchcore/src/tests/proton/documentdb/threading_service_config/threading_service_config_test.cpp b/searchcore/src/tests/proton/documentdb/threading_service_config/threading_service_config_test.cpp
index a3c031cd5c4..e05383387d6 100644
--- a/searchcore/src/tests/proton/documentdb/threading_service_config/threading_service_config_test.cpp
+++ b/searchcore/src/tests/proton/documentdb/threading_service_config/threading_service_config_test.cpp
@@ -56,17 +56,11 @@ TEST_F("require that default task limit is set", Fixture)
     EXPECT_EQUAL(500u, f.make(24).defaultTaskLimit());
 }
 
-TEST_F("require that semiunbound task limit is scaled based on indexing threads", Fixture)
-{
-    EXPECT_EQUAL(12500u, f.make(24).semiUnboundTaskLimit());
-}
-
 namespace {
 
-void assertConfig(uint32_t exp_indexing_threads, uint32_t exp_default_task_limit, uint32_t exp_semi_unbound_task_limit, const ThreadingServiceConfig &config) {
+void assertConfig(uint32_t exp_indexing_threads, uint32_t exp_default_task_limit, const ThreadingServiceConfig &config) {
     EXPECT_EQUAL(exp_indexing_threads, config.indexingThreads());
     EXPECT_EQUAL(exp_default_task_limit, config.defaultTaskLimit());
-    EXPECT_EQUAL(exp_semi_unbound_task_limit, config.semiUnboundTaskLimit());
 }
 
 }
@@ -74,11 +68,11 @@ void assertConfig(uint32_t exp_indexing_threads, uint32_t exp_default_task_limit
 TEST_FF("require that config can be somewhat updated", Fixture(), Fixture(2, 1000, 100000))
 {
     auto cfg1 = f1.make(1);
-    assertConfig(2u, 500u, 25000u, cfg1);
+    assertConfig(2u, 500u, cfg1);
     const auto cfg2 = f2.make(13);
-    assertConfig(3u, 1000u, 33333u, cfg2);
+    assertConfig(3u, 1000u, cfg2);
     cfg1.update(cfg2);
-    assertConfig(2u, 1000u, 33333u, cfg1); // Indexing threads not changed
+    assertConfig(2u, 1000u, cfg1); // Indexing threads not changed
 }
 
 TEST_MAIN()
diff --git a/searchcore/src/vespa/searchcore/config/proton.def b/searchcore/src/vespa/searchcore/config/proton.def
index c558ad2a12f..5ace4b66803 100644
--- a/searchcore/src/vespa/searchcore/config/proton.def
+++ b/searchcore/src/vespa/searchcore/config/proton.def
@@ -127,11 +127,7 @@ indexing.optimize enum {LATENCY, THROUGHPUT, ADAPTIVE} default=LATENCY restart
 ## indexing threads.  Only used when visibility delay is zero.
 indexing.tasklimit int default=1000
 
-## Parameter used to calculate maximum number of pending operations
-## for each of the internal indexing threads when visibility delay is
-## nonzero. The number is divided by the number of indexing threads,
-## i.e.  when indexing.threads is 4 and indexing.semiunboundtasklimit
-## is 40000 then effective task limit is 10000.
+## Deprecated and ignored, will soon go away
 indexing.semiunboundtasklimit int default = 1000
 
 ## Kind of watermark for when to activate extra manpower
diff --git a/searchcore/src/vespa/searchcore/proton/server/documentdb.cpp b/searchcore/src/vespa/searchcore/proton/server/documentdb.cpp
index 3c88324ab6e..58152a6a21b 100644
--- a/searchcore/src/vespa/searchcore/proton/server/documentdb.cpp
+++ b/searchcore/src/vespa/searchcore/proton/server/documentdb.cpp
@@ -210,9 +210,6 @@ DocumentDB::DocumentDB(const vespalib::string &baseDir,
     _writeFilter.setConfig(loaded_config->getMaintenanceConfigSP()->getAttributeUsageFilterConfig());
     vespalib::duration visibilityDelay = loaded_config->getMaintenanceConfigSP()->getVisibilityDelay();
     _visibility.setVisibilityDelay(visibilityDelay);
-    if (_visibility.hasVisibilityDelay()) {
-        _writeService.setTaskLimit(_writeServiceConfig.semiUnboundTaskLimit(), _writeServiceConfig.defaultTaskLimit());
-    }
 }
 
 void DocumentDB::registerReference()
@@ -457,11 +454,7 @@ DocumentDB::applyConfig(DocumentDBConfig::SP configSnapshot, SerialNum serialNum
     if (_state.getState() >= DDBState::State::APPLY_LIVE_CONFIG) {
         _writeServiceConfig.update(configSnapshot->get_threading_service_config());
     }
-    if (_visibility.hasVisibilityDelay()) {
-        _writeService.setTaskLimit(_writeServiceConfig.semiUnboundTaskLimit(), _writeServiceConfig.defaultTaskLimit());
-    } else {
-        _writeService.setTaskLimit(_writeServiceConfig.defaultTaskLimit(), _writeServiceConfig.defaultTaskLimit());
-    }
+    _writeService.setTaskLimit(_writeServiceConfig.defaultTaskLimit(), _writeServiceConfig.defaultTaskLimit());
     if (params.shouldSubDbsChange() || hasVisibilityDelayChanged) {
         applySubDBConfig(*configSnapshot, serialNum, params);
         if (serialNum < _feedHandler->getSerialNum()) {
diff --git a/searchcore/src/vespa/searchcore/proton/server/threading_service_config.cpp b/searchcore/src/vespa/searchcore/proton/server/threading_service_config.cpp
index 4169f6fe55c..a7631148a43 100644
--- a/searchcore/src/vespa/searchcore/proton/server/threading_service_config.cpp
+++ b/searchcore/src/vespa/searchcore/proton/server/threading_service_config.cpp
@@ -12,13 +12,11 @@ using OptimizeFor = vespalib::Executor::OptimizeFor;
 
 ThreadingServiceConfig::ThreadingServiceConfig(uint32_t indexingThreads_,
                                                uint32_t defaultTaskLimit_,
-                                               uint32_t semiUnboundTaskLimit_,
                                                OptimizeFor optimize_,
                                                uint32_t kindOfWatermark_,
                                                vespalib::duration reactionTime_)
     : _indexingThreads(indexingThreads_),
       _defaultTaskLimit(defaultTaskLimit_),
-      _semiUnboundTaskLimit(semiUnboundTaskLimit_),
       _optimize(optimize_),
       _kindOfWatermark(kindOfWatermark_),
       _reactionTime(reactionTime_)
@@ -60,7 +58,6 @@ ThreadingServiceConfig::make(const ProtonConfig &cfg, double concurrency, const
 {
     uint32_t indexingThreads = calculateIndexingThreads(cfg.indexing, concurrency, cpuInfo);
     return ThreadingServiceConfig(indexingThreads, cfg.indexing.tasklimit,
-                                  std::max(uint32_t(cfg.indexing.tasklimit), (cfg.indexing.semiunboundtasklimit / indexingThreads)),
                                   selectOptimization(cfg.indexing.optimize),
                                   cfg.indexing.kindOfWatermark,
                                   vespalib::from_s(cfg.indexing.reactiontime));
@@ -68,14 +65,13 @@ ThreadingServiceConfig::make(const ProtonConfig &cfg, double concurrency, const
 
 ThreadingServiceConfig
 ThreadingServiceConfig::make(uint32_t indexingThreads) {
-    return ThreadingServiceConfig(indexingThreads, 100, 1000, OptimizeFor::LATENCY, 0, 10ms);
+    return ThreadingServiceConfig(indexingThreads, 100, OptimizeFor::LATENCY, 0, 10ms);
 }
 
 void
 ThreadingServiceConfig::update(const ThreadingServiceConfig& cfg)
 {
     _defaultTaskLimit = cfg._defaultTaskLimit;
-    _semiUnboundTaskLimit = cfg._semiUnboundTaskLimit;
 }
 
 bool
@@ -83,7 +79,6 @@ ThreadingServiceConfig::operator==(const ThreadingServiceConfig &rhs) const
 {
     return _indexingThreads == rhs._indexingThreads &&
         _defaultTaskLimit == rhs._defaultTaskLimit &&
-        _semiUnboundTaskLimit == rhs._semiUnboundTaskLimit &&
         _optimize == rhs._optimize &&
         _kindOfWatermark == rhs._kindOfWatermark &&
         _reactionTime == rhs._reactionTime;
diff --git a/searchcore/src/vespa/searchcore/proton/server/threading_service_config.h b/searchcore/src/vespa/searchcore/proton/server/threading_service_config.h
index 24551247c4e..f6eba2734b9 100644
--- a/searchcore/src/vespa/searchcore/proton/server/threading_service_config.h
+++ b/searchcore/src/vespa/searchcore/proton/server/threading_service_config.h
@@ -20,13 +20,12 @@ public:
 private:
     uint32_t           _indexingThreads;
     uint32_t           _defaultTaskLimit;
-    uint32_t           _semiUnboundTaskLimit;
     OptimizeFor        _optimize;
     uint32_t           _kindOfWatermark;
     vespalib::duration _reactionTime;         // Maximum reaction time to new tasks
 
 private:
-    ThreadingServiceConfig(uint32_t indexingThreads_, uint32_t defaultTaskLimit_, uint32_t semiUnboundTaskLimit_, OptimizeFor optimize, uint32_t kindOfWatermark, vespalib::duration reactionTime);
+    ThreadingServiceConfig(uint32_t indexingThreads_, uint32_t defaultTaskLimit_, OptimizeFor optimize, uint32_t kindOfWatermark, vespalib::duration reactionTime);
 
 public:
     static ThreadingServiceConfig make(const ProtonConfig &cfg, double concurrency, const HwInfo::Cpu &cpuInfo);
@@ -34,7 +33,6 @@ public:
     void update(const ThreadingServiceConfig& cfg);
     uint32_t indexingThreads() const { return _indexingThreads; }
     uint32_t defaultTaskLimit() const { return _defaultTaskLimit; }
-    uint32_t semiUnboundTaskLimit() const { return _semiUnboundTaskLimit; }
     OptimizeFor optimize() const { return _optimize; }
     uint32_t kindOfwatermark() const { return _kindOfWatermark; }
     vespalib::duration reactionTime() const { return _reactionTime; }