remove most usage of LinkedPtr from vespa

21 files changed, 75 insertions, 85 deletions

diff --git a/metrics/src/tests/loadmetrictest.cpp b/metrics/src/tests/loadmetrictest.cpp
index 8ea3e9aee6d..97af77169de 100644
--- a/metrics/src/tests/loadmetrictest.cpp
+++ b/metrics/src/tests/loadmetrictest.cpp
@@ -61,7 +61,7 @@ namespace {
               metric("tack", "", "", this)
         { }
 
-        MetricSet* clone(std::vector<Metric::LP>& ownerList, CopyType copyType,
+        MetricSet* clone(std::vector<Metric::UP> &ownerList, CopyType copyType,
                          MetricSet* owner, bool includeUnused = false) const override
         {
             if (copyType != CLONE) {
@@ -86,7 +86,7 @@ LoadMetricTest::testClone(Metric::CopyType copyType)
     LoadMetric<MyMetricSet> metric(loadTypes, myset, &top);
     metric[loadTypes["foo"]].metric.addValue(5);
 
-    std::vector<Metric::LP> ownerList;
+    std::vector<Metric::UP> ownerList;
     MetricSet::UP copy(dynamic_cast<MetricSet*>(top.clone(ownerList, copyType, 0, true)));
     CPPUNIT_ASSERT(copy.get());
 
@@ -116,7 +116,7 @@ LoadMetricTest::testAdding()
     LoadMetric<MyMetricSet> metric(loadTypes, myset, &top);
     metric[loadTypes["foo"]].metric.addValue(5);
 
-    std::vector<Metric::LP> ownerList;
+    std::vector<Metric::UP> ownerList;
     MetricSet::UP copy(dynamic_cast<MetricSet*>(
                 top.clone(ownerList, Metric::INACTIVE, 0, false)));
     CPPUNIT_ASSERT(copy.get());
diff --git a/metrics/src/tests/metricsettest.cpp b/metrics/src/tests/metricsettest.cpp
index 9ce141feaf3..309794cad1e 100644
--- a/metrics/src/tests/metricsettest.cpp
+++ b/metrics/src/tests/metricsettest.cpp
@@ -147,7 +147,7 @@ MetricSetTest::uniqueTargetMetricsAreAddedToMetricSet()
 
     // 'doge' metric in set2 must be preserved even though it does not exist
     // in set1.
-    std::vector<Metric::LP> ownerList;
+    std::vector<Metric::UP> ownerList;
     set1.addToSnapshot(set2, ownerList);
 
     CPPUNIT_ASSERT(set2.getMetric("wow") != nullptr);
diff --git a/metrics/src/tests/snapshottest.cpp b/metrics/src/tests/snapshottest.cpp
index 2527a048df6..977f6e4ad68 100644
--- a/metrics/src/tests/snapshottest.cpp
+++ b/metrics/src/tests/snapshottest.cpp
@@ -40,7 +40,7 @@ struct SubSubMetricSet : public MetricSet {
 
     SubSubMetricSet(vespalib::stringref name, const LoadTypeSet& loadTypes_, MetricSet* owner = 0);
     ~SubSubMetricSet();
-    virtual MetricSet* clone(std::vector<Metric::LP>& ownerList, CopyType copyType,
+    virtual MetricSet* clone(std::vector<Metric::UP> &ownerList, CopyType copyType,
                              metrics::MetricSet* owner, bool includeUnused) const;
     void incValues();
 };
@@ -72,7 +72,7 @@ SubSubMetricSet::SubSubMetricSet(vespalib::stringref name, const LoadTypeSet& lo
 SubSubMetricSet::~SubSubMetricSet() { }
 
 MetricSet*
-SubSubMetricSet::clone(std::vector<Metric::LP>& ownerList,
+SubSubMetricSet::clone(std::vector<Metric::UP> &ownerList,
                        CopyType copyType, metrics::MetricSet* owner,
                        bool includeUnused) const
 {
@@ -114,7 +114,7 @@ struct SubMetricSet : public MetricSet {
     SubMetricSet(vespalib::stringref name, const LoadTypeSet& loadTypes_, MetricSet* owner = 0);
     ~SubMetricSet();
 
-    MetricSet* clone(std::vector<Metric::LP>& ownerList, CopyType copyType,
+    MetricSet* clone(std::vector<Metric::UP> &ownerList, CopyType copyType,
                      metrics::MetricSet* owner, bool includeUnused) const override;
 
     void incValues();
@@ -134,7 +134,7 @@ SubMetricSet::SubMetricSet(vespalib::stringref name, const LoadTypeSet& loadType
 SubMetricSet::~SubMetricSet() { }
 
 MetricSet*
-SubMetricSet::clone(std::vector<Metric::LP>& ownerList, CopyType copyType,
+SubMetricSet::clone(std::vector<Metric::UP> &ownerList, CopyType copyType,
                     metrics::MetricSet* owner, bool includeUnused) const
 {
     if (copyType == INACTIVE) {
diff --git a/metrics/src/tests/stresstest.cpp b/metrics/src/tests/stresstest.cpp
index 9eb13e00a79..905a79252d1 100644
--- a/metrics/src/tests/stresstest.cpp
+++ b/metrics/src/tests/stresstest.cpp
@@ -33,7 +33,7 @@ struct InnerMetricSet : public MetricSet {
     InnerMetricSet(const char* name, const LoadTypeSet& lt, MetricSet* owner = 0);
     ~InnerMetricSet();
 
-    MetricSet* clone(std::vector<Metric::LP>& ownerList, CopyType copyType,
+    MetricSet* clone(std::vector<Metric::UP> &ownerList, CopyType copyType,
                   MetricSet* owner, bool includeUnused) const override;
 };
 
@@ -52,7 +52,7 @@ InnerMetricSet::InnerMetricSet(const char* name, const LoadTypeSet& lt, MetricSe
 InnerMetricSet::~InnerMetricSet() { }
 
     MetricSet*
-    InnerMetricSet::clone(std::vector<Metric::LP>& ownerList, CopyType copyType,
+    InnerMetricSet::clone(std::vector<Metric::UP> &ownerList, CopyType copyType,
                      MetricSet* owner, bool includeUnused) const
 {
     if (copyType != CLONE) {
@@ -89,7 +89,7 @@ OuterMetricSet::OuterMetricSet(const LoadTypeSet& lt, MetricSet* owner)
 OuterMetricSet::~OuterMetricSet() { }
 
     struct Hammer : public document::Runnable {
-        typedef vespalib::LinkedPtr<Hammer> LP;
+        using UP = std::unique_ptr<Hammer>;
 
         OuterMetricSet& _metrics;
         const LoadTypeSet& _loadTypes;
@@ -141,9 +141,9 @@ StressTest::testStress()
 
     LOG(info, "Starting load givers");
     FastOS_ThreadPool threadPool(256 * 1024);
-    std::vector<Hammer::LP> hammers;
+    std::vector<Hammer::UP> hammers;
     for (uint32_t i=0; i<10; ++i) {
-        hammers.push_back(Hammer::LP(
+        hammers.push_back(Hammer::UP(
             new Hammer(metrics, loadTypes, threadPool)));
     }
     LOG(info, "Waiting to let loadgivers hammer a while");
diff --git a/metrics/src/tests/valuemetrictest.cpp b/metrics/src/tests/valuemetrictest.cpp
index 556592d518b..b06b6806a8b 100644
--- a/metrics/src/tests/valuemetrictest.cpp
+++ b/metrics/src/tests/valuemetrictest.cpp
@@ -178,7 +178,7 @@ void ValueMetricTest::testSmallAverage()
     m.addValue(0.0001);
     m.addValue(0.0002);
     m.addValue(0.0003);
-    std::vector<Metric::LP> ownerList;
+    std::vector<Metric::UP> ownerList;
     Metric::UP c(m.clone(ownerList, Metric::INACTIVE, 0, false));
     std::string expect("test average=0.0002 last=0.0003 min=0.0001 max=0.0003 count=3 total=0.0006");
     CPPUNIT_ASSERT_EQUAL(expect, m.toString());
diff --git a/metrics/src/vespa/metrics/countmetric.h b/metrics/src/vespa/metrics/countmetric.h
index 55f3b8a78b3..76eb166ef9a 100644
--- a/metrics/src/vespa/metrics/countmetric.h
+++ b/metrics/src/vespa/metrics/countmetric.h
@@ -93,7 +93,7 @@ public:
     }
 
     virtual CountMetric * clone(
-            std::vector<Metric::LP>&, CopyType type, MetricSet* owner,
+            std::vector<Metric::UP> &, CopyType type, MetricSet* owner,
             bool /*includeUnused*/) const
         { return new CountMetric<T, SumOnAdd>(*this, type, owner); }
 
@@ -125,7 +125,7 @@ public:
     virtual void printDebug(std::ostream&, const std::string& indent) const;
 
     virtual void addToPart(Metric&) const;
-    virtual void addToSnapshot(Metric&, std::vector<Metric::LP>&) const;
+    virtual void addToSnapshot(Metric&, std::vector<Metric::UP> &) const;
 };
 
 typedef CountMetric<uint64_t, true> LongCountMetric;
diff --git a/metrics/src/vespa/metrics/countmetric.hpp b/metrics/src/vespa/metrics/countmetric.hpp
index 187048ce596..836c50dc2b3 100644
--- a/metrics/src/vespa/metrics/countmetric.hpp
+++ b/metrics/src/vespa/metrics/countmetric.hpp
@@ -136,7 +136,7 @@ CountMetric<T, SumOnAdd>::dec(T value)
 template <typename T, bool SumOnAdd>
 void
 CountMetric<T, SumOnAdd>::addToSnapshot(
-        Metric& other, std::vector<Metric::LP>&) const
+        Metric& other, std::vector<Metric::UP> &) const
 {
     CountMetric<T, SumOnAdd>& o(
             reinterpret_cast<CountMetric<T, SumOnAdd>&>(other));
diff --git a/metrics/src/vespa/metrics/loadmetric.h b/metrics/src/vespa/metrics/loadmetric.h
index d31ef5efca4..2aec4cb7383 100644
--- a/metrics/src/vespa/metrics/loadmetric.h
+++ b/metrics/src/vespa/metrics/loadmetric.h
@@ -27,9 +27,9 @@ namespace metrics {
 
 template<typename MetricType>
 class LoadMetric : public MetricSet {
-    std::vector<Metric::LP> _ownerList;
-    typedef vespalib::LinkedPtr<MetricType> MetricTypeLP;
-    using MetricMap = vespalib::hash_map<uint32_t, MetricTypeLP>;
+    std::vector<Metric::UP> _ownerList;
+    using MetricTypeUP = std::unique_ptr<MetricType>;
+    using MetricMap = vespalib::hash_map<uint32_t, MetricTypeUP>;
     MetricMap _metrics;
     SumMetric<MetricType> _sum;
 
@@ -49,7 +49,7 @@ public:
      */
     LoadMetric(const LoadMetric<MetricType>& other, MetricSet* owner);
     ~LoadMetric();
-    MetricSet* clone(std::vector<Metric::LP>& ownerList,
+    MetricSet* clone(std::vector<Metric::UP> &ownerList,
                   CopyType copyType, MetricSet* owner,
                   bool includeUnused = false) const override;
 
diff --git a/metrics/src/vespa/metrics/loadmetric.hpp b/metrics/src/vespa/metrics/loadmetric.hpp
index 54171341b67..3741783180e 100644
--- a/metrics/src/vespa/metrics/loadmetric.hpp
+++ b/metrics/src/vespa/metrics/loadmetric.hpp
@@ -21,15 +21,15 @@ LoadMetric<MetricType>::LoadMetric(const LoadTypeSet& loadTypes, const MetricTyp
     setTags(metric.getTags());
     Tags noTags;
     for (uint32_t i=0; i<loadTypes.size(); ++i) {
-        MetricTypeLP copy(dynamic_cast<MetricType*>(metric.clone(_ownerList, CLONE, 0, false)));
+        MetricTypeUP copy(dynamic_cast<MetricType*>(metric.clone(_ownerList, CLONE, 0, false)));
         assert(copy.get());
         copy->setName(loadTypes[i].getName());
         copy->setTags(noTags);
-        _metrics[loadTypes[i].getId()] = copy;
         registerMetric(*copy);
         _sum.addMetricToSum(*copy);
+        _metrics[loadTypes[i].getId()] = std::move(copy);
     }
-    trim(_ownerList);
+    _ownerList.shrink_to_fit();
 }
 
 template<typename MetricType>
@@ -42,15 +42,15 @@ LoadMetric<MetricType>::LoadMetric(const LoadMetric<MetricType>& other, MetricSe
     setTags(other.getTags());
     Tags noTags;
     for (const auto & metric : other._metrics) {
-        MetricTypeLP copy(dynamic_cast<MetricType*>(metric.second->clone(_ownerList, CLONE, 0, false)));
+        MetricTypeUP copy(dynamic_cast<MetricType*>(metric.second->clone(_ownerList, CLONE, 0, false)));
         assert(copy.get());
         copy->setName(metric.second->getName());
         copy->setTags(noTags);
-        _metrics[metric.first] = copy;
         registerMetric(*copy);
         _sum.addMetricToSum(*copy);
+        _metrics[metric.first] = std::move(copy);
     }
-    trim(_ownerList);
+    _ownerList.shrink_to_fit();
 }
 
 template<typename MetricType>
@@ -58,7 +58,7 @@ LoadMetric<MetricType>::~LoadMetric() { }
 
 template<typename MetricType>
 MetricSet*
-LoadMetric<MetricType>::clone(std::vector<Metric::LP>& ownerList,
+LoadMetric<MetricType>::clone(std::vector<Metric::UP> &ownerList,
                               CopyType copyType, MetricSet* owner,
                               bool includeUnused) const
 {
@@ -73,7 +73,7 @@ MetricType&
 LoadMetric<MetricType>::getMetric(const LoadType& type) {
     MetricType* metric;
 
-    typename vespalib::hash_map<uint32_t, MetricTypeLP>::iterator it(
+    typename vespalib::hash_map<uint32_t, MetricTypeUP>::iterator it(
             _metrics.find(type.getId()));
     if (it == _metrics.end()) {
         it = _metrics.find(0);
@@ -89,7 +89,7 @@ template<typename MetricType>
 void
 LoadMetric<MetricType>::addMemoryUsage(MemoryConsumption& mc) const {
     ++mc._loadMetricCount;
-    mc._loadMetricMeta += (sizeof(Metric::LP) * _ownerList.capacity())
+    mc._loadMetricMeta += (sizeof(Metric::UP) * _ownerList.capacity())
                         + (sizeof(typename MetricMap::value_type) * _metrics.capacity());
     _sum.addMemoryUsage(mc);
     mc._loadMetricMeta += sizeof(LoadMetric<MetricType>)
diff --git a/metrics/src/vespa/metrics/metric.cpp b/metrics/src/vespa/metrics/metric.cpp
index 4560dfce1df..2259808a8be 100644
--- a/metrics/src/vespa/metrics/metric.cpp
+++ b/metrics/src/vespa/metrics/metric.cpp
@@ -236,7 +236,7 @@ Metric::printDebug(std::ostream& out, const std::string& indent) const
 
 Metric*
 Metric::assignValues(const Metric& m) {
-    std::vector<Metric::LP> ownerList;
+    std::vector<Metric::UP> ownerList;
     const_cast<Metric&>(m).addToSnapshot(*this, ownerList);
     // As this should only be called among active metrics, all metrics
     // should exist and owner list should thus always end up empty.
diff --git a/metrics/src/vespa/metrics/metric.h b/metrics/src/vespa/metrics/metric.h
index 959c9bd2411..c45920cfda4 100644
--- a/metrics/src/vespa/metrics/metric.h
+++ b/metrics/src/vespa/metrics/metric.h
@@ -3,8 +3,8 @@
 
 #include <vespa/vespalib/util/printable.h>
 #include <vespa/vespalib/stllike/string.h>
-#include <vespa/vespalib/util/linkedptr.h>
 #include <vespa/vespalib/util/regexp.h>
+#include <assert.h>
 
 namespace metrics {
 
@@ -17,15 +17,6 @@ class XmlWriterMetricVisitor;
 class MemoryConsumption;
 class NameHash;
 
-template<typename T>
-void trim(std::vector<T>& v) {
-    if (v.size() < v.capacity()) {
-        std::vector<T> copy(v);
-        copy.swap(v);
-    }
-    assert(v.size() == v.capacity());
-}
-
 /** Implement class to visit metrics. */
 struct MetricVisitor {
     virtual ~MetricVisitor() {}
@@ -107,7 +98,6 @@ public:
     using String = std::string;
     using stringref = vespalib::stringref;
     using UP = std::unique_ptr<Metric>;
-    using LP = vespalib::LinkedPtr<Metric>;
     using SP = std::shared_ptr<Metric>;
     using Tags = std::vector<Tag>;
 
@@ -151,7 +141,7 @@ public:
      *             unused metrics, but while generating sum metric sum in active
      *             metrics we want to. This has no affect if type is CLONE.
      */
-    virtual Metric* clone(std::vector<Metric::LP>& ownerList,
+    virtual Metric* clone(std::vector<Metric::UP> &ownerList,
                           CopyType type, MetricSet* owner,
                           bool includeUnused = false) const = 0;
 
@@ -200,7 +190,7 @@ public:
      * @param ownerList In case snapshot doesn't contain given metric, it can
      *                  create them and add them to ownerlist.
      */
-    virtual void addToSnapshot(Metric& m, std::vector<Metric::LP>& ownerList) const = 0;
+    virtual void addToSnapshot(Metric& m, std::vector<Metric::UP> &ownerList) const = 0;
 
     /**
      * For sum metrics to work with metric sets, metric sets need operator+=.
diff --git a/metrics/src/vespa/metrics/metricset.cpp b/metrics/src/vespa/metrics/metricset.cpp
index 397eaa85538..201b7c296e2 100644
--- a/metrics/src/vespa/metrics/metricset.cpp
+++ b/metrics/src/vespa/metrics/metricset.cpp
@@ -32,7 +32,7 @@ MetricSet::MetricSet(const String& name, Tags dimensions,
 }
 
 MetricSet::MetricSet(const MetricSet& other,
-                     std::vector<Metric::LP>& ownerList,
+                     std::vector<Metric::UP> &ownerList,
                      CopyType copyType,
                      MetricSet* owner,
                      bool includeUnused)
@@ -48,7 +48,7 @@ MetricSet::MetricSet(const MetricSet& other,
     for (const Metric* metric : other._metricOrder) {
         if (copyType != INACTIVE || includeUnused || metric->used()) {
             Metric* m = metric->clone(ownerList, copyType, this, includeUnused);
-            ownerList.push_back(Metric::LP(m));
+            ownerList.push_back(Metric::UP(m));
         }
     }
 }
@@ -56,7 +56,7 @@ MetricSet::MetricSet(const MetricSet& other,
 MetricSet::~MetricSet() { }
 
 MetricSet*
-MetricSet::clone(std::vector<Metric::LP>& ownerList, CopyType type,
+MetricSet::clone(std::vector<Metric::UP> &ownerList, CopyType type,
                  MetricSet* owner, bool includeUnused) const
 {
     return new MetricSet(*this, ownerList, type, owner, includeUnused);
@@ -224,7 +224,7 @@ namespace {
 }
 
 void
-MetricSet::addTo(Metric& other, std::vector<Metric::LP>* ownerList) const
+MetricSet::addTo(Metric& other, std::vector<Metric::UP> *ownerList) const
 {
     bool mustAdd = (ownerList == 0);
     MetricSet& o(static_cast<MetricSet&>(other));
@@ -239,9 +239,9 @@ MetricSet::addTo(Metric& other, std::vector<Metric::LP>* ownerList) const
         if (target == map2.end() || source->first < target->first) {
                 // Source missing in snapshot to add to. Lets create and add.
             if (!mustAdd && source->second->used()) {
-                Metric::LP copy(source->second->clone(*ownerList, INACTIVE, &o));
-                ownerList->push_back(copy);
+                Metric::UP copy(source->second->clone(*ownerList, INACTIVE, &o));
                 newMetrics[source->first] = copy.get();
+                ownerList->push_back(std::move(copy));
             }
             ++source;
         } else if (source->first == target->first) {
diff --git a/metrics/src/vespa/metrics/metricset.h b/metrics/src/vespa/metrics/metricset.h
index b0ab0f4845c..b7c012af277 100644
--- a/metrics/src/vespa/metrics/metricset.h
+++ b/metrics/src/vespa/metrics/metricset.h
@@ -12,6 +12,7 @@
 
 #include <map>
 #include <vespa/metrics/metric.h>
+#include <assert.h>
 
 namespace metrics {
 
@@ -33,7 +34,7 @@ public:
     MetricSet(const String& name, Tags dimensions,
               const String& description, MetricSet* owner = 0);
 
-    MetricSet(const MetricSet&, std::vector<Metric::LP>& ownerList,
+    MetricSet(const MetricSet&, std::vector<Metric::UP> &ownerList,
               CopyType, MetricSet* owner = 0, bool includeUnused = false);
     ~MetricSet();
 
@@ -52,7 +53,7 @@ public:
     void registerMetric(Metric& m);
     void unregisterMetric(Metric& m);
 
-    MetricSet* clone(std::vector<Metric::LP>& ownerList, CopyType type,
+    MetricSet* clone(std::vector<Metric::UP> &ownerList, CopyType type,
                      MetricSet* owner, bool includeUnused = false) const override;
 
     void reset();
@@ -75,7 +76,7 @@ public:
                 const_cast<const MetricSet*>(this)->getMetric(name));
     }
 
-    virtual void addToSnapshot(Metric& m, std::vector<Metric::LP>& o) const
+    virtual void addToSnapshot(Metric& m, std::vector<Metric::UP> &o) const
         { addTo(m, &o); }
 
     const std::vector<Metric*>& getRegisteredMetrics() const
@@ -109,7 +110,7 @@ private:
     void tagRegistrationAltered();
     const Metric* getMetricInternal(const String& name) const;
 
-    virtual void addTo(Metric&, std::vector<Metric::LP>* ownerList) const;
+    virtual void addTo(Metric&, std::vector<Metric::UP> *ownerList) const;
 };
 
 } // metrics
diff --git a/metrics/src/vespa/metrics/metricsnapshot.cpp b/metrics/src/vespa/metrics/metricsnapshot.cpp
index e8a50419751..1625de3b106 100644
--- a/metrics/src/vespa/metrics/metricsnapshot.cpp
+++ b/metrics/src/vespa/metrics/metricsnapshot.cpp
@@ -30,7 +30,7 @@ MetricSnapshot::MetricSnapshot(
     Metric* m = source.clone(_metrics, Metric::INACTIVE, 0, copyUnset);
     assert(m->isMetricSet());
     _snapshot.reset(static_cast<MetricSet*>(m));
-    trim(_metrics);
+    _metrics.shrink_to_fit();
 }
 
 MetricSnapshot::~MetricSnapshot() { }
@@ -46,7 +46,7 @@ MetricSnapshot::reset(time_t currentTime)
 void
 MetricSnapshot::recreateSnapshot(const MetricSet& metrics, bool copyUnset)
 {
-    std::vector<Metric::LP> newMetrics;
+    std::vector<Metric::UP> newMetrics;
     Metric* m = metrics.clone(newMetrics, Metric::INACTIVE, 0, copyUnset);
     assert(m->isMetricSet());
     std::unique_ptr<MetricSet> newSnapshot(static_cast<MetricSet*>(m));
@@ -54,7 +54,7 @@ MetricSnapshot::recreateSnapshot(const MetricSet& metrics, bool copyUnset)
     _snapshot->addToSnapshot(*newSnapshot, newMetrics);
     _snapshot = std::move(newSnapshot);
     _metrics.swap(newMetrics);
-    trim(_metrics);
+    _metrics.shrink_to_fit();
 }
 
 void
diff --git a/metrics/src/vespa/metrics/metricsnapshot.h b/metrics/src/vespa/metrics/metricsnapshot.h
index b6770d8d7e9..121099ccf3e 100644
--- a/metrics/src/vespa/metrics/metricsnapshot.h
+++ b/metrics/src/vespa/metrics/metricsnapshot.h
@@ -28,7 +28,7 @@ class MetricSnapshot
         // Keeps the metrics set view of the snapshot
     std::unique_ptr<MetricSet> _snapshot;
         // Snapshots must own their own metrics
-    mutable std::vector<Metric::LP> _metrics;
+    mutable std::vector<Metric::UP> _metrics;
 
 public:
     typedef std::unique_ptr<MetricSnapshot> UP;
diff --git a/metrics/src/vespa/metrics/printutils.cpp b/metrics/src/vespa/metrics/printutils.cpp
index 74db31de1ad..2373d2391ff 100644
--- a/metrics/src/vespa/metrics/printutils.cpp
+++ b/metrics/src/vespa/metrics/printutils.cpp
@@ -102,7 +102,7 @@ MetricSource::SourceMetricVisitor::visitMetric(const Metric& metric, bool) {
                 + metric.toString(),
                 VESPA_STRLOC);
     }
-    std::vector<Metric::LP> ownerList;
+    std::vector<Metric::UP> ownerList;
     _resultMetric.reset(metric.clone(ownerList, Metric::INACTIVE, 0));
     if (!ownerList.empty()) {
         throw vespalib::IllegalArgumentException(
diff --git a/metrics/src/vespa/metrics/summetric.h b/metrics/src/vespa/metrics/summetric.h
index 61a1d31e4f6..32444b3a75d 100644
--- a/metrics/src/vespa/metrics/summetric.h
+++ b/metrics/src/vespa/metrics/summetric.h
@@ -26,7 +26,7 @@ public:
     class StartValue
     {
     private:
-        std::vector<Metric::LP>     _startValueChildren;
+        std::vector<Metric::UP>     _startValueChildren;
         Metric::UP _startValue;
 
     public:
@@ -43,10 +43,10 @@ private:
 
 public:
     SumMetric(const String& name, const String& tags, const String& description, MetricSet* owner = 0);
-    SumMetric(const SumMetric<AddendMetric>& other, std::vector<Metric::LP>& ownerList, MetricSet* owner = 0);
+    SumMetric(const SumMetric<AddendMetric>& other, std::vector<Metric::UP> & ownerList, MetricSet* owner = 0);
     ~SumMetric();
 
-    Metric* clone( std::vector<Metric::LP>&, CopyType, MetricSet* owner, bool includeUnused = false) const override;
+    Metric* clone( std::vector<Metric::UP> &, CopyType, MetricSet* owner, bool includeUnused = false) const override;
 
     /**
      * If you want to support sums of collections of metrics that may
@@ -77,13 +77,13 @@ public:
     virtual void printDebug(std::ostream&, const std::string& indent="") const;
 
     virtual void addToPart(Metric&) const;
-    virtual void addToSnapshot(Metric&, std::vector<Metric::LP>&) const;
+    virtual void addToSnapshot(Metric&, std::vector<Metric::UP> &) const;
 
 private:
     friend class MetricManagerTest;
-    std::pair<std::vector<Metric::LP>, Metric::LP> generateSum() const;
+    std::pair<std::vector<Metric::UP>, Metric::UP> generateSum() const;
 
-    virtual void addTo(Metric&, std::vector<Metric::LP>* ownerList) const;
+    virtual void addTo(Metric&, std::vector<Metric::UP> *ownerList) const;
     bool isAddendType(const Metric* m) const;
 };
 
diff --git a/metrics/src/vespa/metrics/summetric.hpp b/metrics/src/vespa/metrics/summetric.hpp
index e2421f322d3..1a54067b01f 100644
--- a/metrics/src/vespa/metrics/summetric.hpp
+++ b/metrics/src/vespa/metrics/summetric.hpp
@@ -16,7 +16,7 @@ SumMetric<AddendMetric>::visit(MetricVisitor& visitor,
 {
     (void) tagAsAutoGenerated;
     if (_metricsToSum.empty()) return true;
-    std::pair<std::vector<Metric::LP>, Metric::LP> sum(generateSum());
+    std::pair<std::vector<Metric::UP>, Metric::UP> sum(generateSum());
     return sum.second->visit(visitor, true);
 }
 
@@ -31,7 +31,7 @@ SumMetric<AddendMetric>::SumMetric(const String& name, const String& tags,
 
 template<typename AddendMetric>
 SumMetric<AddendMetric>::SumMetric(const SumMetric<AddendMetric>& other,
-                                   std::vector<Metric::LP>& ownerList,
+                                   std::vector<Metric::UP> &ownerList,
                                    MetricSet* owner)
     : Metric(other, owner),
       _startValue(other._startValue),
@@ -94,7 +94,7 @@ SumMetric<AddendMetric>::~SumMetric() { }
 
 template<typename AddendMetric>
 Metric*
-SumMetric<AddendMetric>::clone(std::vector<Metric::LP>& ownerList,
+SumMetric<AddendMetric>::clone(std::vector<Metric::UP> &ownerList,
                                CopyType copyType, MetricSet* owner,
                                bool includeUnused) const
 {
@@ -139,19 +139,19 @@ template<typename AddendMetric>
 void
 SumMetric<AddendMetric>::addToPart(Metric& m) const
 {
-    std::pair<std::vector<Metric::LP>, Metric::LP> sum(generateSum());
+    std::pair<std::vector<Metric::UP>, Metric::UP> sum(generateSum());
     sum.second->addToPart(m);
 }
 
 template<typename AddendMetric>
 void
 SumMetric<AddendMetric>::addToSnapshot(
-        Metric& m, std::vector<Metric::LP>& ownerList) const
+        Metric& m, std::vector<Metric::UP> &ownerList) const
 {
     if (isAddendType(&m)) {
         // If the type to add to is an addend metric, it is part of an inactive
         // copy we need to add data to.
-        std::pair<std::vector<Metric::LP>, Metric::LP> sum(generateSum());
+        std::pair<std::vector<Metric::UP>, Metric::UP> sum(generateSum());
         sum.second->addToSnapshot(m, ownerList);
     }
 }
@@ -159,16 +159,16 @@ SumMetric<AddendMetric>::addToSnapshot(
 template<typename AddendMetric>
 void
 SumMetric<AddendMetric>::addTo(Metric& m,
-                               std::vector<Metric::LP>* ownerList) const
+                               std::vector<Metric::UP> *ownerList) const
 {
     if (ownerList == 0) {
-        std::pair<std::vector<Metric::LP>, Metric::LP> sum(generateSum());
+        std::pair<std::vector<Metric::UP>, Metric::UP> sum(generateSum());
         sum.second->addToPart(m);
     } else {
         if (isAddendType(&m)) {
             // If the type to add to is an addend metric, it is part of an
             // inactive copy we need to add data to.
-            std::pair<std::vector<Metric::LP>, Metric::LP> sum(generateSum());
+            std::pair<std::vector<Metric::UP>, Metric::UP> sum(generateSum());
             sum.second->addToSnapshot(m, *ownerList);
         }
     }
@@ -220,10 +220,10 @@ SumMetric<AddendMetric>::removeMetricFromSum(const AddendMetric &metric)
 }
 
 template<typename AddendMetric>
-std::pair<std::vector<Metric::LP>, Metric::LP>
+std::pair<std::vector<Metric::UP>, Metric::UP>
 SumMetric<AddendMetric>::generateSum() const
 {
-    std::pair<std::vector<Metric::LP>, Metric::LP> retVal;
+    std::pair<std::vector<Metric::UP>, Metric::UP> retVal;
     Metric* m = clone(retVal.first, INACTIVE, 0, true);
     m->setRegistered(_owner);
     retVal.second.reset(m);
@@ -234,7 +234,7 @@ template<typename AddendMetric>
 int64_t
 SumMetric<AddendMetric>::getLongValue(const stringref & id) const
 {
-    std::pair<std::vector<Metric::LP>, Metric::LP> sum(generateSum());
+    std::pair<std::vector<Metric::UP>, Metric::UP> sum(generateSum());
     if (sum.second.get() == 0) return 0;
     return sum.second->getLongValue(id);
 }
@@ -243,7 +243,7 @@ template<typename AddendMetric>
 double
 SumMetric<AddendMetric>::getDoubleValue(const stringref & id) const
 {
-    std::pair<std::vector<Metric::LP>, Metric::LP> sum(generateSum());
+    std::pair<std::vector<Metric::UP>, Metric::UP> sum(generateSum());
     if (sum.second.get() == 0) return 0.0;
     return sum.second->getDoubleValue(id);
 }
@@ -252,7 +252,7 @@ template<typename AddendMetric>
 bool
 SumMetric<AddendMetric>::logEvent(const String & fullName) const
 {
-    std::pair<std::vector<Metric::LP>, Metric::LP> sum(generateSum());
+    std::pair<std::vector<Metric::UP>, Metric::UP> sum(generateSum());
     if (sum.second.get() == 0) return false;
     return sum.second->logEvent(fullName);
 }
@@ -263,7 +263,7 @@ SumMetric<AddendMetric>::print(std::ostream& out, bool verbose,
                                const std::string& indent,
                                uint64_t secondsPassed) const
 {
-    std::pair<std::vector<Metric::LP>, Metric::LP> sum(generateSum());
+    std::pair<std::vector<Metric::UP>, Metric::UP> sum(generateSum());
     if (sum.second.get() == 0) return;
     sum.second->print(out, verbose, indent, secondsPassed);
 }
diff --git a/metrics/src/vespa/metrics/updatehook.h b/metrics/src/vespa/metrics/updatehook.h
index 2b2f4466b54..20d7c502a45 100644
--- a/metrics/src/vespa/metrics/updatehook.h
+++ b/metrics/src/vespa/metrics/updatehook.h
@@ -2,7 +2,6 @@
 #pragma once
 
 #include <vespa/vespalib/util/sync.h>
-#include <vespa/vespalib/util/linkedptr.h>
 
 namespace metrics {
 
@@ -15,7 +14,7 @@ class UpdateHook {
     friend class MetricManager;
 
 public:
-    typedef vespalib::LinkedPtr<UpdateHook> LP;
+    using UP = std::unique_ptr<UpdateHook>;
     using MetricLockGuard = vespalib::MonitorGuard;
 
     UpdateHook(const char* name) : _name(name), _nextCall(0), _period(0) {}
diff --git a/metrics/src/vespa/metrics/valuemetric.h b/metrics/src/vespa/metrics/valuemetric.h
index ce132e3ffdd..8c02857bcd7 100644
--- a/metrics/src/vespa/metrics/valuemetric.h
+++ b/metrics/src/vespa/metrics/valuemetric.h
@@ -97,7 +97,7 @@ public:
     void logOnlyIfSet() { _values.removeFlag(LOG_IF_UNSET); }
 
     virtual ValueMetric * clone(
-            std::vector<Metric::LP>&, CopyType type, MetricSet* owner,
+            std::vector<Metric::UP> &, CopyType type, MetricSet* owner,
             bool /*includeUnused*/) const
         { return new ValueMetric<AvgVal,TotVal,SumOnAdd>(*this, type, owner); }
 
@@ -150,7 +150,7 @@ public:
     virtual void printDebug(std::ostream&, const std::string& indent) const;
 
     virtual void addToPart(Metric&) const;
-    virtual void addToSnapshot(Metric&, std::vector<Metric::LP>&) const;
+    virtual void addToSnapshot(Metric&, std::vector<Metric::UP> &) const;
 };
 
 typedef ValueMetric<double, double, true> DoubleValueMetric;
diff --git a/metrics/src/vespa/metrics/valuemetric.hpp b/metrics/src/vespa/metrics/valuemetric.hpp
index 08c639e8069..65a0c2bb5b2 100644
--- a/metrics/src/vespa/metrics/valuemetric.hpp
+++ b/metrics/src/vespa/metrics/valuemetric.hpp
@@ -79,7 +79,7 @@ void ValueMetric<AvgVal, TotVal, SumOnAdd>::dec(AvgVal decVal)
 template<typename AvgVal, typename TotVal, bool SumOnAdd>
 void
 ValueMetric<AvgVal, TotVal, SumOnAdd>::addToSnapshot(
-        Metric& other, std::vector<Metric::LP>&) const
+        Metric& other, std::vector<Metric::UP> &) const
 {
     ValueMetric<AvgVal, TotVal, SumOnAdd>& o(
             reinterpret_cast<ValueMetric<AvgVal, TotVal, SumOnAdd>&>(other));