FastOS_Time -> std::chrono.

16 files changed, 198 insertions, 208 deletions

diff --git a/config/src/tests/api/api.cpp b/config/src/tests/api/api.cpp
index a68b7e676db..4db66761444 100644
--- a/config/src/tests/api/api.cpp
+++ b/config/src/tests/api/api.cpp
@@ -13,9 +13,9 @@ TEST("require that can subscribe with empty config id") {
     set.addBuilder("", &builder);
     ConfigSubscriber subscriber(ctx);
     ConfigHandle<MyConfig>::UP handle = subscriber.subscribe<MyConfig>("");
-    ASSERT_TRUE(subscriber.nextConfig(0));
+    ASSERT_TRUE(subscriber.nextConfigNow());
     std::unique_ptr<MyConfig> cfg(handle->getConfig());
-    ASSERT_TRUE(cfg.get() != NULL);
+    ASSERT_TRUE(cfg);
     ASSERT_EQUAL("myfoo", cfg->myField);
 }
 
diff --git a/config/src/tests/configagent/configagent.cpp b/config/src/tests/configagent/configagent.cpp
index 328959fb34d..a7cc95ab883 100644
--- a/config/src/tests/configagent/configagent.cpp
+++ b/config/src/tests/configagent/configagent.cpp
@@ -10,6 +10,7 @@
 #include <config-my.h>
 
 using namespace config;
+using namespace std::chrono_literals;
 
 class MyConfigRequest : public ConfigRequest
 {
@@ -65,17 +66,17 @@ public:
 
     static ConfigResponse::UP createOKResponse(const ConfigKey & key, const ConfigValue & value, uint64_t timestamp = 10, const vespalib::string & md5 = "a")
     {
-        return ConfigResponse::UP(new MyConfigResponse(key, value, true, timestamp, md5, "", 0, false));
+        return std::make_unique<MyConfigResponse>(key, value, true, timestamp, md5, "", 0, false);
     }
 
     static ConfigResponse::UP createServerErrorResponse(const ConfigKey & key, const ConfigValue & value)
     {
-        return ConfigResponse::UP(new MyConfigResponse(key, value, true, 10, "a", "whinewhine", 2, true));
+        return std::make_unique<MyConfigResponse>(key, value, true, 10, "a", "whinewhine", 2, true);
     }
 
     static ConfigResponse::UP createConfigErrorResponse(const ConfigKey & key, const ConfigValue & value)
     {
-        return ConfigResponse::UP(new MyConfigResponse(key, value, false, 10, "a", "", 0, false));
+        return std::make_unique<MyConfigResponse>(key, value, false, 10, "a", "", 0, false);
     }
 };
 
@@ -92,7 +93,7 @@ public:
         return std::move(_update);
     }
 
-    bool wait(uint64_t timeout) override
+    bool wait(milliseconds timeout) override
     {
         (void) timeout;
         return true;
@@ -124,7 +125,7 @@ static TimingValues testTimingValues(
         2000,  // successTimeout
         500,  // errorTimeout
         500,   // initialTimeout
-        4000,  // subscribeTimeout
+        4000ms,  // subscribeTimeout
         0,     // fixedDelay
         250,   // successDelay
         250,   // unconfiguredDelay
diff --git a/config/src/tests/configfetcher/configfetcher.cpp b/config/src/tests/configfetcher/configfetcher.cpp
index 5a2943f7512..607ab0a29a5 100644
--- a/config/src/tests/configfetcher/configfetcher.cpp
+++ b/config/src/tests/configfetcher/configfetcher.cpp
@@ -2,8 +2,7 @@
 #include <vespa/vespalib/testkit/test_kit.h>
 #include <vespa/config/helper/configfetcher.h>
 #include <vespa/vespalib/util/exception.h>
-#include <vespa/fastos/time.h>
-#include <fstream>
+#include <vespa/fastos/timestamp.h>
 #include "config-my.h"
 #include <atomic>
 
@@ -66,15 +65,14 @@ TEST("requireThatConfigUpdatesArePerformed") {
         writeFile("test1.cfg", "bar");
 
         cb._configured = false;
-        FastOS_Time timer;
-        timer.SetNow();
-        while (!cb._configured && timer.MilliSecsToNow() < 20000.0) {
+        fastos::StopWatch timer;
+        while (!cb._configured && timer.elapsed().ms() < 20000.0) {
             if (cb._configured)
                 break;
             FastOS_Thread::Sleep(1000);
         }
         ASSERT_TRUE(cb._configured);
-        ASSERT_TRUE(cb._config.get() != NULL);
+        ASSERT_TRUE(cb._config);
         ASSERT_EQUAL("my", cb._config->defName());
         ASSERT_EQUAL("bar", cb._config->myField);
     }
@@ -99,8 +97,8 @@ TEST("requireThatFetcherCanHandleMultipleConfigs") {
 
         ASSERT_TRUE(cb1._configured);
         ASSERT_TRUE(cb2._configured);
-        ASSERT_TRUE(cb1._config.get() != NULL);
-        ASSERT_TRUE(cb2._config.get() != NULL);
+        ASSERT_TRUE(cb1._config);
+        ASSERT_TRUE(cb2._config);
         ASSERT_EQUAL("my", cb1._config->defName());
         ASSERT_EQUAL("foo", cb1._config->myField);
         ASSERT_EQUAL("my", cb2._config->defName());
@@ -147,9 +145,8 @@ TEST_F("verify that config generation can be obtained from config fetcher", Conf
         f1.builder.myField = "bar";
         cb._configured = false;
         f1.context->reload();
-        FastOS_Time timer;
-        timer.SetNow();
-        while (timer.MilliSecsToNow() < 120000) {
+        fastos::StopWatch timer;
+        while (timer.elapsed().ms() < 120000) {
             if (cb._configured) {
                 break;
             }
diff --git a/config/src/tests/configholder/configholder.cpp b/config/src/tests/configholder/configholder.cpp
index a488cca705a..ce7e4f0531d 100644
--- a/config/src/tests/configholder/configholder.cpp
+++ b/config/src/tests/configholder/configholder.cpp
@@ -1,14 +1,15 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 #include <vespa/vespalib/testkit/test_kit.h>
 #include <vespa/config/common/configholder.h>
+#include <vespa/fastos/timestamp.h>
 
 using namespace config;
 using namespace std::chrono_literals;
 
 namespace {
 
-constexpr double ONE_SEC = 1000.0;
-constexpr double ONE_MINUTE = 60 * ONE_SEC;
+constexpr long ONE_SEC = 1000;
+constexpr long ONE_MINUTE = 60 * ONE_SEC;
 
 }
 
@@ -33,11 +34,10 @@ TEST("Require that waiting is done")
     ConfigValue value;
 
     ConfigHolder holder;
-    FastOS_Time timer;
-    timer.SetNow();
+    fastos::StopWatch timer;
     holder.wait(1000ms);
-    EXPECT_GREATER_EQUAL(timer.MilliSecsToNow(), ONE_SEC);
-    EXPECT_LESS(timer.MilliSecsToNow(), ONE_MINUTE);
+    EXPECT_GREATER_EQUAL(timer.elapsed().ms(), ONE_SEC);
+    EXPECT_LESS(timer.elapsed().ms(), ONE_MINUTE);
 
     holder.handle(std::make_unique<ConfigUpdate>(value, true, 0));
     ASSERT_TRUE(holder.wait(100ms));
@@ -57,25 +57,23 @@ TEST("Require that polling for elements work")
 
 TEST("Require that negative time does not mean forever.") {
     ConfigHolder holder;
-    FastOS_Time timer;
-    timer.SetNow();
+    fastos::StopWatch timer;
     ASSERT_FALSE(holder.poll());
-    ASSERT_FALSE(holder.wait(10));
-    ASSERT_FALSE(holder.wait(0));
-    ASSERT_FALSE(holder.wait(-1));
-    ASSERT_FALSE(holder.wait(-7));
-    EXPECT_LESS(timer.MilliSecsToNow(), ONE_MINUTE);
+    ASSERT_FALSE(holder.wait(10ms));
+    ASSERT_FALSE(holder.wait(0ms));
+    ASSERT_FALSE(holder.wait(-1ms));
+    ASSERT_FALSE(holder.wait(-7ms));
+    EXPECT_LESS(timer.elapsed().ms(), ONE_MINUTE);
 }
 
 TEST_MT_F("Require that wait is interrupted", 2, ConfigHolder)
 {
     if (thread_id == 0) {
-        FastOS_Time timer;
-        timer.SetNow();
+        fastos::StopWatch timer;
         TEST_BARRIER();
         f.wait(1000ms);
-        EXPECT_LESS(timer.MilliSecsToNow(), ONE_MINUTE);
-        EXPECT_GREATER(timer.MilliSecsToNow(), 400.0);
+        EXPECT_LESS(timer.elapsed().ms(), ONE_MINUTE);
+        EXPECT_GREATER(timer.elapsed().ms(), 400.0);
         TEST_BARRIER();
     } else {
         TEST_BARRIER();
diff --git a/config/src/tests/configmanager/configmanager.cpp b/config/src/tests/configmanager/configmanager.cpp
index 43f194883c3..2a7e4999829 100644
--- a/config/src/tests/configmanager/configmanager.cpp
+++ b/config/src/tests/configmanager/configmanager.cpp
@@ -10,6 +10,7 @@
 #include "config-my.h"
 
 using namespace config;
+using namespace std::chrono_literals;
 
 namespace {
 
@@ -91,7 +92,7 @@ namespace {
             2000,  // successTimeout
             500,  // errorTimeout
             500,   // initialTimeout
-            4000,  // unsubscribeTimeout
+            4000ms,  // unsubscribeTimeout
             0,     // fixedDelay
             250,   // successDelay
             250,   // unconfiguredDelay
@@ -111,7 +112,7 @@ namespace {
 
         void subscribe()
         {
-            sub = _mgr.subscribe(key, 5000);
+            sub = _mgr.subscribe(key, 5000ms);
         }
     };
 
diff --git a/config/src/tests/configretriever/configretriever.cpp b/config/src/tests/configretriever/configretriever.cpp
index 944b0d45da0..fc921a324af 100644
--- a/config/src/tests/configretriever/configretriever.cpp
+++ b/config/src/tests/configretriever/configretriever.cpp
@@ -2,7 +2,6 @@
 
 #include <vespa/vespalib/testkit/test_kit.h>
 #include <vespa/vespalib/data/slime/slime.h>
-#include <vespa/config/config.h>
 #include <vespa/config/print.h>
 #include <vespa/config/retriever/configretriever.h>
 #include <vespa/config/retriever/simpleconfigretriever.h>
@@ -10,7 +9,7 @@
 #include <vespa/config/common/configholder.h>
 #include <vespa/config/subscription/configsubscription.h>
 #include <vespa/config/common/exceptions.h>
-#include <vespa/fastos/time.h>
+#include <vespa/fastos/timestamp.h>
 #include "config-bootstrap.h"
 #include "config-foo.h"
 #include "config-bar.h"
@@ -20,6 +19,7 @@ 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;
@@ -119,8 +119,8 @@ struct SubscriptionFixture
         : holder(new ConfigHolder()),
           sub(new ConfigSubscription(0, key, holder, Source::UP(new MySource())))
     {
-        holder->handle(ConfigUpdate::UP(new ConfigUpdate(value, 3, 3)));
-        ASSERT_TRUE(sub->nextUpdate(0, 0));
+        holder->handle(std::make_unique<ConfigUpdate>(value, 3, 3));
+        ASSERT_TRUE(sub->nextUpdate(0, 0ms));
         sub->flip();
     }
 };
@@ -246,9 +246,8 @@ public:
         configured = true;
     }
     bool waitUntilConfigured(int64_t timeoutInMillis) {
-        FastOS_Time timer;
-        timer.SetNow();
-        while (timer.MilliSecsToNow() < timeoutInMillis) {
+        fastos::StopWatch timer;
+        while (timer.elapsed().ms() < timeoutInMillis) {
             if (configured) {
                 return true;
             }
@@ -386,14 +385,14 @@ TEST_FFF("require that snapshots can produce subsets", SubscriptionFixture(Confi
     ASSERT_EQUAL(3, subset1.getGeneration());
     ASSERT_EQUAL(1u, subset1.size());
     std::unique_ptr<FooConfig> cfg1(subset1.getConfig<FooConfig>("id"));
-    ASSERT_TRUE(cfg1.get() != NULL);
+    ASSERT_TRUE(cfg1);
 
     ConfigSnapshot subset2(parent.subset(ConfigKeySet().add<BarConfig>("id")));
     ASSERT_FALSE(subset2.empty());
     ASSERT_EQUAL(3, subset2.getGeneration());
     ASSERT_EQUAL(1u, subset2.size());
     std::unique_ptr<BarConfig> cfg2(subset2.getConfig<BarConfig>("id"));
-    ASSERT_TRUE(cfg2.get() != NULL);
+    ASSERT_TRUE(cfg2);
 
     ConfigSnapshot subset3(parent.subset(ConfigKeySet().add<BarConfig>("doesnotexist")));
     ASSERT_TRUE(subset3.empty());
@@ -405,9 +404,9 @@ TEST_FFF("require that snapshots can produce subsets", SubscriptionFixture(Confi
     ASSERT_EQUAL(3, subset4.getGeneration());
     ASSERT_EQUAL(2u, subset4.size());
     cfg1 = subset4.getConfig<FooConfig>("id");
-    ASSERT_TRUE(cfg1.get() != NULL);
+    ASSERT_TRUE(cfg1);
     cfg2 = subset4.getConfig<BarConfig>("id");
-    ASSERT_TRUE(cfg2.get() != NULL);
+    ASSERT_TRUE(cfg2);
 }
 
 TEST_FFF("require that snapshots can be serialized", SubscriptionFixture(ConfigKey::create<FooConfig>("id"), createKeyValueV2("fooValue", "bar")),
diff --git a/config/src/tests/configuri/configuri_test.cpp b/config/src/tests/configuri/configuri_test.cpp
index 3a0dafffc17..c813761e763 100644
--- a/config/src/tests/configuri/configuri_test.cpp
+++ b/config/src/tests/configuri/configuri_test.cpp
@@ -38,9 +38,8 @@ TEST("Require that URI can be created from  instance") {
     b.myField = "rabarbra";
     ConfigUri uri(ConfigUri::createFromInstance(b));
     ConfigSubscriber subscriber(uri.getContext());
-    ConfigHandle<MyConfig>::UP handle =
-        subscriber.subscribe<MyConfig>(uri.getConfigId());
-    ASSERT_TRUE(subscriber.nextConfig(0));
+    ConfigHandle<MyConfig>::UP handle = subscriber.subscribe<MyConfig>(uri.getConfigId());
+    ASSERT_TRUE(subscriber.nextConfigNow());
     ASSERT_TRUE(handle->isChanged());
     std::unique_ptr<MyConfig> cfg = handle->getConfig();
     ASSERT_EQUAL(b.myField, cfg->myField);
diff --git a/config/src/tests/failover/failover.cpp b/config/src/tests/failover/failover.cpp
index d05c948b5d6..17fa264fd32 100644
--- a/config/src/tests/failover/failover.cpp
+++ b/config/src/tests/failover/failover.cpp
@@ -15,6 +15,7 @@ using vespalib::Barrier;
 using namespace config::protocol::v2;
 using namespace vespalib::slime;
 using namespace vespalib;
+using namespace std::chrono_literals;
 
 namespace {
 
@@ -173,7 +174,7 @@ TimingValues testTimingValues(
     500,  // successTimeout
     500,  // errorTimeout
     500,   // initialTimeout
-    400,  // unsubscribeTimeout
+    400ms,  // unsubscribeTimeout
     0,     // fixedDelay
     250,   // successDelay
     250,   // unconfiguredDelay
diff --git a/config/src/tests/file_subscription/file_subscription.cpp b/config/src/tests/file_subscription/file_subscription.cpp
index 69090f4bb8e..9c40e2ffd77 100644
--- a/config/src/tests/file_subscription/file_subscription.cpp
+++ b/config/src/tests/file_subscription/file_subscription.cpp
@@ -5,7 +5,6 @@
 #include <vespa/config/file/filesource.h>
 #include <vespa/config/common/exceptions.h>
 #include <vespa/vespalib/util/sync.h>
-#include <vespa/fastos/time.h>
 #include <fstream>
 #include <config-my.h>
 #include <config-foo.h>
@@ -13,9 +12,12 @@
 #include <config-bar.h>
 #include <config-foobar.h>
 #include <vespa/log/log.h>
+#include <vespa/fastos/timestamp.h>
+
 LOG_SETUP(".filesubscription_test");
 
 using namespace config;
+using namespace std::chrono_literals;
 
 namespace {
 
@@ -60,15 +62,15 @@ TEST("requireThatFileSpecGivesCorrectSource") {
     FileSpec spec("my.cfg");
 
     SourceFactory::UP factory(spec.createSourceFactory(TimingValues()));
-    ASSERT_TRUE(factory.get() != NULL);
+    ASSERT_TRUE(factory);
     IConfigHolder::SP holder(new ConfigHolder());
     Source::UP src = factory->createSource(holder, ConfigKey("my", "my", "bar", "foo"));
-    ASSERT_TRUE(src.get() != NULL);
+    ASSERT_TRUE(src);
 
     src->getConfig();
     ASSERT_TRUE(holder->poll());
     ConfigUpdate::UP update(holder->provide());
-    ASSERT_TRUE(update.get() != NULL);
+    ASSERT_TRUE(update);
     const ConfigValue & value(update->getValue());
     ASSERT_EQUAL(1u, value.numLines());
     ASSERT_EQUAL("myField \"foobar\"", value.getLine(0));
@@ -78,12 +80,12 @@ TEST("requireThatFileSubscriptionReturnsCorrectConfig") {
     writeFile("my.cfg", "foobar");
     ConfigSubscriber s(FileSpec("my.cfg"));
     std::unique_ptr<ConfigHandle<MyConfig> > handle = s.subscribe<MyConfig>("my");
-    s.nextConfig(0);
+    s.nextConfigNow();
     std::unique_ptr<MyConfig> cfg = handle->getConfig();
-    ASSERT_TRUE(cfg.get() != NULL);
+    ASSERT_TRUE(cfg);
     ASSERT_EQUAL("foobar", cfg->myField);
     ASSERT_EQUAL("my", cfg->defName());
-    ASSERT_FALSE(s.nextConfig(100));
+    ASSERT_FALSE(s.nextConfig(100ms));
 }
 
 TEST("requireThatReconfigIsCalledWhenConfigChanges") {
@@ -92,28 +94,27 @@ TEST("requireThatReconfigIsCalledWhenConfigChanges") {
         IConfigContext::SP context(new ConfigContext(FileSpec("my.cfg")));
         ConfigSubscriber s(context);
         std::unique_ptr<ConfigHandle<MyConfig> > handle = s.subscribe<MyConfig>("");
-        s.nextConfig(0);
+        s.nextConfigNow();
         std::unique_ptr<MyConfig> cfg = handle->getConfig();
-        ASSERT_TRUE(cfg.get() != NULL);
+        ASSERT_TRUE(cfg);
         ASSERT_EQUAL("foo", cfg->myField);
         ASSERT_EQUAL("my", cfg->defName());
-        ASSERT_FALSE(s.nextConfig(3000));
+        ASSERT_FALSE(s.nextConfig(3000ms));
         writeFile("my.cfg", "bar");
         context->reload();
         bool correctValue = false;
-        FastOS_Time timer;
-        timer.SetNow();
-        while (!correctValue && timer.MilliSecsToNow() < 20000.0) {
+        fastos::StopWatch timer;
+        while (!correctValue && timer.elapsed().ms() < 20000.0) {
             LOG(info, "Testing value...");
-            if (s.nextConfig(1000)) {
+            if (s.nextConfig(1000ms)) {
                 break;
             }
         }
         cfg = handle->getConfig();
-        ASSERT_TRUE(cfg.get() != NULL);
+        ASSERT_TRUE(cfg);
         ASSERT_EQUAL("bar", cfg->myField);
         ASSERT_EQUAL("my", cfg->defName());
-        ASSERT_FALSE(s.nextConfig(1000));
+        ASSERT_FALSE(s.nextConfig(1000ms));
     }
 }
 
@@ -123,10 +124,10 @@ TEST("requireThatMultipleSubscribersCanSubscribeToSameFile") {
     {
         ConfigSubscriber s1(spec);
         std::unique_ptr<ConfigHandle<MyConfig> > h1 = s1.subscribe<MyConfig>("");
-        ASSERT_TRUE(s1.nextConfig(0));
+        ASSERT_TRUE(s1.nextConfigNow());
         ConfigSubscriber s2(spec);
         std::unique_ptr<ConfigHandle<MyConfig> > h2 = s2.subscribe<MyConfig>("");
-        ASSERT_TRUE(s2.nextConfig(0));
+        ASSERT_TRUE(s2.nextConfigNow());
     }
 }
 
@@ -135,13 +136,13 @@ TEST("requireThatCanSubscribeToDirectory") {
     ConfigSubscriber s(spec);
     ConfigHandle<FooConfig>::UP fooHandle = s.subscribe<FooConfig>("");
     ConfigHandle<BarConfig>::UP barHandle = s.subscribe<BarConfig>("");
-    ASSERT_TRUE(s.nextConfig(0));
+    ASSERT_TRUE(s.nextConfigNow());
     ASSERT_TRUE(fooHandle->isChanged());
     ASSERT_TRUE(barHandle->isChanged());
     std::unique_ptr<FooConfig> fooCfg = fooHandle->getConfig();
     std::unique_ptr<BarConfig> barCfg = barHandle->getConfig();
-    ASSERT_TRUE(fooCfg.get() != NULL);
-    ASSERT_TRUE(barCfg.get() != NULL);
+    ASSERT_TRUE(fooCfg);
+    ASSERT_TRUE(barCfg);
     ASSERT_EQUAL("foofoo", fooCfg->fooValue);
     ASSERT_EQUAL("barbar", barCfg->barValue);
 }
@@ -151,13 +152,13 @@ TEST("requireThatCanSubscribeToDirectoryWithEmptyCfgFile") {
     ConfigSubscriber s(spec);
     ConfigHandle<FoodefaultConfig>::UP fooHandle = s.subscribe<FoodefaultConfig>("");
     ConfigHandle<BarConfig>::UP barHandle = s.subscribe<BarConfig>("");
-    ASSERT_TRUE(s.nextConfig(0));
+    ASSERT_TRUE(s.nextConfigNow());
     ASSERT_TRUE(fooHandle->isChanged());
     ASSERT_TRUE(barHandle->isChanged());
     std::unique_ptr<FoodefaultConfig> fooCfg = fooHandle->getConfig();
     std::unique_ptr<BarConfig> barCfg = barHandle->getConfig();
-    ASSERT_TRUE(fooCfg.get() != NULL);
-    ASSERT_TRUE(barCfg.get() != NULL);
+    ASSERT_TRUE(fooCfg);
+    ASSERT_TRUE(barCfg);
     ASSERT_EQUAL("per", fooCfg->fooValue);
     ASSERT_EQUAL("barbar", barCfg->barValue);
 }
@@ -167,13 +168,13 @@ TEST("requireThatCanSubscribeToDirectoryWithNonExistingCfgFile") {
     ConfigSubscriber s(spec);
     ConfigHandle<FoodefaultConfig>::UP fooHandle = s.subscribe<FoodefaultConfig>("");
     ConfigHandle<BarConfig>::UP barHandle = s.subscribe<BarConfig>("");
-    ASSERT_TRUE(s.nextConfig(0));
+    ASSERT_TRUE(s.nextConfigNow());
     ASSERT_TRUE(fooHandle->isChanged());
     ASSERT_TRUE(barHandle->isChanged());
     std::unique_ptr<FoodefaultConfig> fooCfg = fooHandle->getConfig();
     std::unique_ptr<BarConfig> barCfg = barHandle->getConfig();
-    ASSERT_TRUE(fooCfg.get() != NULL);
-    ASSERT_TRUE(barCfg.get() != NULL);
+    ASSERT_TRUE(fooCfg);
+    ASSERT_TRUE(barCfg);
     ASSERT_EQUAL("per", fooCfg->fooValue);
     ASSERT_EQUAL("barbar", barCfg->barValue);
 }
@@ -183,11 +184,11 @@ TEST_F("requireThatDirSpecDoesNotMixNames",
     ConfigSubscriber s(f);
     ConfigHandle<BarConfig>::UP barHandle = s.subscribe<BarConfig>("");
     ConfigHandle<FoobarConfig>::UP foobarHandle = s.subscribe<FoobarConfig>("");
-    s.nextConfig(0);
+    s.nextConfigNow();
     std::unique_ptr<BarConfig> bar = barHandle->getConfig();
     std::unique_ptr<FoobarConfig> foobar = foobarHandle->getConfig();
-    ASSERT_TRUE(bar.get() != NULL);
-    ASSERT_TRUE(foobar.get() != NULL);
+    ASSERT_TRUE(bar);
+    ASSERT_TRUE(foobar);
     ASSERT_EQUAL("barbar", bar->barValue);
     ASSERT_EQUAL("foobarlol", foobar->fooBarValue);
 }
@@ -197,11 +198,11 @@ TEST_F("require that can subscribe multiple config ids of same config",
     ConfigSubscriber s(f1);
     ConfigHandle<BarConfig>::UP fooHandle = s.subscribe<BarConfig>("foo");
     ConfigHandle<BarConfig>::UP barHandle = s.subscribe<BarConfig>("bar");
-    s.nextConfig(0);
+    s.nextConfigNow();
     std::unique_ptr<BarConfig> bar1 = fooHandle->getConfig();
     std::unique_ptr<BarConfig> bar2 = barHandle->getConfig();
-    ASSERT_TRUE(bar1.get() != NULL);
-    ASSERT_TRUE(bar2.get() != NULL);
+    ASSERT_TRUE(bar1);
+    ASSERT_TRUE(bar2);
     ASSERT_EQUAL("barbar", bar1->barValue);
     ASSERT_EQUAL("foobarlol", bar2->barValue);
 }
diff --git a/config/src/tests/frt/frt.cpp b/config/src/tests/frt/frt.cpp
index b89ffe749b0..ba8279a1999 100644
--- a/config/src/tests/frt/frt.cpp
+++ b/config/src/tests/frt/frt.cpp
@@ -14,7 +14,7 @@
 #include <vespa/fnet/frt/frt.h>
 #include <vespa/fnet/frt/error.h>
 #include <vespa/config/frt/protocol.h>
-#include <vespa/fastos/time.h>
+#include <vespa/fastos/timestamp.h>
 #include <lz4.h>
 #include "config-my.h"
 #include "config-bar.h"
@@ -39,15 +39,14 @@ namespace {
         { }
         ConfigUpdate::UP provide() override { return ConfigUpdate::UP(); }
         void handle(ConfigUpdate::UP u) override { update = std::move(u); }
-        bool wait(uint64_t timeoutInMillis) override { (void) timeoutInMillis; return notified; }
+        bool wait(milliseconds timeoutInMillis) override { (void) timeoutInMillis; return notified; }
         bool poll() override { return notified; }
         void interrupt() override { }
 
         bool waitUntilResponse(int timeoutInMillis)
         {
-            FastOS_Time timer;
-            timer.SetNow();
-            while (timer.MilliSecsToNow() < timeoutInMillis) {
+            fastos::StopWatch timer;
+            while (timer.elapsed().ms() < timeoutInMillis) {
                 if (notified)
                     break;
                 FastOS_Thread::Sleep(100);
@@ -256,9 +255,8 @@ TEST_FF("require that request is config task is scheduled", SourceFixture(), FRT
     f2.src.getConfig();
     ASSERT_TRUE(f2.result.notified);
     f2.result.notified = false;
-    FastOS_Time timer;
-    timer.SetNow();
-    while (timer.MilliSecsToNow() < 10000) {
+    fastos::StopWatch timer;
+    while (timer.elapsed().ms() < 10000) {
         f1.conn.scheduler.CheckTasks();
         if (f2.result.notified)
             break;
diff --git a/config/src/tests/functiontest/functiontest.cpp b/config/src/tests/functiontest/functiontest.cpp
index 7fe87775f74..f7a57d6359b 100644
--- a/config/src/tests/functiontest/functiontest.cpp
+++ b/config/src/tests/functiontest/functiontest.cpp
@@ -110,7 +110,7 @@ struct TestFixture : public LazyTestFixture
     TestFixture(const std::string & dirName)
         : LazyTestFixture(dirName)
     {
-        ASSERT_TRUE(_subscriber.nextConfig(0));
+        ASSERT_TRUE(_subscriber.nextConfigNow());
         _config = _handle->getConfig();
     }
 };
@@ -120,7 +120,7 @@ struct ErrorFixture
     LazyTestFixture & f;
     ErrorFixture(LazyTestFixture & f1) : f(f1) { }
     void run() {
-        f._subscriber.nextConfig(0);
+        f._subscriber.nextConfigNow();
         bool thrown = false;
         try {
             f._handle->getConfig();
@@ -153,7 +153,7 @@ void attemptLacking(const std::string& param, bool isArray) {
         RawSpec spec(config.str());
         ConfigSubscriber subscriber(spec);
         ConfigHandle<FunctionTestConfig>::UP handle = subscriber.subscribe<FunctionTestConfig>("foo");
-        ASSERT_TRUE(subscriber.nextConfig(0));
+        ASSERT_TRUE(subscriber.nextConfigNow());
         std::unique_ptr<FunctionTestConfig> cfg = handle->getConfig();
         if (isArray) {
             // Arrays are empty by default
diff --git a/config/src/tests/raw_subscription/raw_subscription.cpp b/config/src/tests/raw_subscription/raw_subscription.cpp
index 6a3b5967f0c..478b4611bac 100644
--- a/config/src/tests/raw_subscription/raw_subscription.cpp
+++ b/config/src/tests/raw_subscription/raw_subscription.cpp
@@ -11,15 +11,15 @@ TEST("require that raw spec can create source factory")
 {
     RawSpec spec("myField \"foo\"\n");
     SourceFactory::UP raw = spec.createSourceFactory(TimingValues());
-    ASSERT_TRUE(raw.get() != NULL);
+    ASSERT_TRUE(raw);
     IConfigHolder::SP holder(new ConfigHolder());
     Source::UP src = raw->createSource(holder, ConfigKey("myid", "my", "bar", "foo"));
-    ASSERT_TRUE(src.get() != NULL);
+    ASSERT_TRUE(src);
 
     src->getConfig();
     ASSERT_TRUE(holder->poll());
     ConfigUpdate::UP update(holder->provide());
-    ASSERT_TRUE(update.get() != NULL);
+    ASSERT_TRUE(update);
     const ConfigValue & value(update->getValue());
     ASSERT_EQUAL(1u, value.numLines());
     ASSERT_EQUAL("myField \"foo\"", value.getLine(0));
@@ -30,9 +30,9 @@ TEST("requireThatRawSubscriptionReturnsCorrectConfig")
     RawSpec spec("myField \"foo\"\n");
     ConfigSubscriber s(spec);
     std::unique_ptr<ConfigHandle<MyConfig> > handle = s.subscribe<MyConfig>("myid");
-    s.nextConfig(0);
+    s.nextConfigNow();
     std::unique_ptr<MyConfig> cfg = handle->getConfig();
-    ASSERT_TRUE(cfg.get() != NULL);
+    ASSERT_TRUE(cfg);
     ASSERT_EQUAL("foo", cfg->myField);
     ASSERT_EQUAL("my", cfg->defName());
 }
diff --git a/config/src/tests/subscriber/subscriber.cpp b/config/src/tests/subscriber/subscriber.cpp
index 5663b145100..0c14928521e 100644
--- a/config/src/tests/subscriber/subscriber.cpp
+++ b/config/src/tests/subscriber/subscriber.cpp
@@ -5,14 +5,14 @@
 #include <vespa/config/common/configholder.h>
 #include <vespa/config/subscription/configsubscription.h>
 #include <vespa/config/common/exceptions.h>
-#include <vespa/fastos/time.h>
-#include <fstream>
+#include <vespa/fastos/timestamp.h>
 #include "config-foo.h"
 #include "config-bar.h"
 #include "config-baz.h"
 
 using namespace config;
 using namespace vespalib;
+using namespace std::chrono_literals;
 
 namespace {
 
@@ -78,13 +78,12 @@ namespace {
 
         MyManager() : idCounter(0), numCancel(0) { }
 
-        ConfigSubscription::SP subscribe(const ConfigKey & key, uint64_t timeoutInMillis) override {
+        ConfigSubscription::SP subscribe(const ConfigKey & key, milliseconds timeoutInMillis) override {
             (void) timeoutInMillis;
             IConfigHolder::SP holder(new ConfigHolder());
             _holders.push_back(holder);
 
-            ConfigSubscription::SP s(new ConfigSubscription(0, key, holder, Source::UP(new MySource())));
-            return s;
+            return std::make_shared<ConfigSubscription>(0, key, holder, std::make_unique<MySource>());
         }
         void unsubscribe(const ConfigSubscription::SP & subscription) override {
             (void) subscription;
@@ -93,7 +92,7 @@ namespace {
 
         void updateValue(size_t index, const ConfigValue & value, int64_t generation) {
             ASSERT_TRUE(index < _holders.size());
-            _holders[index]->handle(ConfigUpdate::UP(new ConfigUpdate(value, true, generation)));
+            _holders[index]->handle(std::make_unique<ConfigUpdate>(value, true, generation));
         }
 
         void updateGeneration(size_t index, int64_t generation) {
@@ -103,7 +102,7 @@ namespace {
             if (_holders[index]->poll()) {
                 value = _holders[index]->provide()->getValue();
             }
-            _holders[index]->handle(ConfigUpdate::UP(new ConfigUpdate(value, false, generation)));
+            _holders[index]->handle(std::make_unique<ConfigUpdate>(value, false, generation));
         }
 
         void reload(int64_t generation) override
@@ -151,7 +150,7 @@ namespace {
             h2 = s.subscribe<BarConfig>("myid");
             f1.updateValue(0, createFooValue("foo"), 1);
             f1.updateValue(1, createBarValue("bar"), 1);
-            ASSERT_TRUE(s.nextConfig(0));
+            ASSERT_TRUE(s.nextConfigNow());
             verifyConfig("foo", h1->getConfig());
             verifyConfig("bar", h2->getConfig());
         }
@@ -174,7 +173,7 @@ TEST_F("requireThatSubscriberCanGetMultipleTypes", SimpleFixture()) {
     ConfigSubscriber s(f.set);
     ConfigHandle<FooConfig>::UP h1 = s.subscribe<FooConfig>("myid");
     ConfigHandle<BarConfig>::UP h2 = s.subscribe<BarConfig>("myid");
-    ASSERT_TRUE(s.nextConfig(0));
+    ASSERT_TRUE(s.nextConfigNow());
     std::unique_ptr<FooConfig> foo = h1->getConfig();
     std::unique_ptr<BarConfig> bar = h2->getConfig();
     ASSERT_EQUAL("bar", foo->fooValue);
@@ -196,7 +195,7 @@ TEST_F("requireThatNextConfigMustBeCalled", SimpleFixture()) {
 TEST_F("requireThatSubscriptionsCannotBeAddedWhenFrozen", SimpleFixture()) {
     ConfigSubscriber s(f.set);
     ConfigHandle<FooConfig>::UP h1 = s.subscribe<FooConfig>("myid");
-    ASSERT_TRUE(s.nextConfig(0));
+    ASSERT_TRUE(s.nextConfigNow());
     bool thrown = false;
     try {
         ConfigHandle<BarConfig>::UP h2 = s.subscribe<BarConfig>("myid");
@@ -210,19 +209,19 @@ TEST_FF("requireThatNextConfigReturnsFalseUntilSubscriptionHasSucceeded", MyMana
     ConfigSubscriber s(IConfigContext::SP(new APIFixture(f2)));
     ConfigHandle<FooConfig>::UP h1 = s.subscribe<FooConfig>("myid");
     ConfigHandle<BarConfig>::UP h2 = s.subscribe<BarConfig>("myid");
-    ASSERT_FALSE(s.nextConfig(0));
-    ASSERT_FALSE(s.nextConfig(100));
+    ASSERT_FALSE(s.nextConfigNow());
+    ASSERT_FALSE(s.nextConfig(100ms));
     f1.updateValue(0, createFooValue("foo"), 1);
-    ASSERT_FALSE(s.nextConfig(100));
+    ASSERT_FALSE(s.nextConfig(100ms));
     f1.updateValue(1, createBarValue("bar"), 1);
-    ASSERT_TRUE(s.nextConfig(100));
+    ASSERT_TRUE(s.nextConfig(100ms));
 }
 
 TEST_FFF("requireThatNewGenerationIsFetchedOnReload", MyManager, APIFixture(f1), StandardFixture(f1, f2)) {
     verifyConfig("foo", f3.h1->getConfig());
     verifyConfig("bar", f3.h2->getConfig());
 
-    ASSERT_FALSE(f3.s.nextConfig(1000));
+    ASSERT_FALSE(f3.s.nextConfig(1000ms));
 
     verifyConfig("foo", f3.h1->getConfig());
     verifyConfig("bar", f3.h2->getConfig());
@@ -230,7 +229,7 @@ TEST_FFF("requireThatNewGenerationIsFetchedOnReload", MyManager, APIFixture(f1),
     f1.updateValue(0, createFooValue("foo2"), 3);
     f1.updateValue(1, createBarValue("bar2"), 3);
 
-    ASSERT_TRUE(f3.s.nextConfig(1000));
+    ASSERT_TRUE(f3.s.nextConfig(1000ms));
 
     verifyConfig("foo2", f3.h1->getConfig());
     verifyConfig("bar2", f3.h2->getConfig());
@@ -238,26 +237,26 @@ TEST_FFF("requireThatNewGenerationIsFetchedOnReload", MyManager, APIFixture(f1),
 
 TEST_FFF("requireThatAllConfigsMustGetTimestampUpdate", MyManager, APIFixture(f1), StandardFixture(f1, f2)) {
     f1.updateValue(0, createFooValue("foo2"), 2);
-    ASSERT_FALSE(f3.s.nextConfig(100));
+    ASSERT_FALSE(f3.s.nextConfig(100ms));
     verifyConfig("foo", f3.h1->getConfig());
     verifyConfig("bar", f3.h2->getConfig());
 
     f1.updateValue(0, createFooValue("foo2"), 3);
     f1.updateGeneration(1, 3);
 
-    ASSERT_TRUE(f3.s.nextConfig(0));
+    ASSERT_TRUE(f3.s.nextConfigNow());
     verifyConfig("foo2", f3.h1->getConfig());
     verifyConfig("bar", f3.h2->getConfig());
 }
 
 TEST_FFF("requireThatNextConfigMaySucceedIfInTheMiddleOfConfigUpdate", MyManager, APIFixture(f1), StandardFixture(f1, f2)) {
     f1.updateValue(0, createFooValue("foo2"), 2);
-    ASSERT_FALSE(f3.s.nextConfig(1000));
+    ASSERT_FALSE(f3.s.nextConfig(1000ms));
     verifyConfig("foo", f3.h1->getConfig());
     verifyConfig("bar", f3.h2->getConfig());
 
     f1.updateGeneration(1, 2);
-    ASSERT_TRUE(f3.s.nextConfig(0));
+    ASSERT_TRUE(f3.s.nextConfigNow());
     verifyConfig("foo2", f3.h1->getConfig());
     verifyConfig("bar", f3.h2->getConfig());
 }
@@ -265,21 +264,20 @@ TEST_FFF("requireThatNextConfigMaySucceedIfInTheMiddleOfConfigUpdate", MyManager
 TEST_FFF("requireThatCorrectConfigIsReturnedAfterTimestampUpdate", MyManager, APIFixture(f1), StandardFixture(f1, f2)) {
     f1.updateGeneration(0, 2);
     f1.updateGeneration(1, 2);
-    ASSERT_FALSE(f3.s.nextConfig(1000));
+    ASSERT_FALSE(f3.s.nextConfig(1000ms));
     verifyConfig("foo", f3.h1->getConfig());
     verifyConfig("bar", f3.h2->getConfig());
-    ASSERT_TRUE(f3.s.nextGeneration(0));
+    ASSERT_TRUE(f3.s.nextGenerationNow());
     verifyConfig("foo", f3.h1->getConfig());
     verifyConfig("bar", f3.h2->getConfig());
 }
 
 TEST_MT_FFF("requireThatConfigIsReturnedWhenUpdatedDuringNextConfig", 2, MyManager, APIFixture(f1), StandardFixture(f1, f2)) {
     if (thread_id == 0) {
-        FastOS_Time timer;
-        timer.SetNow();
-        ASSERT_TRUE(f3.s.nextConfig(10000));
-        ASSERT_TRUE(timer.MilliSecsToNow() > 250);
-        ASSERT_TRUE(timer.MilliSecsToNow() <= 5000);
+        fastos::StopWatch timer;
+        ASSERT_TRUE(f3.s.nextConfig(10000ms));
+        ASSERT_TRUE(timer.elapsed().ms() > 250);
+        ASSERT_TRUE(timer.elapsed().ms() <= 5000);
         verifyConfig("foo2", f3.h1->getConfig());
         verifyConfig("bar", f3.h2->getConfig());
     } else {
@@ -291,15 +289,14 @@ TEST_MT_FFF("requireThatConfigIsReturnedWhenUpdatedDuringNextConfig", 2, MyManag
 }
 
 TEST_FFF("requireThatConfigIsReturnedWhenUpdatedBeforeNextConfig", MyManager, APIFixture(f1), StandardFixture(f1, f2)) {
-    FastOS_Time timer;
-    timer.SetNow();
-    ASSERT_FALSE(f3.s.nextConfig(1000));
-    ASSERT_TRUE(timer.MilliSecsToNow() > 850);
+    fastos::StopWatch timer;
+    ASSERT_FALSE(f3.s.nextConfig(1000ms));
+    ASSERT_TRUE(timer.elapsed().ms() > 850);
     f1.updateGeneration(0, 2);
     f1.updateGeneration(1, 2);
-    timer.SetNow();
-    ASSERT_TRUE(f3.s.nextGeneration(10000));
-    ASSERT_TRUE(timer.MilliSecsToNow() <= 5000);
+    timer.restart();
+    ASSERT_TRUE(f3.s.nextGeneration(10000ms));
+    ASSERT_TRUE(timer.elapsed().ms() <= 5000);
     verifyConfig("foo", f3.h1->getConfig());
     verifyConfig("bar", f3.h2->getConfig());
 }
@@ -315,7 +312,7 @@ TEST_FFF("requireThatNothingCanBeCalledAfterClose", MyManager, APIFixture(f1), S
     ASSERT_FALSE(f3.s.isClosed());
     f3.s.close();
     ASSERT_TRUE(f3.s.isClosed());
-    ASSERT_FALSE(f3.s.nextConfig(100));
+    ASSERT_FALSE(f3.s.nextConfig(100ms));
     bool thrown = false;
     try {
         f3.h1->getConfig();
@@ -327,11 +324,10 @@ TEST_FFF("requireThatNothingCanBeCalledAfterClose", MyManager, APIFixture(f1), S
 
 TEST_MT_FFF("requireThatNextConfigIsInterruptedOnClose", 2, MyManager, APIFixture(f1), StandardFixture(f1, f2)) {
     if (thread_id == 0) {
-        FastOS_Time timer;
-        timer.SetNow();
-        ASSERT_FALSE(f3.s.nextConfig(5000));
-        ASSERT_TRUE(timer.MilliSecsToNow() >= 500.0);
-        ASSERT_TRUE(timer.MilliSecsToNow() < 60000.0);
+        fastos::StopWatch timer;
+        ASSERT_FALSE(f3.s.nextConfig(5000ms));
+        ASSERT_TRUE(timer.elapsed().ms() >= 500.0);
+        ASSERT_TRUE(timer.elapsed().ms() < 60000.0);
     } else {
         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
         f3.s.close();
@@ -342,20 +338,20 @@ TEST_FF("requireThatHandlesAreMarkedAsChanged", MyManager, APIFixture(f1)) {
     ConfigSubscriber s(IConfigContext::SP(new APIFixture(f2)));
     ConfigHandle<FooConfig>::UP h1 = s.subscribe<FooConfig>("myid2");
     ConfigHandle<BarConfig>::UP h2 = s.subscribe<BarConfig>("myid2");
-    EXPECT_FALSE(s.nextConfig(0));
+    EXPECT_FALSE(s.nextConfigNow());
 
     f1.updateValue(0, createFooValue("foo"), 1);
     f1.updateValue(1, createFooValue("bar"), 1);
-    EXPECT_TRUE(s.nextConfig(100));
+    EXPECT_TRUE(s.nextConfig(100ms));
     EXPECT_TRUE(h1->isChanged());
     EXPECT_TRUE(h2->isChanged());
 
-    EXPECT_FALSE(s.nextConfig(100));
+    EXPECT_FALSE(s.nextConfig(100ms));
     EXPECT_FALSE(h1->isChanged());
     EXPECT_FALSE(h2->isChanged());
     f1.updateValue(0, createFooValue("bar"), 2);
     f1.updateGeneration(1, 2);
-    EXPECT_TRUE(s.nextConfig(100));
+    EXPECT_TRUE(s.nextConfig(100ms));
     EXPECT_TRUE(h1->isChanged());
     EXPECT_FALSE(h2->isChanged());
 }
@@ -366,19 +362,19 @@ TEST_FF("requireThatNextGenerationMarksChanged", MyManager, APIFixture(f1)) {
     ConfigHandle<BarConfig>::UP h2 = s.subscribe<BarConfig>("myid2");
     f1.updateValue(0, createFooValue("foo"), 1);
     f1.updateValue(1, createFooValue("bar"), 1);
-    ASSERT_TRUE(s.nextGeneration(0));
+    ASSERT_TRUE(s.nextGenerationNow());
     ASSERT_TRUE(h1->isChanged());
     ASSERT_TRUE(h2->isChanged());
 
     f1.updateValue(0, createFooValue("bar"), 2);
     f1.updateGeneration(1, 2);
-    ASSERT_TRUE(s.nextGeneration(0));
+    ASSERT_TRUE(s.nextGenerationNow());
     ASSERT_TRUE(h1->isChanged());
     ASSERT_FALSE(h2->isChanged());
 
     f1.updateGeneration(0, 3);
     f1.updateGeneration(1, 3);
-    ASSERT_TRUE(s.nextGeneration(0));
+    ASSERT_TRUE(s.nextGenerationNow());
     ASSERT_FALSE(h1->isChanged());
     ASSERT_FALSE(h2->isChanged());
 }
@@ -389,23 +385,23 @@ TEST_FF("requireThatgetGenerationIsSet", MyManager, APIFixture(f1)) {
     ConfigHandle<BarConfig>::UP h2 = s.subscribe<BarConfig>("myid2");
     f1.updateValue(0, createFooValue("foo"), 1);
     f1.updateValue(1, createFooValue("bar"), 1);
-    ASSERT_TRUE(s.nextGeneration(0));
+    ASSERT_TRUE(s.nextGenerationNow());
     ASSERT_EQUAL(1, s.getGeneration());
     ASSERT_TRUE(h1->isChanged());
     ASSERT_TRUE(h2->isChanged());
-    ASSERT_FALSE(s.nextGeneration(0));
+    ASSERT_FALSE(s.nextGenerationNow());
     f1.updateGeneration(1, 2);
-    ASSERT_FALSE(s.nextGeneration(0));
+    ASSERT_FALSE(s.nextGenerationNow());
     ASSERT_EQUAL(1, s.getGeneration());
     f1.updateGeneration(0, 2);
-    ASSERT_TRUE(s.nextGeneration(0));
+    ASSERT_TRUE(s.nextGenerationNow());
     ASSERT_EQUAL(2, s.getGeneration());
 }
 
 TEST_FFF("requireThatConfigHandleStillHasConfigOnTimestampUpdate", MyManager, APIFixture(f1), StandardFixture(f1, f2)) {
     f1.updateGeneration(0, 2);
     f1.updateGeneration(1, 2);
-    ASSERT_TRUE(f3.s.nextGeneration(0));
+    ASSERT_TRUE(f3.s.nextGenerationNow());
     verifyConfig("foo", f3.h1->getConfig());
     verifyConfig("bar", f3.h2->getConfig());
 }
@@ -418,7 +414,7 @@ TEST_FF("requireThatTimeStamp0Works", MyManager, APIFixture(f1)) {
     f1.updateValue(0, createBarValue("bar"), 0);
     f1.updateValue(1, createFooValue("foo"), 0);
     f1.updateValue(2, createBazValue("baz"), 0);
-    ASSERT_TRUE(s.nextConfig(0));
+    ASSERT_TRUE(s.nextConfigNow());
     verifyConfig("bar", h2->getConfig());
     verifyConfig("foo", h1->getConfig());
     verifyConfig("baz", h3->getConfig());
@@ -432,58 +428,58 @@ TEST_FF("requireThatNextGenerationWorksWithManyConfigs", MyManager, APIFixture(f
     f1.updateValue(0, createBarValue("bar"), 1);
     f1.updateValue(1, createFooValue("foo"), 1);
     f1.updateValue(2, createBazValue("baz"), 1);
-    ASSERT_TRUE(s.nextGeneration(100));
+    ASSERT_TRUE(s.nextGeneration(100ms));
     verifyConfig("bar", h2->getConfig());
     verifyConfig("foo", h1->getConfig());
     verifyConfig("baz", h3->getConfig());
     int generation = 2;
 
     f1.updateGeneration(0, generation);
-    ASSERT_FALSE(s.nextGeneration(0));
+    ASSERT_FALSE(s.nextGenerationNow());
     f1.updateGeneration(1, generation);
-    ASSERT_FALSE(s.nextGeneration(0));
+    ASSERT_FALSE(s.nextGenerationNow());
     f1.updateGeneration(2, generation);
-    ASSERT_TRUE(s.nextGeneration(100));
+    ASSERT_TRUE(s.nextGeneration(100ms));
 
     generation++;
     f1.updateGeneration(0, generation);
-    ASSERT_FALSE(s.nextGeneration(0));
+    ASSERT_FALSE(s.nextGenerationNow());
     f1.updateGeneration(2, generation);
-    ASSERT_FALSE(s.nextGeneration(0));
+    ASSERT_FALSE(s.nextGenerationNow());
     f1.updateGeneration(1, generation);
-    ASSERT_TRUE(s.nextGeneration(100));
+    ASSERT_TRUE(s.nextGeneration(100ms));
 
     generation++;
     f1.updateGeneration(1, generation);
-    ASSERT_FALSE(s.nextGeneration(0));
+    ASSERT_FALSE(s.nextGenerationNow());
     f1.updateGeneration(0, generation);
-    ASSERT_FALSE(s.nextGeneration(0));
+    ASSERT_FALSE(s.nextGenerationNow());
     f1.updateGeneration(2, generation);
-    ASSERT_TRUE(s.nextGeneration(100));
+    ASSERT_TRUE(s.nextGeneration(100ms));
 
     generation++;
     f1.updateGeneration(1, generation);
-    ASSERT_FALSE(s.nextGeneration(0));
+    ASSERT_FALSE(s.nextGenerationNow());
     f1.updateGeneration(2, generation);
-    ASSERT_FALSE(s.nextGeneration(0));
+    ASSERT_FALSE(s.nextGenerationNow());
     f1.updateGeneration(0, generation);
-    ASSERT_TRUE(s.nextGeneration(100));
+    ASSERT_TRUE(s.nextGeneration(100ms));
 
     generation++;
     f1.updateGeneration(2, generation);
-    ASSERT_FALSE(s.nextGeneration(0));
+    ASSERT_FALSE(s.nextGenerationNow());
     f1.updateGeneration(0, generation);
-    ASSERT_FALSE(s.nextGeneration(0));
+    ASSERT_FALSE(s.nextGenerationNow());
     f1.updateGeneration(1, generation);
-    ASSERT_TRUE(s.nextGeneration(100));
+    ASSERT_TRUE(s.nextGeneration(100ms));
 
     generation++;
     f1.updateGeneration(2, generation);
-    ASSERT_FALSE(s.nextGeneration(0));
+    ASSERT_FALSE(s.nextGenerationNow());
     f1.updateGeneration(1, generation);
-    ASSERT_FALSE(s.nextGeneration(0));
+    ASSERT_FALSE(s.nextGenerationNow());
     f1.updateGeneration(0, generation);
-    ASSERT_TRUE(s.nextGeneration(100));
+    ASSERT_TRUE(s.nextGeneration(100ms));
 }
 
 TEST_FF("requireThatConfigSubscriberHandlesProxyCache", MyManager, APIFixture(f1)) {
@@ -491,13 +487,13 @@ TEST_FF("requireThatConfigSubscriberHandlesProxyCache", MyManager, APIFixture(f1
     ConfigHandle<FooConfig>::UP h1 = s.subscribe<FooConfig>("myid");
     f1.updateValue(0, createFooValue("foo"), 1);
     f1.updateGeneration(0, 2);
-    ASSERT_TRUE(s.nextConfig(0));
+    ASSERT_TRUE(s.nextConfigNow());
     ASSERT_EQUAL(2, s.getGeneration());
     ASSERT_TRUE(h1->isChanged());
     verifyConfig("foo", h1->getConfig());
 
     f1.updateGeneration(0, 3);
-    ASSERT_TRUE(s.nextGeneration(0));
+    ASSERT_TRUE(s.nextGenerationNow());
     ASSERT_EQUAL(3, s.getGeneration());
     ASSERT_FALSE(h1->isChanged());
     verifyConfig("foo", h1->getConfig());
@@ -508,11 +504,11 @@ TEST_MT_FF("requireThatConfigSubscriberWaitsUntilNextConfigSucceeds", 2, MyManag
         ConfigSubscriber s(IConfigContext::SP(new APIFixture(f2)));
         ConfigHandle<FooConfig>::UP h1 = s.subscribe<FooConfig>("myid");
         f1.updateValue(0, createFooValue("foo"), 1);
-        ASSERT_TRUE(s.nextConfig(0));
+        ASSERT_TRUE(s.nextConfigNow());
         f1.updateGeneration(0, 2);
-        ASSERT_FALSE(s.nextConfig(1000));
+        ASSERT_FALSE(s.nextConfig(1000ms));
         TEST_BARRIER();
-        ASSERT_TRUE(s.nextConfig(2000));
+        ASSERT_TRUE(s.nextConfig(2000ms));
         verifyConfig("foo2", h1->getConfig()); // First update is skipped
     } else {
         TEST_BARRIER();
diff --git a/config/src/tests/subscription/subscription.cpp b/config/src/tests/subscription/subscription.cpp
index bfa341fa982..5b8fc22bf4e 100644
--- a/config/src/tests/subscription/subscription.cpp
+++ b/config/src/tests/subscription/subscription.cpp
@@ -3,10 +3,11 @@
 #include <vespa/config/common/misc.h>
 #include <vespa/config/common/configholder.h>
 #include <vespa/config/subscription/configsubscription.h>
-#include <vespa/fastos/time.h>
+#include <vespa/fastos/timestamp.h>
 #include <config-my.h>
 
 using namespace config;
+using namespace std::chrono_literals;
 
 namespace {
 
@@ -55,33 +56,31 @@ TEST_FF("requireThatKeyIsReturned", ConfigKey("foo", "bar", "bim", "boo"), Subsc
 
 TEST_F("requireThatUpdateReturns", SubscriptionFixture(ConfigKey::create<MyConfig>("myid")))
 {
-    f1.holder->handle(ConfigUpdate::UP(new ConfigUpdate(ConfigValue(), 1, 1)));
-    ASSERT_TRUE(f1.sub.nextUpdate(0, 0));
+    f1.holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(), 1, 1));
+    ASSERT_TRUE(f1.sub.nextUpdate(0, 0ms));
     ASSERT_TRUE(f1.sub.hasChanged());
     ASSERT_EQUAL(1, f1.sub.getGeneration());
 }
 
 TEST_F("requireThatNextUpdateBlocks", SubscriptionFixture(ConfigKey::create<MyConfig>("myid")))
 {
-    ASSERT_FALSE(f1.sub.nextUpdate(0, 0));
-    f1.holder->handle(ConfigUpdate::UP(new ConfigUpdate(ConfigValue(), 1, 1)));
-    FastOS_Time timer;
-    timer.SetNow();
-    ASSERT_FALSE(f1.sub.nextUpdate(1, 500));
-    ASSERT_TRUE(timer.MilliSecsToNow() > 400.0);
+    ASSERT_FALSE(f1.sub.nextUpdate(0, 0ms));
+    f1.holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(), 1, 1));
+    fastos::StopWatch timer;
+    ASSERT_FALSE(f1.sub.nextUpdate(1, 500ms));
+    ASSERT_TRUE(timer.elapsed().ms() > 400.0);
 }
 
 TEST_MT_F("requireThatNextUpdateReturnsWhenNotified", 2, SubscriptionFixture(ConfigKey::create<MyConfig>("myid")))
 {
     if (thread_id == 0) {
-        FastOS_Time timer;
-        timer.SetNow();
-        f1.holder->handle(ConfigUpdate::UP(new ConfigUpdate(ConfigValue(), 1, 1)));
-        ASSERT_TRUE(f1.sub.nextUpdate(2, 5000));
-        ASSERT_TRUE(timer.MilliSecsToNow() > 200.0);
+        fastos::StopWatch timer;
+        f1.holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(), 1, 1));
+        ASSERT_TRUE(f1.sub.nextUpdate(2, 5000ms));
+        ASSERT_TRUE(timer.elapsed().ms() > 200.0);
     } else {
         std::this_thread::sleep_for(std::chrono::milliseconds(500));
-        f1.holder->handle(ConfigUpdate::UP(new ConfigUpdate(ConfigValue(), 1, 1)));
+        f1.holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(), 1, 1));
     }
 }
 
@@ -89,11 +88,10 @@ TEST_MT_F("requireThatNextUpdateReturnsWhenNotified", 2, SubscriptionFixture(Con
 TEST_MT_F("requireThatNextUpdateReturnsInterrupted", 2, SubscriptionFixture(ConfigKey::create<MyConfig>("myid")))
 {
     if (thread_id == 0) {
-        FastOS_Time timer;
-        timer.SetNow();
-        f1.holder->handle(ConfigUpdate::UP(new ConfigUpdate(ConfigValue(), 1, 1)));
-        ASSERT_TRUE(f1.sub.nextUpdate(1, 5000));
-        ASSERT_TRUE(timer.MilliSecsToNow() > 300.0);
+        fastos::StopWatch timer;
+        f1.holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(), 1, 1));
+        ASSERT_TRUE(f1.sub.nextUpdate(1, 5000ms));
+        ASSERT_TRUE(timer.elapsed().ms() > 300.0);
     } else {
         std::this_thread::sleep_for(std::chrono::milliseconds(500));
         f1.sub.close();
@@ -102,16 +100,16 @@ TEST_MT_F("requireThatNextUpdateReturnsInterrupted", 2, SubscriptionFixture(Conf
 
 TEST_F("Require that isChanged takes generation into account", SubscriptionFixture(ConfigKey::create<MyConfig>("myid")))
 {
-    f1.holder->handle(ConfigUpdate::UP(new ConfigUpdate(ConfigValue(std::vector<vespalib::string>(), "a"), true, 1)));
-    ASSERT_TRUE(f1.sub.nextUpdate(0, 0));
+    f1.holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(std::vector<vespalib::string>(), "a"), true, 1));
+    ASSERT_TRUE(f1.sub.nextUpdate(0, 0ms));
     f1.sub.flip();
     ASSERT_EQUAL(1, f1.sub.getLastGenerationChanged());
-    f1.holder->handle(ConfigUpdate::UP(new ConfigUpdate(ConfigValue(std::vector<vespalib::string>(), "b"), true, 2)));
-    ASSERT_TRUE(f1.sub.nextUpdate(1, 0));
+    f1.holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(std::vector<vespalib::string>(), "b"), true, 2));
+    ASSERT_TRUE(f1.sub.nextUpdate(1, 0ms));
     f1.sub.flip();
     ASSERT_EQUAL(2, f1.sub.getLastGenerationChanged());
-    f1.holder->handle(ConfigUpdate::UP(new ConfigUpdate(ConfigValue(), false, 3)));
-    ASSERT_TRUE(f1.sub.nextUpdate(2, 0));
+    f1.holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(), false, 3));
+    ASSERT_TRUE(f1.sub.nextUpdate(2, 0ms));
     f1.sub.flip();
     ASSERT_EQUAL(2, f1.sub.getLastGenerationChanged());
 }
diff --git a/config/src/vespa/config/helper/configgetter.h b/config/src/vespa/config/helper/configgetter.h
index 610b00cb66f..eb19715e3a5 100644
--- a/config/src/vespa/config/helper/configgetter.h
+++ b/config/src/vespa/config/helper/configgetter.h
@@ -17,10 +17,11 @@ 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, const std::shared_ptr<IConfigContext> & context, uint64_t subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT);
+    static std::unique_ptr<ConfigType> getConfig(int64_t &generation, const std::string & configId, const std::shared_ptr<IConfigContext> & context, milliseconds 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, const std::shared_ptr<IConfigContext> & context, uint64_t subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT);
+    static std::unique_ptr<ConfigType> getConfig(const std::string & configId, const std::shared_ptr<IConfigContext> & context, milliseconds 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 6d1f6fe78e5..588744144c2 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, const IConfigContext::SP & context, uint64_t subscribeTimeout)
+ConfigGetter<ConfigType>::getConfig(int64_t &generation, const std::string & configId, const IConfigContext::SP & context, milliseconds subscribeTimeout)
 {
     ConfigSubscriber s(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, const IConfigContext::SP & context, uint64_t subscribeTimeout)
+ConfigGetter<ConfigType>::getConfig(const std::string & configId, const IConfigContext::SP & context, milliseconds subscribeTimeout)
 {
     int64_t ignoreGeneration;
     return getConfig(ignoreGeneration, configId, context, subscribeTimeout);