Allow changing indexing.tasklimit and indexing.semiunboundtasklimit in

proton config without restart.

13 files changed, 119 insertions, 14 deletions

diff --git a/searchcore/src/apps/tests/persistenceconformance_test.cpp b/searchcore/src/apps/tests/persistenceconformance_test.cpp
index 26a44606898..417e47f6bda 100644
--- a/searchcore/src/apps/tests/persistenceconformance_test.cpp
+++ b/searchcore/src/apps/tests/persistenceconformance_test.cpp
@@ -24,6 +24,7 @@
 #include <vespa/searchcore/proton/server/fileconfigmanager.h>
 #include <vespa/searchcore/proton/server/memoryconfigstore.h>
 #include <vespa/searchcore/proton/server/persistencehandlerproxy.h>
+#include <vespa/searchcore/proton/server/threading_service_config.h>
 #include <vespa/searchlib/index/dummyfileheadercontext.h>
 #include <vespa/searchlib/transactionlog/translogserver.h>
 #include <vespa/searchsummary/config/config-juniperrc.h>
@@ -140,6 +141,7 @@ public:
                         schema,
                         std::make_shared<DocumentDBMaintenanceConfig>(),
                         search::LogDocumentStore::Config(),
+                        std::make_shared<const ThreadingServiceConfig>(ThreadingServiceConfig::make(1)),
                         "client",
                         docTypeName.getName());
     }
diff --git a/searchcore/src/apps/vespa-feed-bm/vespa_feed_bm.cpp b/searchcore/src/apps/vespa-feed-bm/vespa_feed_bm.cpp
index 506881ec61e..36b81106ef2 100644
--- a/searchcore/src/apps/vespa-feed-bm/vespa_feed_bm.cpp
+++ b/searchcore/src/apps/vespa-feed-bm/vespa_feed_bm.cpp
@@ -51,6 +51,7 @@
 #include <vespa/searchcore/proton/server/fileconfigmanager.h>
 #include <vespa/searchcore/proton/server/memoryconfigstore.h>
 #include <vespa/searchcore/proton/server/persistencehandlerproxy.h>
+#include <vespa/searchcore/proton/server/threading_service_config.h>
 #include <vespa/searchlib/index/dummyfileheadercontext.h>
 #include <vespa/searchlib/transactionlog/translogserver.h>
 #include <vespa/searchsummary/config/config-juniperrc.h>
@@ -146,6 +147,7 @@ using storage::rpc::StorageApiRpcService;
 using storage::spi::PersistenceProvider;
 using vespalib::compression::CompressionConfig;
 using vespalib::makeLambdaTask;
+using proton::ThreadingServiceConfig;
 
 using DocumentDBMap = std::map<DocTypeName, std::shared_ptr<DocumentDB>>;
 
@@ -196,6 +198,7 @@ std::shared_ptr<DocumentDBConfig> make_document_db_config(std::shared_ptr<Docume
             schema,
             std::make_shared<DocumentDBMaintenanceConfig>(),
             search::LogDocumentStore::Config(),
+            std::make_shared<const ThreadingServiceConfig>(ThreadingServiceConfig::make(1)),
             "client",
             doc_type_name.getName());
 }
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 37ac5f0d65c..a3c031cd5c4 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
@@ -14,15 +14,15 @@ using ProtonConfigBuilder = vespa::config::search::core::ProtonConfigBuilder;
 
 struct Fixture {
     ProtonConfig cfg;
-    Fixture(uint32_t baseLineIndexingThreads = 2)
-        : cfg(makeConfig(baseLineIndexingThreads))
+    Fixture(uint32_t baseLineIndexingThreads = 2, uint32_t task_limit = 500, uint32_t semi_unbound_task_limit = 50000)
+        : cfg(makeConfig(baseLineIndexingThreads, task_limit, semi_unbound_task_limit))
     {
     }
-    ProtonConfig makeConfig(uint32_t baseLineIndexingThreads) {
+    ProtonConfig makeConfig(uint32_t baseLineIndexingThreads, uint32_t task_limit, uint32_t semi_unbound_task_limit) {
         ProtonConfigBuilder builder;
         builder.indexing.threads = baseLineIndexingThreads;
-        builder.indexing.tasklimit = 500;
-        builder.indexing.semiunboundtasklimit = 50000;
+        builder.indexing.tasklimit = task_limit;
+        builder.indexing.semiunboundtasklimit = semi_unbound_task_limit;
         return builder;
     }
     ThreadingServiceConfig make(uint32_t cpuCores) {
@@ -61,6 +61,26 @@ TEST_F("require that semiunbound task limit is scaled based on indexing threads"
     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) {
+    EXPECT_EQUAL(exp_indexing_threads, config.indexingThreads());
+    EXPECT_EQUAL(exp_default_task_limit, config.defaultTaskLimit());
+    EXPECT_EQUAL(exp_semi_unbound_task_limit, config.semiUnboundTaskLimit());
+}
+
+}
+
+TEST_FF("require that config can be somewhat updated", Fixture(), Fixture(2, 1000, 100000))
+{
+    auto cfg1 = f1.make(1);
+    assertConfig(2u, 500u, 25000u, cfg1);
+    const auto cfg2 = f2.make(13);
+    assertConfig(3u, 1000u, 33333u, cfg2);
+    cfg1.update(cfg2);
+    assertConfig(2u, 1000u, 33333u, cfg1); // Indexing threads not changed
+}
+
 TEST_MAIN()
 {
     TEST_RUN_ALL();
diff --git a/searchcore/src/tests/proton/proton_configurer/proton_configurer_test.cpp b/searchcore/src/tests/proton/proton_configurer/proton_configurer_test.cpp
index 6190177ac9d..5a0cfc18c78 100644
--- a/searchcore/src/tests/proton/proton_configurer/proton_configurer_test.cpp
+++ b/searchcore/src/tests/proton/proton_configurer/proton_configurer_test.cpp
@@ -17,6 +17,7 @@
 #include <vespa/searchcore/proton/server/proton_configurer.h>
 #include <vespa/searchcore/proton/server/i_proton_configurer_owner.h>
 #include <vespa/searchcore/proton/server/i_proton_disk_layout.h>
+#include <vespa/searchcore/proton/server/threading_service_config.h>
 #include <vespa/searchsummary/config/config-juniperrc.h>
 #include <vespa/searchcore/config/config-ranking-constants.h>
 #include <vespa/searchcore/config/config-onnx-models.h>
@@ -101,6 +102,7 @@ struct DBConfigFixture {
              buildSchema(),
              std::make_shared<DocumentDBMaintenanceConfig>(),
              search::LogDocumentStore::Config(),
+             std::make_shared<const ThreadingServiceConfig>(ThreadingServiceConfig::make(1)),
              configId,
              docTypeName);
     }
diff --git a/searchcore/src/vespa/searchcore/config/proton.def b/searchcore/src/vespa/searchcore/config/proton.def
index abe774390f0..c558ad2a12f 100644
--- a/searchcore/src/vespa/searchcore/config/proton.def
+++ b/searchcore/src/vespa/searchcore/config/proton.def
@@ -125,14 +125,14 @@ indexing.optimize enum {LATENCY, THROUGHPUT, ADAPTIVE} default=LATENCY restart
 
 ## Maximum number of pending operations for each of the internal
 ## indexing threads.  Only used when visibility delay is zero.
-indexing.tasklimit int default=1000 restart
+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.
-indexing.semiunboundtasklimit int default = 1000 restart
+indexing.semiunboundtasklimit int default = 1000
 
 ## Kind of watermark for when to activate extra manpower
 ## Utilized if optimize is set to either THROUGHPUT or ADAPTIVE
diff --git a/searchcore/src/vespa/searchcore/proton/server/documentdb.cpp b/searchcore/src/vespa/searchcore/proton/server/documentdb.cpp
index c63785faa35..10af2d16764 100644
--- a/searchcore/src/vespa/searchcore/proton/server/documentdb.cpp
+++ b/searchcore/src/vespa/searchcore/proton/server/documentdb.cpp
@@ -136,10 +136,7 @@ DocumentDB::DocumentDB(const vespalib::string &baseDir,
       _bucketSpace(bucketSpace),
       _baseDir(baseDir + "/" + _docTypeName.toString()),
       // Only one thread per executor, or performDropFeedView() will fail.
-      _writeServiceConfig(
-              ThreadingServiceConfig::make(protonCfg,
-                      findDocumentDB(protonCfg.documentdb, docTypeName.getName())->feeding.concurrency,
-                      hwInfo.cpu())),
+      _writeServiceConfig(configSnapshot->get_threading_service_config()),
       _writeService(sharedExecutor, _writeServiceConfig, indexing_thread_stack_size),
       _initializeThreads(std::move(initializeThreads)),
       _initConfigSnapshot(),
@@ -455,6 +452,9 @@ DocumentDB::applyConfig(DocumentDBConfig::SP configSnapshot, SerialNum serialNum
         hasVisibilityDelayChanged = (visibilityDelay != _visibility.getVisibilityDelay());
         _visibility.setVisibilityDelay(visibilityDelay);
     }
+    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 {
diff --git a/searchcore/src/vespa/searchcore/proton/server/documentdbconfig.cpp b/searchcore/src/vespa/searchcore/proton/server/documentdbconfig.cpp
index 8bcf8440101..c254672bfd7 100644
--- a/searchcore/src/vespa/searchcore/proton/server/documentdbconfig.cpp
+++ b/searchcore/src/vespa/searchcore/proton/server/documentdbconfig.cpp
@@ -1,6 +1,7 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include "documentdbconfig.h"
+#include "threading_service_config.h"
 #include <vespa/config-attributes.h>
 #include <vespa/config-imported-fields.h>
 #include <vespa/config-indexschema.h>
@@ -47,7 +48,8 @@ DocumentDBConfig::ComparisonResult::ComparisonResult()
       maintenanceChanged(false),
       storeChanged(false),
       visibilityDelayChanged(false),
-      flushChanged(false)
+      flushChanged(false),
+      threading_service_config_changed(false)
 { }
 
 DocumentDBConfig::DocumentDBConfig(
@@ -67,6 +69,7 @@ DocumentDBConfig::DocumentDBConfig(
                const Schema::SP &schema,
                const DocumentDBMaintenanceConfig::SP &maintenance,
                const search::LogDocumentStore::Config & storeConfig,
+               std::shared_ptr<const ThreadingServiceConfig> threading_service_config,
                const vespalib::string &configId,
                const vespalib::string &docTypeName)
     : _configId(configId),
@@ -87,6 +90,7 @@ DocumentDBConfig::DocumentDBConfig(
       _schema(schema),
       _maintenance(maintenance),
       _storeConfig(storeConfig),
+      _threading_service_config(std::move(threading_service_config)),
       _orig(),
       _delayedAttributeAspects(false)
 { }
@@ -112,6 +116,7 @@ DocumentDBConfig(const DocumentDBConfig &cfg)
       _schema(cfg._schema),
       _maintenance(cfg._maintenance),
       _storeConfig(cfg._storeConfig),
+      _threading_service_config(cfg._threading_service_config),
       _orig(cfg._orig),
       _delayedAttributeAspects(false)
 { }
@@ -135,7 +140,8 @@ DocumentDBConfig::operator==(const DocumentDBConfig & rhs) const
            equals<TuneFileDocumentDB>(_tuneFileDocumentDB.get(), rhs._tuneFileDocumentDB.get()) &&
            equals<Schema>(_schema.get(), rhs._schema.get()) &&
            equals<DocumentDBMaintenanceConfig>(_maintenance.get(), rhs._maintenance.get()) &&
-           _storeConfig == rhs._storeConfig;
+           _storeConfig == rhs._storeConfig &&
+           equals<ThreadingServiceConfig>(_threading_service_config.get(), rhs._threading_service_config.get());
 }
 
 
@@ -160,6 +166,7 @@ DocumentDBConfig::compare(const DocumentDBConfig &rhs) const
     retval.storeChanged = (_storeConfig != rhs._storeConfig);
     retval.visibilityDelayChanged = (_maintenance->getVisibilityDelay() != rhs._maintenance->getVisibilityDelay());
     retval.flushChanged = !equals<DocumentDBMaintenanceConfig>(_maintenance.get(), rhs._maintenance.get(), [](const auto &l, const auto &r) { return l.getFlushConfig() == r.getFlushConfig(); });
+    retval.threading_service_config_changed = !equals<ThreadingServiceConfig>(_threading_service_config.get(), rhs._threading_service_config.get());
     return retval;
 }
 
@@ -180,7 +187,8 @@ DocumentDBConfig::valid() const
            _importedFields &&
            _tuneFileDocumentDB &&
            _schema &&
-           _maintenance;
+           _maintenance &&
+           _threading_service_config;
 }
 
 namespace
@@ -223,6 +231,7 @@ DocumentDBConfig::makeReplayConfig(const SP & orig)
                 o._schema,
                 o._maintenance,
                 o._storeConfig,
+                o._threading_service_config,
                 o._configId,
                 o._docTypeName);
     ret->_orig = orig;
@@ -264,6 +273,7 @@ DocumentDBConfig::newFromAttributesConfig(const AttributesConfigSP &attributes)
             _schema,
             _maintenance,
             _storeConfig,
+            _threading_service_config,
             _configId,
             _docTypeName);
 }
@@ -300,6 +310,7 @@ DocumentDBConfig::makeDelayedAttributeAspectConfig(const SP &newCfg, const Docum
                    n._schema,
                    n._maintenance,
                    n._storeConfig,
+                   n._threading_service_config,
                    n._configId,
                    n._docTypeName);
     result->_delayedAttributeAspects = true;
diff --git a/searchcore/src/vespa/searchcore/proton/server/documentdbconfig.h b/searchcore/src/vespa/searchcore/proton/server/documentdbconfig.h
index 09fdd5b5b0a..daca84d5fd1 100644
--- a/searchcore/src/vespa/searchcore/proton/server/documentdbconfig.h
+++ b/searchcore/src/vespa/searchcore/proton/server/documentdbconfig.h
@@ -29,6 +29,8 @@ namespace document::internal { class InternalDocumenttypesType; }
 
 namespace proton {
 
+class ThreadingServiceConfig;
+
 class DocumentDBConfig
 {
 public:
@@ -52,6 +54,7 @@ public:
         bool storeChanged;
         bool visibilityDelayChanged;
         bool flushChanged;
+        bool threading_service_config_changed;
 
         ComparisonResult();
         ComparisonResult &setRankProfilesChanged(bool val) { rankProfilesChanged = val; return *this; }
@@ -84,6 +87,7 @@ public:
             }
             return *this;
         }
+        ComparisonResult &set_threading_service_config_changed(bool val) { threading_service_config_changed = val; return *this; }
     };
 
     using SP = std::shared_ptr<DocumentDBConfig>;
@@ -126,6 +130,7 @@ private:
     search::index::Schema::SP        _schema;
     MaintenanceConfigSP              _maintenance;
     search::LogDocumentStore::Config _storeConfig;
+    std::shared_ptr<const ThreadingServiceConfig> _threading_service_config;
     SP                               _orig;
     bool                             _delayedAttributeAspects;
 
@@ -163,6 +168,7 @@ public:
                      const search::index::Schema::SP &schema,
                      const DocumentDBMaintenanceConfig::SP &maintenance,
                      const search::LogDocumentStore::Config & storeConfig,
+                     std::shared_ptr<const ThreadingServiceConfig> threading_service_config,
                      const vespalib::string &configId,
                      const vespalib::string &docTypeName);
 
@@ -202,6 +208,8 @@ public:
     const MaintenanceConfigSP &getMaintenanceConfigSP() const { return _maintenance; }
     const search::TuneFileDocumentDB::SP &getTuneFileDocumentDBSP() const { return _tuneFileDocumentDB; }
     bool getDelayedAttributeAspects() const { return _delayedAttributeAspects; }
+    const ThreadingServiceConfig& get_threading_service_config() const { return *_threading_service_config; }
+    const std::shared_ptr<const ThreadingServiceConfig>& get_threading_service_config_shared_ptr() const { return _threading_service_config; }
 
     bool operator==(const DocumentDBConfig &rhs) const;
 
diff --git a/searchcore/src/vespa/searchcore/proton/server/documentdbconfigmanager.cpp b/searchcore/src/vespa/searchcore/proton/server/documentdbconfigmanager.cpp
index e842e3cdc41..f32a8a180e3 100644
--- a/searchcore/src/vespa/searchcore/proton/server/documentdbconfigmanager.cpp
+++ b/searchcore/src/vespa/searchcore/proton/server/documentdbconfigmanager.cpp
@@ -2,6 +2,7 @@
 
 #include "documentdbconfigmanager.h"
 #include "bootstrapconfig.h"
+#include "threading_service_config.h"
 #include <vespa/searchcore/proton/common/hw_info.h>
 #include <vespa/searchcore/config/config-ranking-constants.h>
 #include <vespa/searchcore/config/config-onnx-models.h>
@@ -225,6 +226,30 @@ filterImportedAttributes(const AttributesConfigSP &attrCfg)
     return result;
 }
 
+const ProtonConfig::Documentdb default_document_db_config_entry;
+
+const ProtonConfig::Documentdb&
+find_document_db_config_entry(const ProtonConfig::DocumentdbVector& document_dbs, const vespalib::string& doc_type_name) {
+    for (const auto & db_cfg : document_dbs) {
+        if (db_cfg.inputdoctypename == doc_type_name) {
+            return db_cfg;
+        }
+    }
+    return default_document_db_config_entry;
+}
+
+std::shared_ptr<const ThreadingServiceConfig>
+build_threading_service_config(const ProtonConfig &proton_config,
+                               const HwInfo &hw_info,
+                               const vespalib::string& doc_type_name)
+{
+    auto& document_db_config_entry = find_document_db_config_entry(proton_config.documentdb, doc_type_name);
+    return std::make_shared<const ThreadingServiceConfig>
+        (ThreadingServiceConfig::make(proton_config,
+                                      document_db_config_entry.feeding.concurrency,
+                                      hw_info.cpu()));
+}
+
 }
 
 void
@@ -247,6 +272,7 @@ DocumentDBConfigManager::update(const ConfigSnapshot &snapshot)
     IndexschemaConfigSP newIndexschemaConfig;
     MaintenanceConfigSP oldMaintenanceConfig;
     MaintenanceConfigSP newMaintenanceConfig;
+    std::shared_ptr<const ThreadingServiceConfig> old_threading_service_config;
 
     if (!_ignoreForwardedConfig) {
         if (!(_bootstrapConfig->getDocumenttypesConfigSP() &&
@@ -270,6 +296,7 @@ DocumentDBConfigManager::update(const ConfigSnapshot &snapshot)
         newOnnxModels = current->getOnnxModelsSP();
         newIndexschemaConfig = current->getIndexschemaConfigSP();
         oldMaintenanceConfig = current->getMaintenanceConfigSP();
+        old_threading_service_config = current->get_threading_service_config_shared_ptr();
         currentGeneration = current->getGeneration();
     }
 
@@ -348,6 +375,11 @@ DocumentDBConfigManager::update(const ConfigSnapshot &snapshot)
     if (newMaintenanceConfig && oldMaintenanceConfig && (*newMaintenanceConfig == *oldMaintenanceConfig)) {
         newMaintenanceConfig = oldMaintenanceConfig;
     }
+    auto new_threading_service_config = build_threading_service_config(_bootstrapConfig->getProtonConfig(), _bootstrapConfig->getHwInfo(), _docTypeName);
+    if (new_threading_service_config && old_threading_service_config &&
+        (*new_threading_service_config == *old_threading_service_config)) {
+        new_threading_service_config = old_threading_service_config;
+    }
     auto newSnapshot = std::make_shared<DocumentDBConfig>(generation,
                                  newRankProfilesConfig,
                                  newRankingConstants,
@@ -364,6 +396,7 @@ DocumentDBConfigManager::update(const ConfigSnapshot &snapshot)
                                  schema,
                                  newMaintenanceConfig,
                                  storeConfig,
+                                 new_threading_service_config,
                                  _configId,
                                  _docTypeName);
     assert(newSnapshot->valid());
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 3b268835331..4169f6fe55c 100644
--- a/searchcore/src/vespa/searchcore/proton/server/threading_service_config.cpp
+++ b/searchcore/src/vespa/searchcore/proton/server/threading_service_config.cpp
@@ -71,4 +71,22 @@ ThreadingServiceConfig::make(uint32_t indexingThreads) {
     return ThreadingServiceConfig(indexingThreads, 100, 1000, OptimizeFor::LATENCY, 0, 10ms);
 }
 
+void
+ThreadingServiceConfig::update(const ThreadingServiceConfig& cfg)
+{
+    _defaultTaskLimit = cfg._defaultTaskLimit;
+    _semiUnboundTaskLimit = cfg._semiUnboundTaskLimit;
+}
+
+bool
+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 055c3b46549..24551247c4e 100644
--- a/searchcore/src/vespa/searchcore/proton/server/threading_service_config.h
+++ b/searchcore/src/vespa/searchcore/proton/server/threading_service_config.h
@@ -31,12 +31,14 @@ private:
 public:
     static ThreadingServiceConfig make(const ProtonConfig &cfg, double concurrency, const HwInfo::Cpu &cpuInfo);
     static ThreadingServiceConfig make(uint32_t indexingThreads);
+    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; }
+    bool operator==(const ThreadingServiceConfig &rhs) const;
 };
 
 }
diff --git a/searchcore/src/vespa/searchcore/proton/test/documentdb_config_builder.cpp b/searchcore/src/vespa/searchcore/proton/test/documentdb_config_builder.cpp
index a2366a3cb92..335c7aca24c 100644
--- a/searchcore/src/vespa/searchcore/proton/test/documentdb_config_builder.cpp
+++ b/searchcore/src/vespa/searchcore/proton/test/documentdb_config_builder.cpp
@@ -10,6 +10,7 @@
 #include <vespa/searchsummary/config/config-juniperrc.h>
 #include <vespa/document/config/config-documenttypes.h>
 #include <vespa/config-imported-fields.h>
+#include <vespa/searchcore/proton/server/threading_service_config.h>
 
 using document::DocumenttypesConfig;
 using search::TuneFileDocumentDB;
@@ -21,6 +22,7 @@ using vespa::config::search::SummaryConfig;
 using vespa::config::search::SummarymapConfig;
 using vespa::config::search::summary::JuniperrcConfig;
 using vespa::config::search::ImportedFieldsConfig;
+using proton::ThreadingServiceConfig;
 
 namespace proton::test {
 
@@ -44,6 +46,7 @@ DocumentDBConfigBuilder::DocumentDBConfigBuilder(int64_t generation,
       _schema(schema),
       _maintenance(std::make_shared<DocumentDBMaintenanceConfig>()),
       _store(),
+      _threading_service_config(std::make_shared<const ThreadingServiceConfig>(ThreadingServiceConfig::make(1))),
       _configId(configId),
       _docTypeName(docTypeName)
 { }
@@ -66,6 +69,7 @@ DocumentDBConfigBuilder::DocumentDBConfigBuilder(const DocumentDBConfig &cfg)
       _schema(cfg.getSchemaSP()),
       _maintenance(cfg.getMaintenanceConfigSP()),
       _store(cfg.getStoreConfig()),
+      _threading_service_config(cfg.get_threading_service_config_shared_ptr()),
       _configId(cfg.getConfigId()),
       _docTypeName(cfg.getDocTypeName())
 {}
@@ -92,6 +96,7 @@ DocumentDBConfigBuilder::build()
             _schema,
             _maintenance,
             _store,
+            _threading_service_config,
             _configId,
             _docTypeName);
 }
diff --git a/searchcore/src/vespa/searchcore/proton/test/documentdb_config_builder.h b/searchcore/src/vespa/searchcore/proton/test/documentdb_config_builder.h
index 68fb5454eef..218a7c56fa9 100644
--- a/searchcore/src/vespa/searchcore/proton/test/documentdb_config_builder.h
+++ b/searchcore/src/vespa/searchcore/proton/test/documentdb_config_builder.h
@@ -27,6 +27,7 @@ private:
     search::index::Schema::SP _schema;
     DocumentDBConfig::MaintenanceConfigSP _maintenance;
     search::LogDocumentStore::Config _store;
+    std::shared_ptr<const ThreadingServiceConfig> _threading_service_config;
     vespalib::string _configId;
     vespalib::string _docTypeName;