Unify on using vespalib::duration.

54 files changed, 312 insertions, 391 deletions

diff --git a/config/src/apps/vespa-get-config/getconfig.cpp b/config/src/apps/vespa-get-config/getconfig.cpp
index 9bbc14552b0..78ae9c390f0 100644
--- a/config/src/apps/vespa-get-config/getconfig.cpp
+++ b/config/src/apps/vespa-get-config/getconfig.cpp
@@ -108,8 +108,8 @@ GetConfig::Main()
         configId = "";
     }
     const char *configXxhash64 = "";
-    int serverTimeout = 3;
-    int clientTimeout = 10;
+    vespalib::duration serverTimeout = 3s;
+    vespalib::duration clientTimeout = 10s;
 
     int serverPort = 19090;
 
@@ -142,10 +142,10 @@ GetConfig::Main()
             defMD5 = optArg;
             break;
         case 't':
-            serverTimeout = atoi(optArg);
+            serverTimeout = vespalib::from_s(atof(optArg));
             break;
         case 'w':
-            clientTimeout = atoi(optArg);
+            clientTimeout = vespalib::from_s(atof(optArg));
             break;
         case 'r':
             traceLevel = atoi(optArg);
@@ -231,9 +231,9 @@ GetConfig::Main()
     FRTConnection connection(spec, _server->supervisor(), TimingValues());
     ConfigKey key(configId, defName, defNamespace, defMD5, defSchema);
     ConfigState state(configXxhash64, generation, false);
-    FRTConfigRequest::UP request = requestFactory.createConfigRequest(key, &connection, state, serverTimeout * 1000);
+    FRTConfigRequest::UP request = requestFactory.createConfigRequest(key, &connection, state, serverTimeout);
 
-    _target->InvokeSync(request->getRequest(), clientTimeout); // seconds
+    _target->InvokeSync(request->getRequest(), vespalib::to_s(clientTimeout)); // seconds
 
     ConfigResponse::UP response = request->createResponse(request->getRequest());
     response->validateResponse();
diff --git a/config/src/tests/configagent/configagent.cpp b/config/src/tests/configagent/configagent.cpp
index 10f321c181d..03155f6261d 100644
--- a/config/src/tests/configagent/configagent.cpp
+++ b/config/src/tests/configagent/configagent.cpp
@@ -2,6 +2,7 @@
 #include <vespa/vespalib/testkit/test_kit.h>
 #include <vespa/config/common/misc.h>
 #include <vespa/config/common/configrequest.h>
+#include <vespa/config/common/configresponse.h>
 #include <vespa/config/common/timingvalues.h>
 #include <vespa/config/common/trace.h>
 #include <vespa/config/common/configkey.h>
@@ -10,7 +11,6 @@
 #include <config-my.h>
 
 using namespace config;
-using namespace std::chrono_literals;
 
 class MyConfigRequest : public ConfigRequest
 {
@@ -91,7 +91,7 @@ public:
         return std::move(_update);
     }
 
-    bool wait(milliseconds timeout) override
+    bool wait(vespalib::duration timeout) override
     {
         (void) timeout;
         return true;
@@ -120,22 +120,22 @@ ConfigValue createValue(const std::string & myField, const std::string & xxhash6
 }
 
 static TimingValues testTimingValues(
-        2000,  // successTimeout
-        500,  // errorTimeout
-        500,   // initialTimeout
+        2000ms,  // successTimeout
+        500ms,  // errorTimeout
+        500ms,   // initialTimeout
         4000ms,  // subscribeTimeout
-        0,     // fixedDelay
-        250,   // successDelay
-        250,   // unconfiguredDelay
-        500,   // configuredErrorDelay
+        0ms,     // fixedDelay
+        250ms,   // successDelay
+        250ms,   // unconfiguredDelay
+        500ms,   // configuredErrorDelay
         5,
-        1000,
-        2000);    // maxDelayMultiplier
+        1000ms,
+        2000ms);    // maxDelayMultiplier
 
 TEST("require that agent returns correct values") {
     FRTConfigAgent handler(std::make_shared<MyHolder>(), testTimingValues);
-    ASSERT_EQUAL(500u, handler.getTimeout());
-    ASSERT_EQUAL(0u, handler.getWaitTime());
+    ASSERT_EQUAL(500ms, handler.getTimeout());
+    ASSERT_EQUAL(0ms, handler.getWaitTime());
     ConfigState cs;
     ASSERT_EQUAL(cs.xxhash64, handler.getConfigState().xxhash64);
     ASSERT_EQUAL(cs.generation, handler.getConfigState().generation);
@@ -192,10 +192,10 @@ TEST("require that successful request sets correct wait time") {
     FRTConfigAgent handler(latch, testTimingValues);
 
     handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createOKResponse(testKey, testValue));
-    ASSERT_EQUAL(250u, handler.getWaitTime());
+    ASSERT_EQUAL(250ms, handler.getWaitTime());
 
     handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createOKResponse(testKey, testValue));
-    ASSERT_EQUAL(250u, handler.getWaitTime());
+    ASSERT_EQUAL(250ms, handler.getWaitTime());
 }
 
 TEST("require that bad config response returns false") {
@@ -205,36 +205,36 @@ TEST("require that bad config response returns false") {
     FRTConfigAgent handler(latch, testTimingValues);
 
     handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createConfigErrorResponse(testKey, testValue));
-    ASSERT_EQUAL(250u, handler.getWaitTime());
-    ASSERT_EQUAL(500u, handler.getTimeout());
+    ASSERT_EQUAL(250ms, handler.getWaitTime());
+    ASSERT_EQUAL(500ms, handler.getTimeout());
 
     handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createConfigErrorResponse(testKey, testValue));
-    ASSERT_EQUAL(500u, handler.getWaitTime());
-    ASSERT_EQUAL(500u, handler.getTimeout());
+    ASSERT_EQUAL(500ms, handler.getWaitTime());
+    ASSERT_EQUAL(500ms, handler.getTimeout());
 
     handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createConfigErrorResponse(testKey, testValue));
-    ASSERT_EQUAL(750u, handler.getWaitTime());
-    ASSERT_EQUAL(500u, handler.getTimeout());
+    ASSERT_EQUAL(750ms, handler.getWaitTime());
+    ASSERT_EQUAL(500ms, handler.getTimeout());
 
     handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createConfigErrorResponse(testKey, testValue));
-    ASSERT_EQUAL(1000u, handler.getWaitTime());
-    ASSERT_EQUAL(500u, handler.getTimeout());
+    ASSERT_EQUAL(1000ms, handler.getWaitTime());
+    ASSERT_EQUAL(500ms, handler.getTimeout());
 
     handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createConfigErrorResponse(testKey, testValue));
-    ASSERT_EQUAL(1250u, handler.getWaitTime());
-    ASSERT_EQUAL(500u, handler.getTimeout());
+    ASSERT_EQUAL(1250ms, handler.getWaitTime());
+    ASSERT_EQUAL(500ms, handler.getTimeout());
 
     handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createConfigErrorResponse(testKey, testValue));
-    ASSERT_EQUAL(1250u, handler.getWaitTime());
-    ASSERT_EQUAL(500u, handler.getTimeout());
+    ASSERT_EQUAL(1250ms, handler.getWaitTime());
+    ASSERT_EQUAL(500ms, handler.getTimeout());
 
     handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createOKResponse(testKey, testValue));
-    ASSERT_EQUAL(250u, handler.getWaitTime());
-    ASSERT_EQUAL(2000u, handler.getTimeout());
+    ASSERT_EQUAL(250ms, handler.getWaitTime());
+    ASSERT_EQUAL(2000ms, handler.getTimeout());
 
     handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createConfigErrorResponse(testKey, testValue));
-    ASSERT_EQUAL(500u, handler.getWaitTime());
-    ASSERT_EQUAL(500u, handler.getTimeout());
+    ASSERT_EQUAL(500ms, handler.getWaitTime());
+    ASSERT_EQUAL(500ms, handler.getTimeout());
 }
 
 TEST("require that bad response returns false") {
@@ -245,22 +245,22 @@ TEST("require that bad response returns false") {
     FRTConfigAgent handler(latch, testTimingValues);
 
     handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createServerErrorResponse(testKey, testValue));
-    ASSERT_EQUAL(250u, handler.getWaitTime());
+    ASSERT_EQUAL(250ms, handler.getWaitTime());
 
     handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createServerErrorResponse(testKey, testValue));
-    ASSERT_EQUAL(500u, handler.getWaitTime());
+    ASSERT_EQUAL(500ms, handler.getWaitTime());
 
     handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createServerErrorResponse(testKey, testValue));
-    ASSERT_EQUAL(750u, handler.getWaitTime());
+    ASSERT_EQUAL(750ms, handler.getWaitTime());
 
     handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createServerErrorResponse(testKey, testValue));
-    ASSERT_EQUAL(1000u, handler.getWaitTime());
+    ASSERT_EQUAL(1000ms, handler.getWaitTime());
 
     handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createServerErrorResponse(testKey, testValue));
-    ASSERT_EQUAL(1250u, handler.getWaitTime());
+    ASSERT_EQUAL(1250ms, handler.getWaitTime());
 
     handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createServerErrorResponse(testKey, testValue));
-    ASSERT_EQUAL(1250u, handler.getWaitTime());
+    ASSERT_EQUAL(1250ms, handler.getWaitTime());
 }
 
 TEST_MAIN() { TEST_RUN_ALL(); }
diff --git a/config/src/tests/configmanager/configmanager.cpp b/config/src/tests/configmanager/configmanager.cpp
index a7171b11137..d5e765cc69c 100644
--- a/config/src/tests/configmanager/configmanager.cpp
+++ b/config/src/tests/configmanager/configmanager.cpp
@@ -11,7 +11,6 @@
 #include "config-my.h"
 
 using namespace config;
-using namespace std::chrono_literals;
 
 namespace {
 
@@ -90,17 +89,17 @@ namespace {
     };
 
     static TimingValues testTimingValues(
-            2000,  // successTimeout
-            500,  // errorTimeout
-            500,   // initialTimeout
+            2000ms,  // successTimeout
+            500ms,  // errorTimeout
+            500ms,   // initialTimeout
             4000ms,  // unsubscribeTimeout
-            0,     // fixedDelay
-            250,   // successDelay
-            250,   // unconfiguredDelay
-            500,   // configuredErrorDelay
+            0ms,     // fixedDelay
+            250ms,   // successDelay
+            250ms,   // unconfiguredDelay
+            500ms,   // configuredErrorDelay
             5,
-            1000,
-            2000);    // maxDelayMultiplier
+            1000ms,
+            2000ms);    // maxDelayMultiplier
 
     class ManagerTester {
     public:
diff --git a/config/src/tests/configretriever/configretriever.cpp b/config/src/tests/configretriever/configretriever.cpp
index fdd106e44f2..1515632cf4b 100644
--- a/config/src/tests/configretriever/configretriever.cpp
+++ b/config/src/tests/configretriever/configretriever.cpp
@@ -23,7 +23,6 @@ using namespace config;
 using namespace std;
 using namespace vespalib::slime;
 using namespace vespalib;
-using namespace std::chrono_literals;
 
 struct ComponentFixture {
     typedef std::shared_ptr<ComponentFixture> SP;
diff --git a/config/src/tests/failover/failover.cpp b/config/src/tests/failover/failover.cpp
index e342a477b13..bac0513eea7 100644
--- a/config/src/tests/failover/failover.cpp
+++ b/config/src/tests/failover/failover.cpp
@@ -19,7 +19,6 @@ using vespalib::Barrier;
 using namespace config::protocol::v2;
 using namespace vespalib::slime;
 using namespace vespalib;
-using namespace std::chrono_literals;
 
 namespace {
 
@@ -175,17 +174,17 @@ struct NetworkFixture {
 
 
 TimingValues testTimingValues(
-    500,  // successTimeout
-    500,  // errorTimeout
-    500,   // initialTimeout
+    500ms,  // successTimeout
+    500ms,  // errorTimeout
+    500ms,   // initialTimeout
     400ms,  // unsubscribeTimeout
-    0,     // fixedDelay
-    250,   // successDelay
-    250,   // unconfiguredDelay
-    500,   // configuredErrorDelay
+    0ms,     // fixedDelay
+    250ms,   // successDelay
+    250ms,   // unconfiguredDelay
+    500ms,   // configuredErrorDelay
     1,      // maxDelayMultiplier
-    600,  // transientDelay
-    1200); // fatalDelay
+    600ms,  // transientDelay
+    1200ms); // fatalDelay
 
 struct ConfigCheckFixture {
     std::shared_ptr<IConfigContext> ctx;
diff --git a/config/src/tests/file_subscription/file_subscription.cpp b/config/src/tests/file_subscription/file_subscription.cpp
index 2d1a8498ba5..b4a2b890bb5 100644
--- a/config/src/tests/file_subscription/file_subscription.cpp
+++ b/config/src/tests/file_subscription/file_subscription.cpp
@@ -15,7 +15,6 @@
 LOG_SETUP(".filesubscription_test");
 
 using namespace config;
-using namespace std::chrono_literals;
 
 namespace {
 
diff --git a/config/src/tests/frt/frt.cpp b/config/src/tests/frt/frt.cpp
index 0a0c3262b84..e590aebaf76 100644
--- a/config/src/tests/frt/frt.cpp
+++ b/config/src/tests/frt/frt.cpp
@@ -3,7 +3,6 @@
 #include "config-my.h"
 #include "config-bar.h"
 #include <vespa/vespalib/testkit/test_kit.h>
-#include <vespa/config/common/iconfigholder.h>
 #include <vespa/config/common/trace.h>
 #include <vespa/config/common/configdefinition.h>
 #include <vespa/config/frt/connection.h>
@@ -30,32 +29,6 @@ using namespace config::protocol::v3;
 
 namespace {
 
-    struct UpdateFixture : public IConfigHolder {
-        std::unique_ptr<ConfigUpdate> update;
-        bool notified;
-
-        UpdateFixture()
-            : update(),
-              notified(false)
-        { }
-        std::unique_ptr<ConfigUpdate> provide() override { return std::unique_ptr<ConfigUpdate>(); }
-        void handle(std::unique_ptr<ConfigUpdate> u) override { update = std::move(u); }
-        bool wait(milliseconds timeoutInMillis) override { (void) timeoutInMillis; return notified; }
-        bool poll() override { return notified; }
-        void interrupt() override { }
-
-        bool waitUntilResponse(vespalib::duration timeout)
-        {
-            vespalib::Timer timer;
-            while (timer.elapsed() < timeout) {
-                if (notified)
-                    break;
-                std::this_thread::sleep_for(100ms);
-            }
-            return notified;
-        }
-    };
-
     struct RPCFixture
     {
         std::vector<FRT_RPCRequest *> requests;
@@ -108,17 +81,9 @@ namespace {
         }
     };
 
-
-    struct MyAbortHandler : public FRT_IAbortHandler
-    {
-        bool aborted;
-        MyAbortHandler() : aborted(false) { }
-        bool HandleAbort() override { aborted = true; return true; }
-    };
-
     struct ConnectionMock : public Connection {
         int errorCode;
-        int timeout;
+        duration timeout;
         FRT_RPCRequest * ans;
         fnet::frt::StandaloneFRT server;
         FRT_Supervisor & supervisor;
@@ -128,21 +93,21 @@ namespace {
         ~ConnectionMock();
         FRT_RPCRequest * allocRPCRequest() override { return supervisor.AllocRPCRequest(); }
         void setError(int ec) override { errorCode = ec; }
-        void invoke(FRT_RPCRequest * req, double t, FRT_IRequestWait * waiter) override
+        void invoke(FRT_RPCRequest * req, duration t, FRT_IRequestWait * waiter) override
         {
-            timeout = static_cast<int>(t);
+            timeout = t;
             if (ans != nullptr)
                 waiter->RequestDone(ans);
             else
                 waiter->RequestDone(req);
         }
         const vespalib::string & getAddress() const override { return address; }
-        void setTransientDelay(int64_t delay) override { (void) delay; }
+        void setTransientDelay(duration delay) override { (void) delay; }
     };
 
     ConnectionMock::ConnectionMock(FRT_RPCRequest * answer)
         : errorCode(0),
-          timeout(0),
+          timeout(0ms),
           ans(answer),
           server(),
           supervisor(server.supervisor()),
@@ -152,7 +117,8 @@ namespace {
 
     struct FactoryMock : public ConnectionFactory {
         ConnectionMock * current;
-        FactoryMock(ConnectionMock * c) : current(c) { }
+        FactoryMock(ConnectionMock * c) noexcept : current(c) { }
+        ~FactoryMock() = default;
         Connection * getCurrent() override {
             return current;
         }
@@ -164,10 +130,10 @@ namespace {
     struct AgentResultFixture
     {
         bool notified;
-        uint64_t waitTime;
-        uint64_t timeout;
+        duration waitTime;
+        duration timeout;
         ConfigState state;
-        AgentResultFixture(uint64_t w, uint64_t t)
+        AgentResultFixture(duration w, duration t)
             : notified(false),
               waitTime(w),
               timeout(t),
@@ -185,8 +151,8 @@ namespace {
         }
 
         const ConfigState & getConfigState() const override { return result->state; }
-        uint64_t getWaitTime () const override { return result->waitTime; }
-        uint64_t getTimeout() const override { return result->timeout; }
+        duration getWaitTime () const override { return result->waitTime; }
+        duration getTimeout() const override { return result->timeout; }
         void handleResponse(const ConfigRequest & request, ConfigResponse::UP response) override
         {
             (void) request;
@@ -219,11 +185,11 @@ namespace {
         FRTSource src;
 
         FRTFixture(SourceFixture & f1)
-            : result(2000, 10000),
+            : result(2s, 10s),
               requestFactory(3, VespaVersion::fromString("1.2.3"), CompressionType::UNCOMPRESSED),
-              src(ConnectionFactory::SP(new FactoryMock(&f1.conn)),
+              src(std::make_shared<FactoryMock>(&f1.conn),
                   requestFactory,
-                  ConfigAgent::UP(new AgentFixture(&result)),
+                  std::make_unique<AgentFixture>(&result),
                   f1.key)
         { }
     };
@@ -273,7 +239,7 @@ TEST("require that v3 request is correctly initialized") {
     vespalib::string xxhash64 = "myxxhash64";
     int64_t currentGeneration = 3;
     vespalib::string hostName = "myhost";
-    int64_t timeout = 3000;
+    duration timeout = 3s;
     Trace traceIn(3);
     traceIn.trace(2, "Hei");
     FRTConfigRequestV3 v3req(&conn, key, xxhash64, currentGeneration, hostName,
@@ -300,7 +266,7 @@ TEST("require that v3 request is correctly initialized") {
     EXPECT_EQUAL(hostName, root[REQUEST_CLIENT_HOSTNAME].asString().make_string());
     EXPECT_EQUAL(currentGeneration, root[REQUEST_CURRENT_GENERATION].asLong());
     EXPECT_EQUAL(xxhash64, root[REQUEST_CONFIG_XXHASH64].asString().make_string());
-    EXPECT_EQUAL(timeout, root[REQUEST_TIMEOUT].asLong());
+    EXPECT_EQUAL(count_ms(timeout), root[REQUEST_TIMEOUT].asLong());
     EXPECT_EQUAL("LZ4", root[REQUEST_COMPRESSION_TYPE].asString().make_string());
     EXPECT_EQUAL(root[REQUEST_VESPA_VERSION].asString().make_string(), "1.2.3");
     Trace trace;
@@ -308,7 +274,7 @@ TEST("require that v3 request is correctly initialized") {
     EXPECT_TRUE(trace.shouldTrace(2));
     EXPECT_TRUE(trace.shouldTrace(3));
     EXPECT_FALSE(trace.shouldTrace(4));
-    EXPECT_EQUAL(timeout, root[REQUEST_TIMEOUT].asLong());
+    EXPECT_EQUAL(count_ms(timeout), root[REQUEST_TIMEOUT].asLong());
     ConfigDefinition def;
     def.deserialize(root[REQUEST_DEF_CONTENT]);
     EXPECT_EQUAL(origDef.asString(), def.asString());
diff --git a/config/src/tests/frtconnectionpool/frtconnectionpool.cpp b/config/src/tests/frtconnectionpool/frtconnectionpool.cpp
index 337f5953e30..c2ed60370e0 100644
--- a/config/src/tests/frtconnectionpool/frtconnectionpool.cpp
+++ b/config/src/tests/frtconnectionpool/frtconnectionpool.cpp
@@ -201,7 +201,7 @@ void Test::testSuspensionTimeout() {
     const ServerSpec spec(_sources);
     FRTConnectionPool sourcePool(spec, timingValues);
     Connection* source = sourcePool.getCurrent();
-    source->setTransientDelay(1000);
+    source->setTransientDelay(1s);
     source->setError(FRTE_RPC_CONNECTION);
     for (int i = 0; i < 9; i++) {
         EXPECT_NOT_EQUAL(source->getAddress(), sourcePool.getCurrent()->getAddress());
diff --git a/config/src/tests/subscriber/subscriber.cpp b/config/src/tests/subscriber/subscriber.cpp
index 68e211ec3f8..548e54e1d18 100644
--- a/config/src/tests/subscriber/subscriber.cpp
+++ b/config/src/tests/subscriber/subscriber.cpp
@@ -13,7 +13,6 @@
 
 using namespace config;
 using namespace vespalib;
-using namespace std::chrono_literals;
 
 namespace {
 
@@ -79,8 +78,8 @@ namespace {
 
         MyManager() : idCounter(0), numCancel(0) { }
 
-        ConfigSubscription::SP subscribe(const ConfigKey & key, milliseconds timeoutInMillis) override {
-            (void) timeoutInMillis;
+        ConfigSubscription::SP subscribe(const ConfigKey & key, vespalib::duration timeout) override {
+            (void) timeout;
             auto holder = std::make_shared<ConfigHolder>();
             _holders.push_back(holder);
 
@@ -284,9 +283,9 @@ TEST_MT_FFF("requireThatConfigIsReturnedWhenUpdatedDuringNextConfig", 2, MyManag
         verifyConfig("foo2", f3.h1->getConfig());
         verifyConfig("bar", f3.h2->getConfig());
     } else {
-        std::this_thread::sleep_for(std::chrono::milliseconds(300));
+        std::this_thread::sleep_for(300ms);
         f1.updateValue(0, createFooValue("foo2"), 2);
-        std::this_thread::sleep_for(std::chrono::milliseconds(300));
+        std::this_thread::sleep_for(300ms);
         f1.updateGeneration(1, 2);
     }
 }
@@ -332,7 +331,7 @@ TEST_MT_FFF("requireThatNextConfigIsInterruptedOnClose", 2, MyManager, APIFixtur
         ASSERT_TRUE(timer.elapsed() >= 500ms);
         ASSERT_TRUE(timer.elapsed() < 60s);
     } else {
-        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+        std::this_thread::sleep_for(1000ms);
         f3.s.close();
     }
 }
@@ -515,7 +514,7 @@ TEST_MT_FF("requireThatConfigSubscriberWaitsUntilNextConfigSucceeds", 2, MyManag
         verifyConfig("foo2", h1->getConfig()); // First update is skipped
     } else {
         TEST_BARRIER();
-        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+        std::this_thread::sleep_for(1000ms);
         f1.updateValue(0, createFooValue("foo2"), 3);
     }
 }
diff --git a/config/src/tests/subscription/subscription.cpp b/config/src/tests/subscription/subscription.cpp
index f35ea3c6cef..13eafbf876e 100644
--- a/config/src/tests/subscription/subscription.cpp
+++ b/config/src/tests/subscription/subscription.cpp
@@ -7,7 +7,6 @@
 #include <thread>
 
 using namespace config;
-using namespace std::chrono_literals;
 
 namespace {
 
@@ -79,7 +78,7 @@ TEST_MT_F("requireThatNextUpdateReturnsWhenNotified", 2, SubscriptionFixture(Con
         ASSERT_TRUE(f1.sub.nextUpdate(2, 5000ms));
         ASSERT_TRUE(timer.elapsed() > 200ms);
     } else {
-        std::this_thread::sleep_for(std::chrono::milliseconds(500));
+        std::this_thread::sleep_for(500ms);
         f1.holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(), 1, 1));
     }
 }
@@ -93,7 +92,7 @@ TEST_MT_F("requireThatNextUpdateReturnsInterrupted", 2, SubscriptionFixture(Conf
         ASSERT_TRUE(f1.sub.nextUpdate(1, 5000ms));
         ASSERT_TRUE(timer.elapsed() > 300ms);
     } else {
-        std::this_thread::sleep_for(std::chrono::milliseconds(500));
+        std::this_thread::sleep_for(500ms);
         f1.sub.close();
     }
 }
diff --git a/config/src/tests/unittest/unittest.cpp b/config/src/tests/unittest/unittest.cpp
index 207a139f31d..29a85c8395c 100644
--- a/config/src/tests/unittest/unittest.cpp
+++ b/config/src/tests/unittest/unittest.cpp
@@ -11,7 +11,6 @@
 LOG_SETUP("unittest");
 
 using namespace config;
-using namespace std::chrono_literals;
 
 namespace {
     void verifyConfig(const std::string & expected, std::unique_ptr<FooConfig> cfg)
diff --git a/config/src/vespa/config/common/configholder.cpp b/config/src/vespa/config/common/configholder.cpp
index 41c88e13b06..95fa3fecba8 100644
--- a/config/src/vespa/config/common/configholder.cpp
+++ b/config/src/vespa/config/common/configholder.cpp
@@ -32,10 +32,10 @@ ConfigHolder::handle(std::unique_ptr<ConfigUpdate> update)
 }
 
 bool
-ConfigHolder::wait(milliseconds timeoutInMillis)
+ConfigHolder::wait(vespalib::duration timeout)
 {
     std::unique_lock guard(_lock);
-    return static_cast<bool>(_current) || (_cond.wait_for(guard, timeoutInMillis) == std::cv_status::no_timeout);
+    return static_cast<bool>(_current) || (_cond.wait_for(guard, timeout) == std::cv_status::no_timeout);
 }
 
 bool
diff --git a/config/src/vespa/config/common/configholder.h b/config/src/vespa/config/common/configholder.h
index c9b5a37765a..1cbbb383f98 100644
--- a/config/src/vespa/config/common/configholder.h
+++ b/config/src/vespa/config/common/configholder.h
@@ -18,7 +18,7 @@ public:
 
     std::unique_ptr<ConfigUpdate> provide() override;
     void handle(std::unique_ptr<ConfigUpdate> update) override;
-    bool wait(milliseconds timeoutInMillis) override;
+    bool wait(vespalib::duration timeoutI) override;
     bool poll() override;
     void interrupt() override;
 public:
diff --git a/config/src/vespa/config/common/configmanager.cpp b/config/src/vespa/config/common/configmanager.cpp
index d982a77bd1c..983cccb0b0b 100644
--- a/config/src/vespa/config/common/configmanager.cpp
+++ b/config/src/vespa/config/common/configmanager.cpp
@@ -8,8 +8,6 @@
 #include <vespa/log/log.h>
 LOG_SETUP(".config.common.configmanager");
 
-using namespace std::chrono_literals;
-using namespace std::chrono;
 
 namespace config {
 
@@ -24,7 +22,7 @@ ConfigManager::ConfigManager(SourceFactory::UP sourceFactory, int64_t initialGen
 ConfigManager::~ConfigManager() = default;
 
 ConfigSubscription::SP
-ConfigManager::subscribe(const ConfigKey & key, milliseconds timeoutInMillis)
+ConfigManager::subscribe(const ConfigKey & key, vespalib::duration timeout)
 {
     LOG(debug, "subscribing on def %s, configid %s", key.getDefName().c_str(), key.getConfigId().c_str());
 
@@ -37,8 +35,8 @@ ConfigManager::subscribe(const ConfigKey & key, milliseconds timeoutInMillis)
     source->getConfig();
     ConfigSubscription::SP subscription(new ConfigSubscription(id, key, holder, std::move(source)));
 
-    steady_clock::time_point endTime = steady_clock::now() + timeoutInMillis;
-    while (steady_clock::now() < endTime) {
+    vespalib::steady_time endTime = vespalib::steady_clock::now() + timeout;
+    while (vespalib::steady_clock::now() < endTime) {
         if (holder->poll())
             break;
         std::this_thread::sleep_for(10ms);
diff --git a/config/src/vespa/config/common/configmanager.h b/config/src/vespa/config/common/configmanager.h
index 4dde9f0d448..09d263d9c25 100644
--- a/config/src/vespa/config/common/configmanager.h
+++ b/config/src/vespa/config/common/configmanager.h
@@ -24,13 +24,8 @@ public:
     ConfigManager(SourceFactory::UP sourceFactory, int64_t initialGeneration);
     ~ConfigManager() override;
 
-    // Implements IConfigManager
-    ConfigSubscription::SP subscribe(const ConfigKey & key, milliseconds timeoutInMillis) override;
-
-    // Implements IConfigManager
+    ConfigSubscription::SP subscribe(const ConfigKey & key, vespalib::duration timeout) override;
     void unsubscribe(const ConfigSubscription::SP & subscription) override;
-
-    // Implements IConfigManager
     void reload(int64_t generation) override;
 
 private:
diff --git a/config/src/vespa/config/common/configrequest.h b/config/src/vespa/config/common/configrequest.h
index 1ef5db30cad..4331b204d72 100644
--- a/config/src/vespa/config/common/configrequest.h
+++ b/config/src/vespa/config/common/configrequest.h
@@ -16,14 +16,11 @@ struct ConfigState;
  */
 
 class ConfigRequest {
-private:
-    ConfigRequest& operator=(const ConfigRequest&);
-
 public:
     typedef std::unique_ptr<ConfigRequest> UP;
 
-    ConfigRequest() { }
-    virtual ~ConfigRequest() { }
+    ConfigRequest& operator=(const ConfigRequest&) = delete;
+    virtual ~ConfigRequest() = default;
     virtual const ConfigKey & getKey() const = 0;
     /** Abort a request. */
     virtual bool abort() = 0;
diff --git a/config/src/vespa/config/common/subscribehandler.h b/config/src/vespa/config/common/subscribehandler.h
index da8bdfadcf2..a522c33ccfa 100644
--- a/config/src/vespa/config/common/subscribehandler.h
+++ b/config/src/vespa/config/common/subscribehandler.h
@@ -2,6 +2,7 @@
 #pragma once
 
 #include "configkey.h"
+#include <vespa/vespalib/util/time.h>
 
 namespace config {
 
@@ -9,17 +10,16 @@ class ConfigSubscription;
 
 struct SubscribeHandler
 {
-    using milliseconds = std::chrono::milliseconds;
     /**
      * Subscribes to a spesific config given by a subscription.
      * If the subscribe call is successful, the callback handler will be called
      * with the new config.
      *
      * @param key the subscription key to subscribe to.
-     * @param timeoutInMillis the timeout of the subscribe call.
+     * @param timeout the timeout of the subscribe call.
      * @return subscription object containing data relevant to client
      */
-    virtual std::shared_ptr<ConfigSubscription> subscribe(const ConfigKey & key, milliseconds timeoutInMillis) = 0;
+    virtual std::shared_ptr<ConfigSubscription> subscribe(const ConfigKey & key, vespalib::duration timeout) = 0;
     virtual ~SubscribeHandler() = default;
 };
 
diff --git a/config/src/vespa/config/common/timingvalues.cpp b/config/src/vespa/config/common/timingvalues.cpp
index 9133091b80a..67f9e578396 100644
--- a/config/src/vespa/config/common/timingvalues.cpp
+++ b/config/src/vespa/config/common/timingvalues.cpp
@@ -4,38 +4,37 @@
 
 namespace config {
 
-using std::chrono::milliseconds;
 
-const milliseconds DEFAULT_NEXTCONFIG_TIMEOUT(55000);
-const milliseconds DEFAULT_SUBSCRIBE_TIMEOUT(55000);
-const milliseconds DEFAULT_GETCONFIGS_TIMEOUT(55000);
+const vespalib::duration DEFAULT_NEXTCONFIG_TIMEOUT(55s);
+const vespalib::duration DEFAULT_SUBSCRIBE_TIMEOUT(55s);
+const vespalib::duration DEFAULT_GETCONFIGS_TIMEOUT(55s);
 
 TimingValues::TimingValues()
-    : successTimeout(600000),
-      errorTimeout(25000),
-      initialTimeout(15000),
+    : successTimeout(600s),
+      errorTimeout(25s),
+      initialTimeout(15s),
       subscribeTimeout(DEFAULT_SUBSCRIBE_TIMEOUT),
-      fixedDelay(5000),
-      successDelay(250),
-      unconfiguredDelay(1000),
-      configuredErrorDelay(15000),
+      fixedDelay(5s),
+      successDelay(250ms),
+      unconfiguredDelay(1s),
+      configuredErrorDelay(15s),
       maxDelayMultiplier(10),
-      transientDelay(10000),
-      fatalDelay(60000)
+      transientDelay(60s),
+      fatalDelay(60s)
 { }
 
 
-TimingValues::TimingValues(uint64_t initSuccessTimeout,
-                           uint64_t initErrorTimeout,
-                           uint64_t initInitialTimeout,
-                           milliseconds initSubscribeTimeout,
-                           uint64_t initFixedDelay,
-                           uint64_t initSuccessDelay,
-                           uint64_t initUnconfiguredDelay,
-                           uint64_t initConfiguredErrorDelay,
+TimingValues::TimingValues(duration initSuccessTimeout,
+                           duration initErrorTimeout,
+                           duration initInitialTimeout,
+                           duration initSubscribeTimeout,
+                           duration initFixedDelay,
+                           duration initSuccessDelay,
+                           duration initUnconfiguredDelay,
+                           duration initConfiguredErrorDelay,
                            unsigned int initMaxDelayMultiplier,
-                           uint64_t initTransientDelay,
-                           uint64_t initFatalDelay)
+                           duration initTransientDelay,
+                           duration initFatalDelay)
     : successTimeout(initSuccessTimeout),
       errorTimeout(initErrorTimeout),
       initialTimeout(initInitialTimeout),
diff --git a/config/src/vespa/config/common/timingvalues.h b/config/src/vespa/config/common/timingvalues.h
index b6a8c8a6cdc..61d7d4ed9dc 100644
--- a/config/src/vespa/config/common/timingvalues.h
+++ b/config/src/vespa/config/common/timingvalues.h
@@ -2,45 +2,44 @@
 
 #pragma once
 
-#include <cstdint>
-#include <chrono>
+#include <vespa/vespalib/util/time.h>
 
 namespace config {
 
-extern const std::chrono::milliseconds DEFAULT_NEXTCONFIG_TIMEOUT;
-extern const std::chrono::milliseconds DEFAULT_SUBSCRIBE_TIMEOUT;
-extern const std::chrono::milliseconds DEFAULT_GETCONFIGS_TIMEOUT;
+extern const vespalib::duration DEFAULT_NEXTCONFIG_TIMEOUT;
+extern const vespalib::duration DEFAULT_SUBSCRIBE_TIMEOUT;
+extern const vespalib::duration DEFAULT_GETCONFIGS_TIMEOUT;
 
 
 struct TimingValues
 {
-    using milliseconds = std::chrono::milliseconds;
-    uint64_t successTimeout;        // Timeout when previous config request was a success.
-    uint64_t errorTimeout;          // Timeout when previous config request was an error.
-    uint64_t initialTimeout;        // Timeout used when requesting config for the first time.
-    milliseconds subscribeTimeout;    // Timeout used to find out when to give up unsubscribe.
-
-    uint64_t fixedDelay;            // Fixed delay between config requests.
-    uint64_t successDelay;          // Delay if until next request after successful getConfig.
-    uint64_t unconfiguredDelay;     // Delay if failed and client not yet configured.
-    uint64_t configuredErrorDelay;  // Delay if failed but client has gotten config for the first time earlier.
+    using duration = vespalib::duration;
+    duration successTimeout;        // Timeout when previous config request was a success.
+    duration errorTimeout;          // Timeout when previous config request was an error.
+    duration initialTimeout;        // Timeout used when requesting config for the first time.
+    duration subscribeTimeout;    // Timeout used to find out when to give up unsubscribe.
+
+    duration fixedDelay;            // Fixed delay between config requests.
+    duration successDelay;          // Delay if until next request after successful getConfig.
+    duration unconfiguredDelay;     // Delay if failed and client not yet configured.
+    duration configuredErrorDelay;  // Delay if failed but client has gotten config for the first time earlier.
     unsigned int maxDelayMultiplier;        // Max multiplier when trying to get config.
 
-    uint64_t transientDelay;        // Delay between connection reuse if transient error.
-    uint64_t fatalDelay;            // Delay between connection reuse if fatal error.
+    duration transientDelay;        // Delay between connection reuse if transient error.
+    duration fatalDelay;            // Delay between connection reuse if fatal error.
 
     TimingValues();
-    TimingValues(uint64_t initSuccessTimeout,
-                 uint64_t initerrorTimeout,
-                 uint64_t initInitialTimeout,
-                 milliseconds initSubscribeTimeout,
-                 uint64_t initFixedDelay,
-                 uint64_t initSuccessDelay,
-                 uint64_t initUnconfiguredDelay,
-                 uint64_t initConfiguredErrorDelay,
+    TimingValues(duration initSuccessTimeout,
+                 duration initerrorTimeout,
+                 duration initInitialTimeout,
+                 duration initSubscribeTimeout,
+                 duration initFixedDelay,
+                 duration initSuccessDelay,
+                 duration initUnconfiguredDelay,
+                 duration initConfiguredErrorDelay,
                  unsigned int initMaxDelayMultiplier,
-                 uint64_t initTransientDelay,
-                 uint64_t initFatalDelay);
+                 duration initTransientDelay,
+                 duration initFatalDelay);
 };
 
 }
diff --git a/config/src/vespa/config/common/waitable.h b/config/src/vespa/config/common/waitable.h
index 9c88bdccf77..e15d1a0ace7 100644
--- a/config/src/vespa/config/common/waitable.h
+++ b/config/src/vespa/config/common/waitable.h
@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include <chrono>
+#include <vespa/vespalib/util/time.h>
 
 namespace config {
 
@@ -11,9 +11,8 @@ namespace config {
  */
 struct Waitable
 {
-    using milliseconds = std::chrono::milliseconds;
-    virtual bool wait(milliseconds) = 0;
-    virtual ~Waitable() {}
+    virtual bool wait(vespalib::duration timeout) = 0;
+    virtual ~Waitable() = default;
 };
 
 } // namespace config
diff --git a/config/src/vespa/config/frt/connection.h b/config/src/vespa/config/frt/connection.h
index 841549e0ec6..ea4863123fc 100644
--- a/config/src/vespa/config/frt/connection.h
+++ b/config/src/vespa/config/frt/connection.h
@@ -2,6 +2,8 @@
 #pragma once
 
 #include <vespa/vespalib/stllike/string.h>
+#include <vespa/vespalib/util/time.h>
+
 class FRT_RPCRequest;
 class FRT_IRequestWait;
 
@@ -9,12 +11,13 @@ namespace config {
 
 class Connection {
 public:
+    using duration = vespalib::duration;
     virtual FRT_RPCRequest * allocRPCRequest() = 0;
     virtual void setError(int errorCode) = 0;
-    virtual void invoke(FRT_RPCRequest * req, double timeout, FRT_IRequestWait * waiter) = 0;
+    virtual void invoke(FRT_RPCRequest * req, duration timeout, FRT_IRequestWait * waiter) = 0;
     virtual const vespalib::string & getAddress() const = 0;
-    virtual void setTransientDelay(int64_t delay) = 0;
-    virtual ~Connection() { }
+    virtual void setTransientDelay(duration delay) = 0;
+    virtual ~Connection() = default;
 };
 
 }
diff --git a/config/src/vespa/config/frt/frtconfigagent.cpp b/config/src/vespa/config/frt/frtconfigagent.cpp
index b6014a1d668..9689c5ee2a1 100644
--- a/config/src/vespa/config/frt/frtconfigagent.cpp
+++ b/config/src/vespa/config/frt/frtconfigagent.cpp
@@ -76,6 +76,8 @@ FRTConfigAgent::handleUpdatedGeneration(const ConfigKey & key, const ConfigState
     _numConfigured++;
 }
 
+using vespalib::to_s;
+
 void
 FRTConfigAgent::handleErrorResponse(const ConfigRequest & request, ConfigResponse::UP response)
 {
@@ -84,19 +86,20 @@ FRTConfigAgent::handleErrorResponse(const ConfigRequest & request, ConfigRespons
     setWaitTime(_numConfigured > 0 ? _timingValues.configuredErrorDelay : _timingValues.unconfiguredDelay, multiplier);
     _nextTimeout = _timingValues.errorTimeout;
     const ConfigKey & key(request.getKey());
-    LOG(info, "Error response or no response from config server (key: %s) (errcode=%d, validresponse:%d), trying again in %" PRIu64 " milliseconds", key.toString().c_str(), response->errorCode(), response->hasValidResponse() ? 1 : 0, _waitTime);
+    LOG(info, "Error response or no response from config server (key: %s) (errcode=%d, validresponse:%d), trying again in %f seconds",
+        key.toString().c_str(), response->errorCode(), response->hasValidResponse() ? 1 : 0, to_s(_waitTime));
 }
 
 void
-FRTConfigAgent::setWaitTime(uint64_t delay, int multiplier)
+FRTConfigAgent::setWaitTime(duration delay, int multiplier)
 {
-    uint64_t prevWait = _waitTime;
+    duration prevWait = _waitTime;
     _waitTime = _timingValues.fixedDelay + (multiplier * delay);
-    LOG(spam, "Adjusting waittime from %" PRIu64 " to %" PRIu64, prevWait, _waitTime);
+    LOG(spam, "Adjusting waittime from %f to %f", to_s(prevWait), to_s(_waitTime));
 }
 
-uint64_t FRTConfigAgent::getTimeout() const { return _nextTimeout; }
-uint64_t FRTConfigAgent::getWaitTime() const { return _waitTime; }
+vespalib::duration FRTConfigAgent::getTimeout() const { return _nextTimeout; }
+vespalib::duration FRTConfigAgent::getWaitTime() const { return _waitTime; }
 const ConfigState & FRTConfigAgent::getConfigState() const { return _configState; }
 
 }
diff --git a/config/src/vespa/config/frt/frtconfigagent.h b/config/src/vespa/config/frt/frtconfigagent.h
index c69f4204168..a2a91320d0e 100644
--- a/config/src/vespa/config/frt/frtconfigagent.h
+++ b/config/src/vespa/config/frt/frtconfigagent.h
@@ -3,22 +3,24 @@
 
 #include <vespa/config/common/configstate.h>
 #include <vespa/config/common/timingvalues.h>
-#include <vespa/config/common/configresponse.h>
-#include <vespa/config/common/configrequest.h>
 #include <vespa/config/common/configvalue.h>
 
 namespace config {
 
 class IConfigHolder;
+class ConfigResponse;
+class ConfigRequest;
+class ConfigKey;
 
 class ConfigAgent
 {
 public:
-    typedef std::unique_ptr<ConfigAgent> UP;
-    virtual void handleResponse(const ConfigRequest & request, ConfigResponse::UP response) = 0;
+    using UP = std::unique_ptr<ConfigAgent>;
+    using duration = vespalib::duration;
+    virtual void handleResponse(const ConfigRequest & request, std::unique_ptr<ConfigResponse> response) = 0;
 
-    virtual uint64_t getTimeout() const = 0;
-    virtual uint64_t getWaitTime() const = 0;
+    virtual duration getTimeout() const = 0;
+    virtual duration getWaitTime() const = 0;
     virtual const ConfigState & getConfigState() const = 0;
 
     virtual ~ConfigAgent() = default;
@@ -29,24 +31,24 @@ class FRTConfigAgent : public ConfigAgent
 public:
     FRTConfigAgent(std::shared_ptr<IConfigHolder> holder, const TimingValues & timingValues);
     ~FRTConfigAgent() override;
-    void handleResponse(const ConfigRequest & request, ConfigResponse::UP response) override;
-    uint64_t getTimeout() const override;
-    uint64_t getWaitTime() const override;
+    void handleResponse(const ConfigRequest & request, std::unique_ptr<ConfigResponse> response) override;
+    duration getTimeout() const override;
+    duration getWaitTime() const override;
     const ConfigState & getConfigState() const override;
 private:
     void handleUpdatedGeneration(const ConfigKey & key, const ConfigState & newState, const ConfigValue & configValue);
-    void handleOKResponse(const ConfigRequest & request, ConfigResponse::UP response);
-    void handleErrorResponse(const ConfigRequest & request, ConfigResponse::UP response);
-    void setWaitTime(uint64_t delay, int multiplier);
+    void handleOKResponse(const ConfigRequest & request, std::unique_ptr<ConfigResponse> response);
+    void handleErrorResponse(const ConfigRequest & request, std::unique_ptr<ConfigResponse> response);
+    void setWaitTime(duration delay, int multiplier);
 
     std::shared_ptr<IConfigHolder> _holder;
     const TimingValues _timingValues;
     ConfigState        _configState;
     ConfigValue        _latest;
-    uint64_t           _waitTime;
+    duration           _waitTime;
     uint64_t           _numConfigured;
     unsigned int       _failedRequests;
-    uint64_t           _nextTimeout;
+    duration           _nextTimeout;
 };
 
 }
diff --git a/config/src/vespa/config/frt/frtconfigrequestfactory.cpp b/config/src/vespa/config/frt/frtconfigrequestfactory.cpp
index 01a9fb40301..dd70407183a 100644
--- a/config/src/vespa/config/frt/frtconfigrequestfactory.cpp
+++ b/config/src/vespa/config/frt/frtconfigrequestfactory.cpp
@@ -22,7 +22,7 @@ FRTConfigRequestFactory::~FRTConfigRequestFactory() = default;
 
 FRTConfigRequest::UP
 FRTConfigRequestFactory::createConfigRequest(const ConfigKey & key, Connection * connection,
-                                             const ConfigState & state, int64_t serverTimeout) const
+                                             const ConfigState & state, vespalib::duration serverTimeout) const
 {
     return make_unique<FRTConfigRequestV3>(connection, key, state.xxhash64, state.generation, _hostName,
                                            serverTimeout, Trace(_traceLevel), _vespaVersion, _compressionType);
diff --git a/config/src/vespa/config/frt/frtconfigrequestfactory.h b/config/src/vespa/config/frt/frtconfigrequestfactory.h
index 96ecdc0af2a..ac6ad30ac97 100644
--- a/config/src/vespa/config/frt/frtconfigrequestfactory.h
+++ b/config/src/vespa/config/frt/frtconfigrequestfactory.h
@@ -21,11 +21,11 @@ public:
     FRTConfigRequestFactory(int traceLevel, const VespaVersion & vespaVersion, const CompressionType & compressionType);
     ~FRTConfigRequestFactory();
 
-    FRTConfigRequest::UP createConfigRequest(const ConfigKey & key, Connection * connection, const ConfigState & state, int64_t serverTimeout) const;
+    FRTConfigRequest::UP createConfigRequest(const ConfigKey & key, Connection * connection, const ConfigState & state, vespalib::duration serverTimeout) const;
 private:
-    const int _traceLevel;
-    const VespaVersion _vespaVersion;
-    vespalib::string _hostName;
+    const int             _traceLevel;
+    const VespaVersion    _vespaVersion;
+    vespalib::string      _hostName;
     const CompressionType _compressionType;
 };
 
diff --git a/config/src/vespa/config/frt/frtconfigrequestv3.cpp b/config/src/vespa/config/frt/frtconfigrequestv3.cpp
index bcea529c802..8504e0ee122 100644
--- a/config/src/vespa/config/frt/frtconfigrequestv3.cpp
+++ b/config/src/vespa/config/frt/frtconfigrequestv3.cpp
@@ -14,7 +14,7 @@ FRTConfigRequestV3::FRTConfigRequestV3(Connection * connection,
                                        const vespalib::string & configXxhash64,
                                        int64_t currentGeneration,
                                        const vespalib::string & hostName,
-                                       int64_t serverTimeout,
+                                       vespalib::duration serverTimeout,
                                        const Trace & trace,
                                        const VespaVersion & vespaVersion,
                                        const CompressionType & compressionType)
diff --git a/config/src/vespa/config/frt/frtconfigrequestv3.h b/config/src/vespa/config/frt/frtconfigrequestv3.h
index 32f8b7203c3..5e74d88d284 100644
--- a/config/src/vespa/config/frt/frtconfigrequestv3.h
+++ b/config/src/vespa/config/frt/frtconfigrequestv3.h
@@ -20,7 +20,7 @@ public:
                        const vespalib::string & configXxhash64,
                        int64_t currentGeneration,
                        const vespalib::string & hostName,
-                       int64_t serverTimeout,
+                       duration serverTimeout,
                        const Trace & trace,
                        const VespaVersion & vespaVersion,
                        const CompressionType & compressionType);
diff --git a/config/src/vespa/config/frt/frtconnection.cpp b/config/src/vespa/config/frt/frtconnection.cpp
index 5ef1e43d1fe..93a5867b180 100644
--- a/config/src/vespa/config/frt/frtconnection.cpp
+++ b/config/src/vespa/config/frt/frtconnection.cpp
@@ -16,8 +16,8 @@ FRTConnection::FRTConnection(const vespalib::string& address, FRT_Supervisor& su
     : _address(address),
       _supervisor(supervisor),
       _target(0),
-      _suspendedUntil(0),
-      _suspendWarned(0),
+      _suspendedUntil(),
+      _suspendWarned(),
       _transientFailures(0),
       _fatalFailures(0),
       _transientDelay(timingValues.transientDelay),
@@ -46,9 +46,9 @@ FRTConnection::getTarget()
 }
 
 void
-FRTConnection::invoke(FRT_RPCRequest * req, double timeout, FRT_IRequestWait * waiter)
+FRTConnection::invoke(FRT_RPCRequest * req, duration timeout, FRT_IRequestWait * waiter)
 {
-    getTarget()->InvokeAsync(req, timeout, waiter);
+    getTarget()->InvokeAsync(req, vespalib::to_s(timeout), waiter);
 }
 
 void
@@ -79,16 +79,16 @@ void FRTConnection::setSuccess()
 {
     _transientFailures = 0;
     _fatalFailures = 0;
-    _suspendedUntil = 0;
+    _suspendedUntil = system_time(duration::zero());
 }
 
 void FRTConnection::calculateSuspension(ErrorType type)
 {
-    int64_t delay = 0;
+    duration delay = duration::zero();
     switch(type) {
     case TRANSIENT:
         _transientFailures.fetch_add(1);
-        delay = _transientFailures * getTransientDelay();
+        delay = _transientFailures.load(std::memory_order_relaxed) * getTransientDelay();
         if (delay > getMaxTransientDelay()) {
             delay = getMaxTransientDelay();
         }
@@ -96,21 +96,16 @@ void FRTConnection::calculateSuspension(ErrorType type)
         break;
     case FATAL:
         _fatalFailures.fetch_add(1);
-        delay = _fatalFailures * getFatalDelay();
+        delay = _fatalFailures.load(std::memory_order_relaxed) * getFatalDelay();
         if (delay > getMaxFatalDelay()) {
             delay = getMaxFatalDelay();
         }
         break;
     }
-    int64_t now = milliSecsSinceEpoch();
+    system_time now = system_clock::now();
     _suspendedUntil = now + delay;
-    if (_suspendWarned < (now - 5000)) {
-        char date[32];
-        struct tm* timeinfo;
-        time_t suspendedSeconds = _suspendedUntil / 1000;
-        timeinfo = gmtime(&suspendedSeconds);
-        strftime(date, 32, "%Y-%m-%d %H:%M:%S %Z", timeinfo);
-        LOG(warning, "FRT Connection %s suspended until %s", _address.c_str(), date);
+    if (_suspendWarned < (now - 5s)) {
+        LOG(warning, "FRT Connection %s suspended until %s", _address.c_str(), vespalib::to_string(_suspendedUntil).c_str());
         _suspendWarned = now;
     }
 }
@@ -120,10 +115,4 @@ FRTConnection::allocRPCRequest() {
     return _supervisor.AllocRPCRequest();
 }
 
-using namespace std::chrono;
-int64_t
-FRTConnection::milliSecsSinceEpoch() {
-    return duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
-}
-
 }
diff --git a/config/src/vespa/config/frt/frtconnection.h b/config/src/vespa/config/frt/frtconnection.h
index 334127117ea..0e491d61bbf 100644
--- a/config/src/vespa/config/frt/frtconnection.h
+++ b/config/src/vespa/config/frt/frtconnection.h
@@ -12,20 +12,16 @@ class FRT_Target;
 namespace config {
 
 class FRTConnection : public Connection {
-
 private:
-    FRTConnection(const FRTConnection&);
-    FRTConnection& operator=(const FRTConnection&);
-
     const vespalib::string _address;
-    FRT_Supervisor& _supervisor;
-    FRT_Target* _target;
-    int64_t _suspendedUntil;
-    int64_t _suspendWarned;
-    std::atomic<int> _transientFailures;
-    std::atomic<int> _fatalFailures;
-    int64_t _transientDelay;
-    int64_t _fatalDelay;
+    FRT_Supervisor&       _supervisor;
+    FRT_Target*           _target;
+    vespalib::system_time _suspendedUntil;
+    vespalib::system_time _suspendWarned;
+    std::atomic<int>      _transientFailures;
+    std::atomic<int>      _fatalFailures;
+    duration              _transientDelay;
+    duration              _fatalDelay;
 
     FRT_Target * getTarget();
 
@@ -34,21 +30,22 @@ public:
     enum ErrorType { TRANSIENT, FATAL };
 
     FRTConnection(const vespalib::string & address, FRT_Supervisor & supervisor, const TimingValues & timingValues);
+    FRTConnection(const FRTConnection&) = delete;
+    FRTConnection& operator=(const FRTConnection&) = delete;
     ~FRTConnection() override;
 
     FRT_RPCRequest * allocRPCRequest() override;
-    void invoke(FRT_RPCRequest * req, double timeout, FRT_IRequestWait * waiter) override;
+    void invoke(FRT_RPCRequest * req, duration timeout, FRT_IRequestWait * waiter) override;
     const vespalib::string & getAddress() const override { return _address; }
-    int64_t getSuspendedUntil() { return _suspendedUntil; }
+    vespalib::system_time getSuspendedUntil() { return _suspendedUntil; }
     void setError(int errorCode) override;
     void setSuccess();
     void calculateSuspension(ErrorType type);
-    int64_t getTransientDelay() { return _transientDelay; }
-    int64_t getMaxTransientDelay() { return getTransientDelay() * 6; }
-    void setTransientDelay(int64_t delay) override { _transientDelay = delay; }
-    int64_t getFatalDelay() { return _fatalDelay; }
-    int64_t getMaxFatalDelay() { return getFatalDelay() * 6; }
-    static int64_t milliSecsSinceEpoch();
+    duration getTransientDelay() { return _transientDelay; }
+    duration getMaxTransientDelay() { return getTransientDelay() * 6; }
+    void setTransientDelay(duration delay) override { _transientDelay = delay; }
+    duration getFatalDelay() { return _fatalDelay; }
+    duration getMaxFatalDelay() { return getFatalDelay() * 6; }
 };
 
 } // namespace config
diff --git a/config/src/vespa/config/frt/frtconnectionpool.cpp b/config/src/vespa/config/frt/frtconnectionpool.cpp
index 58de86793fb..629baf67cf8 100644
--- a/config/src/vespa/config/frt/frtconnectionpool.cpp
+++ b/config/src/vespa/config/frt/frtconnectionpool.cpp
@@ -107,8 +107,7 @@ FRTConnectionPool::getReadySources() const
     std::vector<FRTConnection*> readySources;
     for (const auto & entry : _connections) {
         FRTConnection* source = entry.second.get();
-        int64_t tnow = FRTConnection::milliSecsSinceEpoch();
-        int64_t timestamp = tnow;
+        vespalib::system_time timestamp = vespalib::system_clock::now();
         if (source->getSuspendedUntil() < timestamp) {
             readySources.push_back(source);
         }
@@ -122,8 +121,7 @@ FRTConnectionPool::getSuspendedSources() const
     std::vector<FRTConnection*> suspendedSources;
     for (const auto & entry : _connections) {
         FRTConnection* source = entry.second.get();
-        int64_t tnow = FRTConnection::milliSecsSinceEpoch();
-        int64_t timestamp = tnow;
+        vespalib::system_time timestamp = vespalib::system_clock::now();
         if (source->getSuspendedUntil() >= timestamp) {
             suspendedSources.push_back(source);
         }
diff --git a/config/src/vespa/config/frt/frtsource.cpp b/config/src/vespa/config/frt/frtsource.cpp
index 8fe424dbf57..edea25e9aa7 100644
--- a/config/src/vespa/config/frt/frtsource.cpp
+++ b/config/src/vespa/config/frt/frtsource.cpp
@@ -32,8 +32,8 @@ FRTSource::FRTSource(const ConnectionFactory::SP & connectionFactory, const FRTC
       _agent(std::move(agent)),
       _currentRequest(),
       _key(key),
-      _task(std::make_unique<GetConfigTask>(_connectionFactory->getScheduler(), this)),
       _lock(),
+      _task(std::make_unique<GetConfigTask>(_connectionFactory->getScheduler(), this)),
       _closed(false)
 {
     LOG(spam, "New source!");
@@ -48,8 +48,8 @@ FRTSource::~FRTSource()
 void
 FRTSource::getConfig()
 {
-    int64_t serverTimeout = _agent->getTimeout();
-    double clientTimeout = (serverTimeout / 1000.0) + 5.0; // The additional 5 seconds is the time allowed for the server to respond after serverTimeout has elapsed.
+    vespalib::duration serverTimeout = _agent->getTimeout();
+    vespalib::duration clientTimeout = serverTimeout + 5s; // The additional 5 seconds is the time allowed for the server to respond after serverTimeout has elapsed.
     Connection * connection = _connectionFactory->getCurrent();
     if (connection == nullptr) {
         LOG(warning, "No connection available - bad config ?");
@@ -110,7 +110,7 @@ FRTSource::scheduleNextGetConfig()
     std::lock_guard guard(_lock);
     if (_closed)
         return;
-    double sec = _agent->getWaitTime() / 1000.0;
+    double sec = vespalib::to_s(_agent->getWaitTime());
     LOG(debug, "Scheduling task in %f seconds", sec);
     _task->Schedule(sec);
     LOG(debug, "Done scheduling task");
@@ -122,10 +122,4 @@ FRTSource::reload(int64_t generation)
     (void) generation;
 }
 
-const FRTConfigRequest &
-FRTSource::getCurrentRequest() const
-{
-    return *_currentRequest;
-}
-
 } // namespace config
diff --git a/config/src/vespa/config/frt/frtsource.h b/config/src/vespa/config/frt/frtsource.h
index 993b8b3acda..a53797dc331 100644
--- a/config/src/vespa/config/frt/frtsource.h
+++ b/config/src/vespa/config/frt/frtsource.h
@@ -25,21 +25,18 @@ public:
     void close() override;
     void reload(int64_t generation) override;
     void getConfig() override;
-
-    const FRTConfigRequest & getCurrentRequest() const;
-
 private:
     void scheduleNextGetConfig();
 
-    ConnectionFactory::SP _connectionFactory;
+    ConnectionFactory::SP           _connectionFactory;
     const FRTConfigRequestFactory & _requestFactory;
-    ConfigAgent::UP _agent;
-    FRTConfigRequest::UP _currentRequest;
-    const ConfigKey _key;
+    ConfigAgent::UP                 _agent;
+    FRTConfigRequest::UP            _currentRequest;
+    const ConfigKey                 _key;
 
-    std::unique_ptr<FNET_Task> _task;
-    std::mutex _lock; // Protects _task and _closed
-    bool _closed;
+    std::mutex                      _lock; // Protects _task and _closed
+    std::unique_ptr<FNET_Task>      _task;
+    bool                            _closed;
 };
 
 } // namespace config
diff --git a/config/src/vespa/config/frt/slimeconfigrequest.cpp b/config/src/vespa/config/frt/slimeconfigrequest.cpp
index 80a05bbc2f9..6f83840f13a 100644
--- a/config/src/vespa/config/frt/slimeconfigrequest.cpp
+++ b/config/src/vespa/config/frt/slimeconfigrequest.cpp
@@ -19,14 +19,12 @@ using namespace config::protocol::v3;
 
 namespace config {
 
-const vespalib::string SlimeConfigRequest::REQUEST_TYPES = "s";
-
 SlimeConfigRequest::SlimeConfigRequest(Connection * connection,
                                        const ConfigKey & key,
                                        const vespalib::string & configXxhash64,
                                        int64_t currentGeneration,
                                        const vespalib::string & hostName,
-                                       int64_t serverTimeout,
+                                       duration serverTimeout,
                                        const Trace & trace,
                                        const VespaVersion & vespaVersion,
                                        int64_t protocolVersion,
@@ -40,6 +38,8 @@ SlimeConfigRequest::SlimeConfigRequest(Connection * connection,
     _parameters.AddString(createJsonFromSlime(_data).c_str());
 }
 
+SlimeConfigRequest::~SlimeConfigRequest() = default;
+
 bool
 SlimeConfigRequest::verifyState(const ConfigState & state) const
 {
@@ -52,7 +52,7 @@ SlimeConfigRequest::populateSlimeRequest(const ConfigKey & key,
                                          const vespalib::string & configXxhash64,
                                          int64_t currentGeneration,
                                          const vespalib::string & hostName,
-                                         int64_t serverTimeout,
+                                         duration serverTimeout,
                                          const Trace & trace,
                                          const VespaVersion & vespaVersion,
                                          int64_t protocolVersion,
@@ -69,7 +69,7 @@ SlimeConfigRequest::populateSlimeRequest(const ConfigKey & key,
     root.setString(REQUEST_CLIENT_HOSTNAME, Memory(hostName));
     root.setString(REQUEST_CONFIG_XXHASH64, Memory(configXxhash64));
     root.setLong(REQUEST_CURRENT_GENERATION, currentGeneration);
-    root.setLong(REQUEST_TIMEOUT, serverTimeout);
+    root.setLong(REQUEST_TIMEOUT, vespalib::count_ms(serverTimeout));
     trace.serialize(root.setObject(REQUEST_TRACE));
     root.setString(REQUEST_COMPRESSION_TYPE, Memory(compressionTypeToString(compressionType)));
     root.setString(REQUEST_VESPA_VERSION, Memory(vespaVersion.toString()));
diff --git a/config/src/vespa/config/frt/slimeconfigrequest.h b/config/src/vespa/config/frt/slimeconfigrequest.h
index a0654ec9da1..c17eab2f2bc 100644
--- a/config/src/vespa/config/frt/slimeconfigrequest.h
+++ b/config/src/vespa/config/frt/slimeconfigrequest.h
@@ -4,6 +4,8 @@
 #include "frtconfigrequest.h"
 #include "protocol.h"
 #include <vespa/vespalib/data/slime/slime.h>
+#include <vespa/vespalib/util/time.h>
+
 
 class FRT_Values;
 class FRT_RPCRequest;
@@ -17,18 +19,19 @@ struct VespaVersion;
 
 class SlimeConfigRequest : public FRTConfigRequest {
 public:
+    using duration = vespalib::duration;
     SlimeConfigRequest(Connection * connection,
                        const ConfigKey & key,
                        const vespalib::string & configXxhash64,
                        int64_t currentGeneration,
                        const vespalib::string & hostName,
-                       int64_t serverTimeout,
+                       duration serverTimeout,
                        const Trace & trace,
                        const VespaVersion & vespaVersion,
                        int64_t protocolVersion,
                        const CompressionType & compressionType,
                        const vespalib::string & methodName);
-    ~SlimeConfigRequest() {}
+    ~SlimeConfigRequest();
     bool verifyState(const ConfigState & state) const override;
     virtual ConfigResponse::UP createResponse(FRT_RPCRequest * request) const override = 0;
 private:
@@ -36,13 +39,12 @@ private:
                               const vespalib::string & configXxhash64,
                               int64_t currentGeneration,
                               const vespalib::string & hostName,
-                              int64_t serverTimeout,
+                              duration serverTimeout,
                               const Trace & trace,
                               const VespaVersion & vespaVersion,
                               int64_t protocolVersion,
                               const CompressionType & compressionType);
     static vespalib::string createJsonFromSlime(const vespalib::Slime & data);
-    static const vespalib::string REQUEST_TYPES;
     vespalib::Slime _data;
 };
 
diff --git a/config/src/vespa/config/helper/configfetcher.h b/config/src/vespa/config/helper/configfetcher.h
index 8891f0989e5..2ed236eda68 100644
--- a/config/src/vespa/config/helper/configfetcher.h
+++ b/config/src/vespa/config/helper/configfetcher.h
@@ -19,13 +19,12 @@ class IConfigContext;
 class ConfigFetcher
 {
 public:
-    using milliseconds = std::chrono::milliseconds;
     ConfigFetcher(std::shared_ptr<IConfigContext> context);
     ConfigFetcher(const SourceSpec & spec = ServerSpec());
     ~ConfigFetcher();
 
     template <typename ConfigType>
-    void subscribe(const std::string & configId, IFetcherCallback<ConfigType> * callback, milliseconds subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT);
+    void subscribe(const std::string & configId, IFetcherCallback<ConfigType> * callback, vespalib::duration subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT);
 
     void start();
     void close();
diff --git a/config/src/vespa/config/helper/configfetcher.hpp b/config/src/vespa/config/helper/configfetcher.hpp
index 585a798b2ba..4c4e323ac83 100644
--- a/config/src/vespa/config/helper/configfetcher.hpp
+++ b/config/src/vespa/config/helper/configfetcher.hpp
@@ -9,7 +9,7 @@ namespace config {
 
 template <typename ConfigType>
 void
-ConfigFetcher::subscribe(const std::string & configId, IFetcherCallback<ConfigType> * callback, milliseconds subscribeTimeout)
+ConfigFetcher::subscribe(const std::string & configId, IFetcherCallback<ConfigType> * callback, vespalib::duration subscribeTimeout)
 {
     _poller->subscribe<ConfigType>(configId, callback, subscribeTimeout);
 }
diff --git a/config/src/vespa/config/helper/configgetter.h b/config/src/vespa/config/helper/configgetter.h
index dfb61da3c6f..479b00aa510 100644
--- a/config/src/vespa/config/helper/configgetter.h
+++ b/config/src/vespa/config/helper/configgetter.h
@@ -17,11 +17,10 @@ template <typename ConfigType>
 class ConfigGetter
 {
 public:
-    using milliseconds = std::chrono::milliseconds;
     static std::unique_ptr<ConfigType> getConfig(int64_t &generation, const std::string & configId, const SourceSpec & spec = ServerSpec());
-    static std::unique_ptr<ConfigType> getConfig(int64_t &generation, const std::string & configId, std::shared_ptr<IConfigContext> context, milliseconds subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT);
+    static std::unique_ptr<ConfigType> getConfig(int64_t &generation, const std::string & configId, std::shared_ptr<IConfigContext> context, vespalib::duration subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT);
     static std::unique_ptr<ConfigType> getConfig(const std::string & configId, const SourceSpec & spec = ServerSpec());
-    static std::unique_ptr<ConfigType> getConfig(const std::string & configId, std::shared_ptr<IConfigContext> context, milliseconds subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT);
+    static std::unique_ptr<ConfigType> getConfig(const std::string & configId, std::shared_ptr<IConfigContext> context, vespalib::duration subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT);
 };
 
 } // namespace config
diff --git a/config/src/vespa/config/helper/configgetter.hpp b/config/src/vespa/config/helper/configgetter.hpp
index b01781ee313..7f2a17a0a3e 100644
--- a/config/src/vespa/config/helper/configgetter.hpp
+++ b/config/src/vespa/config/helper/configgetter.hpp
@@ -18,7 +18,7 @@ ConfigGetter<ConfigType>::getConfig(int64_t &generation, const std::string & con
 
 template <typename ConfigType>
 std::unique_ptr<ConfigType>
-ConfigGetter<ConfigType>::getConfig(int64_t &generation, const std::string & configId, std::shared_ptr<IConfigContext> context, milliseconds subscribeTimeout)
+ConfigGetter<ConfigType>::getConfig(int64_t &generation, const std::string & configId, std::shared_ptr<IConfigContext> context, vespalib::duration subscribeTimeout)
 {
     ConfigSubscriber s(std::move(context));
     std::unique_ptr< ConfigHandle<ConfigType> > h = s.subscribe<ConfigType>(configId, subscribeTimeout);
@@ -37,7 +37,7 @@ ConfigGetter<ConfigType>::getConfig(const std::string & configId, const SourceSp
 
 template <typename ConfigType>
 std::unique_ptr<ConfigType>
-ConfigGetter<ConfigType>::getConfig(const std::string & configId, std::shared_ptr<IConfigContext> context, milliseconds subscribeTimeout)
+ConfigGetter<ConfigType>::getConfig(const std::string & configId, std::shared_ptr<IConfigContext> context, vespalib::duration subscribeTimeout)
 {
     int64_t ignoreGeneration;
     return getConfig(ignoreGeneration, configId, std::move(context), subscribeTimeout);
diff --git a/config/src/vespa/config/helper/configpoller.h b/config/src/vespa/config/helper/configpoller.h
index 44d3a51595d..80eb03513b1 100644
--- a/config/src/vespa/config/helper/configpoller.h
+++ b/config/src/vespa/config/helper/configpoller.h
@@ -18,12 +18,11 @@ class ConfigSubscriber;
  */
 class ConfigPoller : public vespalib::Runnable {
 public:
-    using milliseconds = std::chrono::milliseconds;
     ConfigPoller(std::shared_ptr<IConfigContext> context);
     ~ConfigPoller() override;
     void run() override;
     template <typename ConfigType>
-    void subscribe(const std::string & configId, IFetcherCallback<ConfigType> * callback, milliseconds subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT);
+    void subscribe(const std::string & configId, IFetcherCallback<ConfigType> * callback, vespalib::duration subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT);
     void poll();
     void close();
     int64_t getGeneration() const { return _generation; }
diff --git a/config/src/vespa/config/helper/configpoller.hpp b/config/src/vespa/config/helper/configpoller.hpp
index 540ea160e7e..cf280110289 100644
--- a/config/src/vespa/config/helper/configpoller.hpp
+++ b/config/src/vespa/config/helper/configpoller.hpp
@@ -26,7 +26,7 @@ private:
 
 template <typename ConfigType>
 void
-ConfigPoller::subscribe(const std::string & configId, IFetcherCallback<ConfigType> * callback, milliseconds subscribeTimeout)
+ConfigPoller::subscribe(const std::string & configId, IFetcherCallback<ConfigType> * callback, vespalib::duration subscribeTimeout)
 {
     std::unique_ptr<ConfigHandle<ConfigType> > handle(_subscriber->subscribe<ConfigType>(configId, subscribeTimeout));
     _handleList.emplace_back(std::make_unique<GenericHandle<ConfigType>>(std::move(handle)));
diff --git a/config/src/vespa/config/retriever/configretriever.cpp b/config/src/vespa/config/retriever/configretriever.cpp
index 125d8ef3012..5d7daf5d366 100644
--- a/config/src/vespa/config/retriever/configretriever.cpp
+++ b/config/src/vespa/config/retriever/configretriever.cpp
@@ -5,16 +5,14 @@
 #include <vespa/config/subscription/sourcespec.h>
 #include <cassert>
 
-using std::chrono::milliseconds;
-
 namespace config {
 
- const milliseconds ConfigRetriever::DEFAULT_SUBSCRIBE_TIMEOUT(60000);
- const milliseconds ConfigRetriever::DEFAULT_NEXTGENERATION_TIMEOUT(60000);
+const vespalib::duration ConfigRetriever::DEFAULT_SUBSCRIBE_TIMEOUT(60s);
+const vespalib::duration ConfigRetriever::DEFAULT_NEXTGENERATION_TIMEOUT(60s);
 
 ConfigRetriever::ConfigRetriever(const ConfigKeySet & bootstrapSet,
                                  std::shared_ptr<IConfigContext> context,
-                                 milliseconds subscribeTimeout)
+                                 vespalib::duration subscribeTimeout)
     : _bootstrapSubscriber(bootstrapSet, context, subscribeTimeout),
       _configSubscriber(),
       _lock(),
@@ -31,9 +29,9 @@ ConfigRetriever::ConfigRetriever(const ConfigKeySet & bootstrapSet,
 ConfigRetriever::~ConfigRetriever() = default;
 
 ConfigSnapshot
-ConfigRetriever::getBootstrapConfigs(milliseconds timeoutInMillis)
+ConfigRetriever::getBootstrapConfigs(vespalib::duration timeout)
 {
-    bool ret = _bootstrapSubscriber.nextGeneration(timeoutInMillis);
+    bool ret = _bootstrapSubscriber.nextGeneration(timeout);
     if (!ret) {
         return ConfigSnapshot();
     }
@@ -42,7 +40,7 @@ ConfigRetriever::getBootstrapConfigs(milliseconds timeoutInMillis)
 }
 
 ConfigSnapshot
-ConfigRetriever::getConfigs(const ConfigKeySet & keySet, milliseconds timeoutInMillis)
+ConfigRetriever::getConfigs(const ConfigKeySet & keySet, vespalib::duration timeout)
 {
     if (_closed)
         return ConfigSnapshot();
@@ -65,7 +63,7 @@ ConfigRetriever::getConfigs(const ConfigKeySet & keySet, milliseconds timeoutInM
     }
     // Try update the subscribers generation if older than bootstrap
     if (_configSubscriber->getGeneration() < _bootstrapSubscriber.getGeneration())
-        _configSubscriber->nextGeneration(timeoutInMillis);
+        _configSubscriber->nextGeneration(timeout);
 
     // If we failed to get a new generation, the user should call us again.
     if (_configSubscriber->getGeneration() < _bootstrapSubscriber.getGeneration()) {
diff --git a/config/src/vespa/config/retriever/configretriever.h b/config/src/vespa/config/retriever/configretriever.h
index 8a47ad825cb..ae0dfd3fa34 100644
--- a/config/src/vespa/config/retriever/configretriever.h
+++ b/config/src/vespa/config/retriever/configretriever.h
@@ -25,23 +25,21 @@ class SourceSpec;
 class ConfigRetriever
 {
 public:
-    using milliseconds = std::chrono::milliseconds;
     ConfigRetriever(const ConfigKeySet & bootstrapSet,
                     std::shared_ptr<IConfigContext> context,
-                    milliseconds subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT);
+                    vespalib::duration subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT);
     ~ConfigRetriever();
 
     /**
      * Waits for the next generation of bootstrap configs to arrive, and returns
      * them. If no new generation has arrived, return an empty snapshot.
      *
-     * @param timeoutInMillis The timeout of the nextGeneration call, in
-     *                        milliseconds. Optional.
+     * @param timeout The timeout of the nextGeneration call. Optional.
      * @return a snapshot of bootstrap configs, empty if no new snapshot or
      *         retriever has been closed.
      * @throws ConfigTimeoutException if initial subscribe timed out.
      */
-    ConfigSnapshot getBootstrapConfigs(milliseconds timeoutInMillis = DEFAULT_NEXTGENERATION_TIMEOUT);
+    ConfigSnapshot getBootstrapConfigs(vespalib::duration timeout = DEFAULT_NEXTGENERATION_TIMEOUT);
 
     /**
      * Return the configs represented by a ConfigKeySet in a snapshot, and makes
@@ -50,7 +48,7 @@ public:
      *
      * @param keySet The set of configs that should be fetched. The set may only
      *               change when bootstrap has been changed.
-     * @param timeoutInMillis The timeout, in milliseconds. Optional.
+     * @param timeout The timeout. Optional.
      * @return a snapshot of configs corresponding to the keySet or
      *         an empty snapshot if
      *              a) retriever has been closed. The isClosed() method can be
@@ -62,7 +60,7 @@ public:
      *                 method can be used to check for this condition.
      * @throws ConfigTimeoutException if resubscribe timed out.
      */
-    ConfigSnapshot getConfigs(const ConfigKeySet & keySet, milliseconds timeoutInMillis = DEFAULT_NEXTGENERATION_TIMEOUT);
+    ConfigSnapshot getConfigs(const ConfigKeySet & keySet, vespalib::duration timeout = DEFAULT_NEXTGENERATION_TIMEOUT);
 
     /**
      * Close this retriever in order to shut down.
@@ -90,8 +88,8 @@ public:
      */
     int64_t getGeneration() const { return _generation; }
 
-    static const milliseconds DEFAULT_SUBSCRIBE_TIMEOUT;
-    static const milliseconds DEFAULT_NEXTGENERATION_TIMEOUT;
+    static const vespalib::duration DEFAULT_SUBSCRIBE_TIMEOUT;
+    static const vespalib::duration DEFAULT_NEXTGENERATION_TIMEOUT;
 private:
     FixedConfigSubscriber                            _bootstrapSubscriber;
     std::unique_ptr<GenericConfigSubscriber>         _configSubscriber;
@@ -102,7 +100,7 @@ private:
     std::unique_ptr<SourceSpec>                      _spec;
     bool                        _closed;
     int64_t                     _generation;
-    milliseconds                _subscribeTimeout;
+    vespalib::duration                _subscribeTimeout;
     bool                        _bootstrapRequired;
 };
 
diff --git a/config/src/vespa/config/retriever/fixedconfigsubscriber.cpp b/config/src/vespa/config/retriever/fixedconfigsubscriber.cpp
index da199c2e298..4f3ad4552c1 100644
--- a/config/src/vespa/config/retriever/fixedconfigsubscriber.cpp
+++ b/config/src/vespa/config/retriever/fixedconfigsubscriber.cpp
@@ -4,7 +4,7 @@
 namespace config {
 FixedConfigSubscriber::FixedConfigSubscriber(const ConfigKeySet & keySet,
                                              std::shared_ptr<IConfigContext> context,
-                                             milliseconds subscribeTimeout)
+                                             vespalib::duration subscribeTimeout)
     : _set(std::move(context)),
       _subscriptionList()
 {
@@ -14,9 +14,9 @@ FixedConfigSubscriber::FixedConfigSubscriber(const ConfigKeySet & keySet,
 }
 
 bool
-FixedConfigSubscriber::nextGeneration(milliseconds timeoutInMillis)
+FixedConfigSubscriber::nextGeneration(vespalib::duration timeout)
 {
-    return _set.acquireSnapshot(timeoutInMillis, true);
+    return _set.acquireSnapshot(timeout, true);
 }
 
 void
diff --git a/config/src/vespa/config/retriever/fixedconfigsubscriber.h b/config/src/vespa/config/retriever/fixedconfigsubscriber.h
index 1ca4d8cf0b3..56ac8868042 100644
--- a/config/src/vespa/config/retriever/fixedconfigsubscriber.h
+++ b/config/src/vespa/config/retriever/fixedconfigsubscriber.h
@@ -14,9 +14,8 @@ namespace config {
 class FixedConfigSubscriber
 {
 public:
-    using milliseconds = std::chrono::milliseconds;
-    FixedConfigSubscriber(const ConfigKeySet & keySet, std::shared_ptr<IConfigContext> context, milliseconds subscribeTimeout);
-    bool nextGeneration(milliseconds timeoutInMillis);
+    FixedConfigSubscriber(const ConfigKeySet & keySet, std::shared_ptr<IConfigContext> context, vespalib::duration subscribeTimeout);
+    bool nextGeneration(vespalib::duration timeout);
     void close();
     int64_t getGeneration() const;
     ConfigSnapshot getConfigSnapshot() const;
diff --git a/config/src/vespa/config/retriever/genericconfigsubscriber.cpp b/config/src/vespa/config/retriever/genericconfigsubscriber.cpp
index 4190c404d04..93001518b32 100644
--- a/config/src/vespa/config/retriever/genericconfigsubscriber.cpp
+++ b/config/src/vespa/config/retriever/genericconfigsubscriber.cpp
@@ -8,15 +8,15 @@ GenericConfigSubscriber::GenericConfigSubscriber(std::shared_ptr<IConfigContext>
 { }
 
 bool
-GenericConfigSubscriber::nextGeneration(milliseconds timeoutInMillis)
+GenericConfigSubscriber::nextGeneration(vespalib::duration timeout)
 {
-    return _set.acquireSnapshot(timeoutInMillis, true);
+    return _set.acquireSnapshot(timeout, true);
 }
 
 std::shared_ptr<ConfigSubscription>
-GenericConfigSubscriber::subscribe(const ConfigKey & key, milliseconds timeoutInMillis)
+GenericConfigSubscriber::subscribe(const ConfigKey & key, vespalib::duration timeout)
 {
-    return _set.subscribe(key, timeoutInMillis);
+    return _set.subscribe(key, timeout);
 }
 
 void
diff --git a/config/src/vespa/config/retriever/genericconfigsubscriber.h b/config/src/vespa/config/retriever/genericconfigsubscriber.h
index b2b7be5b9e4..af9cf2c0dcb 100644
--- a/config/src/vespa/config/retriever/genericconfigsubscriber.h
+++ b/config/src/vespa/config/retriever/genericconfigsubscriber.h
@@ -13,10 +13,9 @@ namespace config {
 class GenericConfigSubscriber
 {
 public:
-    using milliseconds = std::chrono::milliseconds;
     GenericConfigSubscriber(std::shared_ptr<IConfigContext> context);
-    bool nextGeneration(milliseconds timeoutInMillis);
-    std::shared_ptr<ConfigSubscription> subscribe(const ConfigKey & key, milliseconds timeoutInMillis);
+    bool nextGeneration(vespalib::duration timeout);
+    std::shared_ptr<ConfigSubscription> subscribe(const ConfigKey & key, vespalib::duration timeout);
     void close();
     int64_t getGeneration() const;
 private:
diff --git a/config/src/vespa/config/retriever/simpleconfigretriever.cpp b/config/src/vespa/config/retriever/simpleconfigretriever.cpp
index 43dad7d9429..69ff736cbca 100644
--- a/config/src/vespa/config/retriever/simpleconfigretriever.cpp
+++ b/config/src/vespa/config/retriever/simpleconfigretriever.cpp
@@ -4,7 +4,7 @@
 namespace config {
 SimpleConfigRetriever::SimpleConfigRetriever(const ConfigKeySet & keySet,
                                              std::shared_ptr<IConfigContext> context,
-                                             milliseconds subscribeTimeout)
+                                             vespalib::duration subscribeTimeout)
     : _set(context),
       _subscriptionList()
 {
@@ -14,9 +14,9 @@ SimpleConfigRetriever::SimpleConfigRetriever(const ConfigKeySet & keySet,
 }
 
 ConfigSnapshot
-SimpleConfigRetriever::getConfigs(milliseconds timeoutInMillis)
+SimpleConfigRetriever::getConfigs(vespalib::duration timeout)
 {
-    if (_set.acquireSnapshot(timeoutInMillis, true)) {
+    if (_set.acquireSnapshot(timeout, true)) {
         return ConfigSnapshot(_subscriptionList, _set.getGeneration());
     }
     return ConfigSnapshot();
diff --git a/config/src/vespa/config/retriever/simpleconfigretriever.h b/config/src/vespa/config/retriever/simpleconfigretriever.h
index 2650532cda2..7033ab26e32 100644
--- a/config/src/vespa/config/retriever/simpleconfigretriever.h
+++ b/config/src/vespa/config/retriever/simpleconfigretriever.h
@@ -1,10 +1,10 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 #pragma once
 
-#include <vespa/config/subscription/configsubscriptionset.h>
-#include <vespa/config/common/timingvalues.h>
 #include "configkeyset.h"
 #include "configsnapshot.h"
+#include <vespa/config/subscription/configsubscriptionset.h>
+#include <vespa/config/common/timingvalues.h>
 
 namespace config {
 
@@ -17,19 +17,18 @@ class SimpleConfigRetriever
 {
 public:
     typedef std::unique_ptr<SimpleConfigRetriever> UP;
-    using milliseconds = std::chrono::milliseconds;
 
     SimpleConfigRetriever(const ConfigKeySet & keySet,
                           std::shared_ptr<IConfigContext> context,
-                          milliseconds subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT);
+                          vespalib::duration subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT);
 
     /**
      * Attempt retrieving a snapshot of configs.
-     * @param timeoutInMillis The amount of time to wait for a new snapshot.
+     * @param timeout The amount of time to wait for a new snapshot.
      * @return A new snapshot. The snapshot is empty if timeout was reached or
      *         if the retriever was closed.
      */
-    ConfigSnapshot getConfigs(milliseconds timeoutInMillis = DEFAULT_GETCONFIGS_TIMEOUT);
+    ConfigSnapshot getConfigs(vespalib::duration timeout = DEFAULT_GETCONFIGS_TIMEOUT);
     void close();
     bool isClosed() const;
 
diff --git a/config/src/vespa/config/subscription/configsubscriber.cpp b/config/src/vespa/config/subscription/configsubscriber.cpp
index 0645481a1f5..979d0e50df0 100644
--- a/config/src/vespa/config/subscription/configsubscriber.cpp
+++ b/config/src/vespa/config/subscription/configsubscriber.cpp
@@ -18,15 +18,15 @@ ConfigSubscriber::ConfigSubscriber(const SourceSpec & spec)
 ConfigSubscriber::~ConfigSubscriber() = default;
 
 bool
-ConfigSubscriber::nextConfig(milliseconds timeoutInMillis)
+ConfigSubscriber::nextConfig(vespalib::duration timeout)
 {
-    return _set.acquireSnapshot(timeoutInMillis, false);
+    return _set.acquireSnapshot(timeout, false);
 }
 
 bool
-ConfigSubscriber::nextGeneration(milliseconds timeoutInMillis)
+ConfigSubscriber::nextGeneration(vespalib::duration timeout)
 {
-    return _set.acquireSnapshot(timeoutInMillis, true);
+    return _set.acquireSnapshot(timeout, true);
 }
 
 void
diff --git a/config/src/vespa/config/subscription/configsubscriber.h b/config/src/vespa/config/subscription/configsubscriber.h
index fd6497155fc..03f93153efd 100644
--- a/config/src/vespa/config/subscription/configsubscriber.h
+++ b/config/src/vespa/config/subscription/configsubscriber.h
@@ -27,7 +27,6 @@ namespace config {
 class ConfigSubscriber
 {
 public:
-    using milliseconds = std::chrono::milliseconds;
     typedef std::unique_ptr<ConfigSubscriber> UP;
 
     /**
@@ -53,28 +52,27 @@ public:
     /**
      * Checks if one or more of the configs in the set is updated or not.
      *
-     * @param timeoutInMillis The timeout in milliseconds.
+     * @param timeout The timeout.
      * @return true if new configs are available, false if timeout was reached
      *              or subscriber has been closed.
      */
-    bool nextConfig(milliseconds timeoutInMillis = DEFAULT_NEXTCONFIG_TIMEOUT);
-    bool nextConfigNow() { return nextConfig(milliseconds(0)); }
+    bool nextConfig(vespalib::duration timeout = DEFAULT_NEXTCONFIG_TIMEOUT);
+    bool nextConfigNow() { return nextConfig(vespalib::duration::zero()); }
 
     /**
      * Checks if the generation of this config set is updated.
      *
-     * @param timeoutInMillis The timeout in milliseconds.
+     * @param timeout The timeout
      * @return true if a new generation are available, false if timeout was reached
      *              or subscriber has been closed.
      */
-    bool nextGeneration(milliseconds timeoutInMillis = DEFAULT_NEXTCONFIG_TIMEOUT);
-    bool nextGenerationNow() { return nextGeneration(milliseconds(0)); }
+    bool nextGeneration(vespalib::duration timeout = DEFAULT_NEXTCONFIG_TIMEOUT);
+    bool nextGenerationNow() { return nextGeneration(vespalib::duration::zero()); }
     /**
      * Subscribe to a config fetched from the default source specification.
      *
      * @param configId        The configId to get config for.
-     * @param timeoutInMillis An optional timeout on the subscribe call, in
-     *                        milliseconds.
+     * @param timeout         An optional timeout on the subscribe call
      * @return                A subscription handle which can be used to
      *                        retrieve config.
      * @throws ConfigTimeoutException if subscription timed out.
@@ -82,7 +80,7 @@ public:
      */
     template <typename ConfigType>
     std::unique_ptr<ConfigHandle<ConfigType> >
-    subscribe(const std::string & configId, milliseconds timeoutInMillis = DEFAULT_SUBSCRIBE_TIMEOUT);
+    subscribe(const std::string & configId, vespalib::duration timeout = DEFAULT_SUBSCRIBE_TIMEOUT);
 
     /**
      * Return the current generation number for configs.
diff --git a/config/src/vespa/config/subscription/configsubscriber.hpp b/config/src/vespa/config/subscription/configsubscriber.hpp
index ca890f8e35d..aeaf0befcbd 100644
--- a/config/src/vespa/config/subscription/configsubscriber.hpp
+++ b/config/src/vespa/config/subscription/configsubscriber.hpp
@@ -7,10 +7,10 @@ namespace config {
 
 template <typename ConfigType>
 std::unique_ptr<ConfigHandle<ConfigType> >
-ConfigSubscriber::subscribe(const std::string & configId, milliseconds timeoutInMillis)
+ConfigSubscriber::subscribe(const std::string & configId, vespalib::duration timeout)
 {
     const ConfigKey key(ConfigKey::create<ConfigType>(configId));
-    return std::make_unique<ConfigHandle<ConfigType> >(_set.subscribe(key, timeoutInMillis));
+    return std::make_unique<ConfigHandle<ConfigType> >(_set.subscribe(key, timeout));
 }
 
 }
diff --git a/config/src/vespa/config/subscription/configsubscription.cpp b/config/src/vespa/config/subscription/configsubscription.cpp
index d49c5c32478..859e5b6f056 100644
--- a/config/src/vespa/config/subscription/configsubscription.cpp
+++ b/config/src/vespa/config/subscription/configsubscription.cpp
@@ -29,7 +29,7 @@ ConfigSubscription::~ConfigSubscription()
 
 
 bool
-ConfigSubscription::nextUpdate(int64_t generation, std::chrono::milliseconds timeout)
+ConfigSubscription::nextUpdate(int64_t generation, vespalib::duration timeout)
 {
     if (_closed || !_holder->poll()) {
         return false;
diff --git a/config/src/vespa/config/subscription/configsubscription.h b/config/src/vespa/config/subscription/configsubscription.h
index 05c03736fa3..063af97dcec 100644
--- a/config/src/vespa/config/subscription/configsubscription.h
+++ b/config/src/vespa/config/subscription/configsubscription.h
@@ -1,10 +1,12 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
 #pragma once
+
 #include "subscriptionid.h"
 #include <vespa/config/common/configkey.h>
 #include <vespa/config/common/source.h>
+#include <vespa/vespalib/util/time.h>
 #include <atomic>
-#include <chrono>
 
 namespace config {
 
@@ -47,7 +49,7 @@ public:
     /// Used by ConfigSubscriptionSet
     SubscriptionId getSubscriptionId() const { return _id; }
     const ConfigKey & getKey() const;
-    bool nextUpdate(int64_t generation, std::chrono::milliseconds timeoutInMillis);
+    bool nextUpdate(int64_t generation, vespalib::duration timeout);
     int64_t getGeneration() const;
     bool hasChanged() const;
     bool hasGenerationChanged() const;
diff --git a/config/src/vespa/config/subscription/configsubscriptionset.cpp b/config/src/vespa/config/subscription/configsubscriptionset.cpp
index 28eb8463ca7..0b3944acc4e 100644
--- a/config/src/vespa/config/subscription/configsubscriptionset.cpp
+++ b/config/src/vespa/config/subscription/configsubscriptionset.cpp
@@ -11,8 +11,8 @@
 #include <vespa/log/log.h>
 LOG_SETUP(".config.subscription.configsubscriptionset");
 
-using namespace std::chrono_literals;
-using namespace std::chrono;
+using vespalib::duration;
+using vespalib::steady_clock;
 
 namespace config {
 
@@ -31,7 +31,7 @@ ConfigSubscriptionSet::~ConfigSubscriptionSet()
 }
 
 bool
-ConfigSubscriptionSet::acquireSnapshot(vespalib::duration timeout, bool ignoreChange)
+ConfigSubscriptionSet::acquireSnapshot(duration timeout, bool ignoreChange)
 {
     if (_state == CLOSED) {
         return false;
@@ -40,12 +40,12 @@ ConfigSubscriptionSet::acquireSnapshot(vespalib::duration timeout, bool ignoreCh
     }
 
     steady_clock::time_point startTime = steady_clock::now();
-    vespalib::duration timeLeft = timeout;
+    duration timeLeft = timeout;
     int64_t lastGeneration = _currentGeneration;
     bool inSync = false;
 
-    LOG(spam, "Going into nextConfig loop, time left is %" PRId64, timeLeft.count());
-    while (!isClosed() && (timeLeft.count() >= 0) && !inSync) {
+    LOG(spam, "Going into nextConfig loop, time left is %f", vespalib::to_s(timeLeft));
+    while (!isClosed() && (timeLeft >= duration::zero()) && !inSync) {
         size_t numChanged = 0;
         size_t numGenerationChanged = 0;
         bool generationsInSync = true;
@@ -54,7 +54,7 @@ ConfigSubscriptionSet::acquireSnapshot(vespalib::duration timeout, bool ignoreCh
         // Run nextUpdate on all subscribers to get them in sync.
         for (const auto & subscription : _subscriptionList) {
 
-            if (!subscription->nextUpdate(_currentGeneration, duration_cast<milliseconds>(timeLeft)) && !subscription->hasGenerationChanged()) {
+            if (!subscription->nextUpdate(_currentGeneration, timeLeft) && !subscription->hasGenerationChanged()) {
                 subscription->reset();
                 continue;
             }
@@ -82,7 +82,7 @@ ConfigSubscriptionSet::acquireSnapshot(vespalib::duration timeout, bool ignoreCh
         inSync = generationsInSync && (_subscriptionList.size() == numGenerationChanged) && (ignoreChange || numChanged > 0);
         lastGeneration = generation;
         timeLeft = timeout - (steady_clock::now() - startTime);
-        if (!inSync && (timeLeft.count() > 0)) {
+        if (!inSync && (timeLeft > duration::zero())) {
             std::this_thread::sleep_for(std::min(_maxNapTime, timeLeft));
         } else {
             break;
@@ -124,14 +124,14 @@ ConfigSubscriptionSet::isClosed() const
 }
 
 std::shared_ptr<ConfigSubscription>
-ConfigSubscriptionSet::subscribe(const ConfigKey & key, vespalib::duration timeout)
+ConfigSubscriptionSet::subscribe(const ConfigKey & key, duration timeout)
 {
     if (_state != OPEN) {
         throw ConfigRuntimeException("Adding subscription after calling nextConfig() is not allowed");
     }
     LOG(debug, "Subscribing with config Id(%s), defName(%s)", key.getConfigId().c_str(), key.getDefName().c_str());
 
-    std::shared_ptr<ConfigSubscription> s = _mgr.subscribe(key, duration_cast<milliseconds>(timeout));
+    std::shared_ptr<ConfigSubscription> s = _mgr.subscribe(key, timeout);
     _subscriptionList.push_back(s);
     return s;
 }