Use fixed size array since it will not change.

6 files changed, 50 insertions, 58 deletions

diff --git a/metrics/src/vespa/metrics/countmetric.hpp b/metrics/src/vespa/metrics/countmetric.hpp
index e0e7c235f47..469986e797a 100644
--- a/metrics/src/vespa/metrics/countmetric.hpp
+++ b/metrics/src/vespa/metrics/countmetric.hpp
@@ -16,9 +16,9 @@ CountMetric<T, SumOnAdd>::CountMetric(const String& name, Tags dimensions,
 
 template <typename T, bool SumOnAdd>
 CountMetric<T, SumOnAdd>::CountMetric(const CountMetric<T, SumOnAdd>& other,
-                                      CopyType copyType, MetricSet* owner)
+                                      CopyType , MetricSet* owner)
     : AbstractCountMetric(other, owner),
-      _values(other._values, copyType == CLONE ? other._values.size() : 1)
+      _values(other._values)
 {
 }
 
@@ -117,8 +117,7 @@ void
 CountMetric<T, SumOnAdd>::addToSnapshot(
         Metric& other, std::vector<Metric::UP> &) const
 {
-    CountMetric<T, SumOnAdd>& o(
-            reinterpret_cast<CountMetric<T, SumOnAdd>&>(other));
+    CountMetric<T, SumOnAdd>& o(reinterpret_cast<CountMetric<T, SumOnAdd>&>(other));
     o.inc(_values.getValues()._value);
 }
 
@@ -126,8 +125,7 @@ template <typename T, bool SumOnAdd>
 void
 CountMetric<T, SumOnAdd>::addToPart(Metric& other) const
 {
-    CountMetric<T, SumOnAdd>& o(
-            reinterpret_cast<CountMetric<T, SumOnAdd>&>(other));
+    CountMetric<T, SumOnAdd>& o(reinterpret_cast<CountMetric<T, SumOnAdd>&>(other));
     if (SumOnAdd) {
         o.inc(_values.getValues()._value);
     } else {
@@ -158,9 +156,7 @@ void
 CountMetric<T, SumOnAdd>::addMemoryUsage(MemoryConsumption& mc) const
 {
     ++mc._countMetricCount;
-    mc._countMetricValues += _values.getMemoryUsageAllocatedInternally();
-    mc._countMetricMeta += sizeof(CountMetric<T, SumOnAdd>)
-                         - sizeof(Metric);
+    mc._countMetricMeta += sizeof(CountMetric<T, SumOnAdd>) - sizeof(Metric);
     Metric::addMemoryUsage(mc);
 }
 
diff --git a/metrics/src/vespa/metrics/countmetricvalues.h b/metrics/src/vespa/metrics/countmetricvalues.h
index 981c4c07631..902b5294c28 100644
--- a/metrics/src/vespa/metrics/countmetricvalues.h
+++ b/metrics/src/vespa/metrics/countmetricvalues.h
@@ -23,7 +23,9 @@ struct CountMetricValues : public MetricValueClass {
     T _value;
 
     struct AtomicImpl {
-        std::atomic<T> _value {0};
+        AtomicImpl() noexcept : _value(0) {}
+        AtomicImpl(const AtomicImpl & rhs) noexcept : _value(rhs._value.load(std::memory_order_relaxed)) {}
+        std::atomic<T> _value;
     };
 
     void relaxedStoreInto(AtomicImpl& target) const noexcept {
diff --git a/metrics/src/vespa/metrics/metricvalueset.h b/metrics/src/vespa/metrics/metricvalueset.h
index bb2a7409ce7..b38cab4bfac 100644
--- a/metrics/src/vespa/metrics/metricvalueset.h
+++ b/metrics/src/vespa/metrics/metricvalueset.h
@@ -49,20 +49,16 @@ struct MetricValueClass {
 template<typename ValueClass>
 class MetricValueSet {
     using AtomicValues = typename ValueClass::AtomicImpl;
-    std::vector<AtomicValues> _values;
-    std::atomic<uint32_t> _activeValueIndex;
-    std::atomic<uint32_t> _flags;
+    std::array<AtomicValues, 3> _values;
+    std::atomic<uint32_t>       _activeValueIndex;
+    std::atomic<uint32_t>       _flags;
 
     enum Flag { RESET = 1 };
     bool isReset() const { return hasFlag(RESET); }
-
-    void validateCorrectValueSuperClass(const MetricValueClass&) {}
-
 public:
-    MetricValueSet(uint32_t copyCount = 3);
-    MetricValueSet(const MetricValueSet& other, uint32_t copyCount = 3);
-
-    MetricValueSet& operator=(const MetricValueSet& other);
+    MetricValueSet() noexcept;
+    MetricValueSet(const MetricValueSet&) noexcept;
+    MetricValueSet& operator=(const MetricValueSet& other) noexcept;
 
     /** Get the current values. */
     ValueClass getValues() const;
@@ -82,10 +78,6 @@ public:
 
     std::string toString();
 
-    uint32_t getMemoryUsageAllocatedInternally() const {
-        return _values.capacity() * sizeof(ValueClass);
-    }
-
     uint32_t size() const { return _values.size(); }
 
     bool hasFlag(uint32_t flags) const {
diff --git a/metrics/src/vespa/metrics/metricvalueset.hpp b/metrics/src/vespa/metrics/metricvalueset.hpp
index fa42708f35e..ada833b20e2 100644
--- a/metrics/src/vespa/metrics/metricvalueset.hpp
+++ b/metrics/src/vespa/metrics/metricvalueset.hpp
@@ -7,23 +7,21 @@
 namespace metrics {
 
 template<typename ValueClass>
-MetricValueSet<ValueClass>::MetricValueSet(uint32_t copyCount)
-    : _values(copyCount),
+MetricValueSet<ValueClass>::MetricValueSet() noexcept
+    : _values(),
       _activeValueIndex(0),
       _flags(0)
 { }
 
 template<typename ValueClass>
-MetricValueSet<ValueClass>::MetricValueSet(const MetricValueSet& other, uint32_t copyCount)
-    : _values(copyCount),
-      _activeValueIndex(0),
-      _flags(other._flags.load(std::memory_order_relaxed))
-{
-    setValues(other.getValues());
-}
+MetricValueSet<ValueClass>::MetricValueSet(const MetricValueSet& rhs) noexcept
+    : _values(rhs._values),
+      _activeValueIndex(rhs._activeValueIndex.load(std::memory_order_relaxed)),
+      _flags(rhs._flags.load(std::memory_order_relaxed))
+{ }
 
 template<typename ValueClass>
-MetricValueSet<ValueClass> & MetricValueSet<ValueClass>::operator=(const MetricValueSet& other)
+MetricValueSet<ValueClass> & MetricValueSet<ValueClass>::operator=(const MetricValueSet& other) noexcept
 {
     setValues(other.getValues());
     return *this;
@@ -47,11 +45,9 @@ MetricValueSet<ValueClass>::getValues() const {
 template<typename ValueClass>
 bool
 MetricValueSet<ValueClass>::setValues(const ValueClass& values) {
-    validateCorrectValueSuperClass(values);
     // Only setter-thread can write _activeValueIndex, so relaxed
     // load suffices.
-    uint32_t nextIndex = (_activeValueIndex.load(std::memory_order_relaxed)
-                          + 1) % _values.size();
+    uint32_t nextIndex = (_activeValueIndex.load(std::memory_order_relaxed) + 1) % _values.size();
     // Reset flag is loaded/stored with relaxed semantics since it does not
     // carry data dependencies. _activeValueIndex has a dependency on
     // _values, however, so we must ensure that stores are published
diff --git a/metrics/src/vespa/metrics/valuemetric.hpp b/metrics/src/vespa/metrics/valuemetric.hpp
index 5e0ef95e9e5..a5273307b5c 100644
--- a/metrics/src/vespa/metrics/valuemetric.hpp
+++ b/metrics/src/vespa/metrics/valuemetric.hpp
@@ -20,9 +20,9 @@ ValueMetric<AvgVal, TotVal, SumOnAdd>::ValueMetric(
 template<typename AvgVal, typename TotVal, bool SumOnAdd>
 ValueMetric<AvgVal, TotVal, SumOnAdd>::ValueMetric(
         const ValueMetric<AvgVal, TotVal, SumOnAdd>& other,
-        CopyType copyType, MetricSet* owner)
+        CopyType, MetricSet* owner)
     : AbstractValueMetric(other, owner),
-      _values(other._values, copyType == CLONE ? other._values.size() : 1)
+      _values(other._values)
 {}
 
 template<typename AvgVal, typename TotVal, bool SumOnAdd>
@@ -66,11 +66,9 @@ 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::UP> &) const
+ValueMetric<AvgVal, TotVal, SumOnAdd>::addToSnapshot(Metric& other, std::vector<Metric::UP> &) const
 {
-    ValueMetric<AvgVal, TotVal, SumOnAdd>& o(
-            reinterpret_cast<ValueMetric<AvgVal, TotVal, SumOnAdd>&>(other));
+    auto & o = reinterpret_cast<ValueMetric<AvgVal, TotVal, SumOnAdd>&>(other);
     if (_values.getValues()._count == 0) return; // Don't add if not set
     o.add(_values.getValues(), false);
 }
@@ -79,9 +77,7 @@ template<typename AvgVal, typename TotVal, bool SumOnAdd>
 void
 ValueMetric<AvgVal, TotVal, SumOnAdd>::addToPart(Metric& other) const
 {
-    ValueMetric<AvgVal, TotVal, SumOnAdd>& o(
-            reinterpret_cast<ValueMetric<AvgVal, TotVal, SumOnAdd>&>(
-                other));
+    auto & o = reinterpret_cast<ValueMetric<AvgVal, TotVal, SumOnAdd>&>(other);
     o.add(_values.getValues(), SumOnAdd);
 }
 
@@ -229,10 +225,8 @@ ValueMetric<AvgVal, TotVal, SumOnAdd>::getDoubleValue(stringref id) const
         return getAverage();
     if (id == "count") return static_cast<double>(values._count);
     if (id == "total") return static_cast<double>(values._total);
-    if (id == "min") return static_cast<double>(
-            values._count > 0 ? values._min : 0);
-    if (id == "max") return static_cast<double>(
-            values._count > 0 ? values._max : 0);
+    if (id == "min") return static_cast<double>(values._count > 0 ? values._min : 0);
+    if (id == "max") return static_cast<double>(values._count > 0 ? values._max : 0);
     throw vespalib::IllegalArgumentException(
             "No value " + vespalib::string(id) + " in average metric.", VESPA_STRLOC);
 }
@@ -242,9 +236,7 @@ void
 ValueMetric<AvgVal, TotVal, SumOnAdd>::addMemoryUsage(MemoryConsumption& mc) const
 {
     ++mc._valueMetricCount;
-    mc._valueMetricValues += _values.getMemoryUsageAllocatedInternally();
-    mc._valueMetricMeta += sizeof(ValueMetric<AvgVal, TotVal, SumOnAdd>)
-                         - sizeof(Metric);
+    mc._valueMetricMeta += sizeof(ValueMetric<AvgVal, TotVal, SumOnAdd>) - sizeof(Metric);
     Metric::addMemoryUsage(mc);
 }
 
diff --git a/metrics/src/vespa/metrics/valuemetricvalues.h b/metrics/src/vespa/metrics/valuemetricvalues.h
index 905d334214c..43a6e68c754 100644
--- a/metrics/src/vespa/metrics/valuemetricvalues.h
+++ b/metrics/src/vespa/metrics/valuemetricvalues.h
@@ -25,11 +25,25 @@ struct ValueMetricValues : MetricValueClass {
     TotVal _total;
 
     struct AtomicImpl {
-        std::atomic<uint32_t> _count {0};
-        std::atomic<AvgVal> _min {std::numeric_limits<AvgVal>::max()};
-        std::atomic<AvgVal> _max {std::numeric_limits<AvgVal>::min()};
-        std::atomic<AvgVal> _last {0};
-        std::atomic<TotVal> _total {0};
+        AtomicImpl() noexcept
+            : _count(0),
+              _min(std::numeric_limits<AvgVal>::max()),
+              _max(std::numeric_limits<AvgVal>::min()),
+              _last(0),
+              _total(0)
+        {}
+        AtomicImpl(const AtomicImpl & rhs) noexcept
+                : _count(rhs._count.load(std::memory_order_relaxed)),
+                  _min(rhs._min.load(std::memory_order_relaxed)),
+                  _max(rhs._max.load(std::memory_order_relaxed)),
+                  _last(rhs._last.load(std::memory_order_relaxed)),
+                  _total(rhs._total.load(std::memory_order_relaxed))
+        {}
+        std::atomic<uint32_t> _count;
+        std::atomic<AvgVal>   _min;
+        std::atomic<AvgVal>   _max;
+        std::atomic<AvgVal>   _last;
+        std::atomic<TotVal>   _total;
     };
 
     ValueMetricValues();