Merge pull request #31016 from vespa-engine/balder/use-std-vector

Use std::vector instead of vespalib::Array

17 files changed, 146 insertions, 159 deletions

diff --git a/vespalib/src/tests/btree/btree_test.cpp b/vespalib/src/tests/btree/btree_test.cpp
index a43fbf01ad1..c8aa7feb123 100644
--- a/vespalib/src/tests/btree/btree_test.cpp
+++ b/vespalib/src/tests/btree/btree_test.cpp
@@ -1072,7 +1072,7 @@ adjustAllocatedBytes(size_t nodeCount, size_t nodeSize)
 TEST_F(BTreeTest, require_that_memory_usage_is_calculated)
 {
     constexpr size_t BASE_ALLOCATED = 28744u;
-    constexpr size_t BASE_USED = 24936;
+    constexpr size_t BASE_USED = 24920;
     typedef BTreeNodeAllocator<int32_t, int8_t,
         btree::NoAggregated,
         MyTraits::INTERNAL_SLOTS, MyTraits::LEAF_SLOTS> NodeAllocator;
diff --git a/vespalib/src/tests/datastore/array_store/array_store_test.cpp b/vespalib/src/tests/datastore/array_store/array_store_test.cpp
index dc248ec2fed..a65a73ad9bb 100644
--- a/vespalib/src/tests/datastore/array_store/array_store_test.cpp
+++ b/vespalib/src/tests/datastore/array_store/array_store_test.cpp
@@ -278,10 +278,10 @@ TYPED_TEST(NumberStoreTest, control_static_sizes) {
     MemoryUsage usage = this->store.getMemoryUsage();
     if (this->simple_buffers()) {
         EXPECT_EQ(202140u, usage.allocatedBytes());
-        EXPECT_EQ(197680u, usage.usedBytes());
+        EXPECT_EQ(197648u, usage.usedBytes());
     } else {
         EXPECT_EQ(202328u, usage.allocatedBytes());
-        EXPECT_EQ(197568u, usage.usedBytes());
+        EXPECT_EQ(197536u, usage.usedBytes());
     }
 }
 
diff --git a/vespalib/src/tests/datastore/datastore/datastore_test.cpp b/vespalib/src/tests/datastore/datastore/datastore_test.cpp
index 540fb05a8a6..e0557226e3c 100644
--- a/vespalib/src/tests/datastore/datastore/datastore_test.cpp
+++ b/vespalib/src/tests/datastore/datastore/datastore_test.cpp
@@ -475,7 +475,7 @@ TEST(DataStoreTest, require_that_memory_stats_are_calculated)
 TEST(DataStoreTest, require_that_memory_usage_is_calculated)
 {
     constexpr size_t BASE_ALLOCATED = 4228;
-    constexpr size_t BASE_USED = 284;
+    constexpr size_t BASE_USED = 276;
     MyStore s;
     MyRef r = s.addEntry(10);
     s.addEntry(20);
@@ -494,7 +494,7 @@ TEST(DataStoreTest, require_that_memory_usage_is_calculated)
 TEST(DataStoreTest, require_that_we_can_disable_elemement_hold_list)
 {
     constexpr size_t BASE_ALLOCATED = 4228;
-    constexpr size_t BASE_USED = 284;
+    constexpr size_t BASE_USED = 276;
     MyStore s;
     MyRef r1 = s.addEntry(10);
     MyRef r2 = s.addEntry(20);
@@ -667,9 +667,9 @@ TEST(DataStoreTest, can_reuse_active_buffer_as_primary_buffer)
 TEST(DataStoreTest, control_static_sizes) {
     EXPECT_EQ(96, sizeof(BufferTypeBase));
     EXPECT_EQ(24, sizeof(FreeList));
-    EXPECT_EQ(48, sizeof(BufferFreeList));
+    EXPECT_EQ(40, sizeof(BufferFreeList));
     EXPECT_EQ(1, sizeof(BufferState::State));
-    EXPECT_EQ(120, sizeof(BufferState));
+    EXPECT_EQ(112, sizeof(BufferState));
     BufferState bs;
     EXPECT_EQ(0, bs.size());
 }
diff --git a/vespalib/src/tests/datastore/unique_store/unique_store_test.cpp b/vespalib/src/tests/datastore/unique_store/unique_store_test.cpp
index 2c359db59b1..4d271618250 100644
--- a/vespalib/src/tests/datastore/unique_store/unique_store_test.cpp
+++ b/vespalib/src/tests/datastore/unique_store/unique_store_test.cpp
@@ -465,13 +465,13 @@ TEST_F(DoubleTest, nan_is_handled)
 TEST_F(DoubleTest, control_memory_usage) {
     static constexpr size_t sizeof_deque = vespalib::datastore::DataStoreBase::sizeof_entry_ref_hold_list_deque;
     EXPECT_EQ(400u + sizeof_deque, sizeof(store));
-    EXPECT_EQ(120u, sizeof(BufferState));
+    EXPECT_EQ(112u, sizeof(BufferState));
     EXPECT_EQ(28740u, store.get_values_memory_usage().allocatedBytes());
-    EXPECT_EQ(24780u, store.get_values_memory_usage().usedBytes());
+    EXPECT_EQ(24772u, store.get_values_memory_usage().usedBytes());
     EXPECT_EQ(126952u, store.get_dictionary_memory_usage().allocatedBytes());
-    EXPECT_EQ(25200u, store.get_dictionary_memory_usage().usedBytes());
+    EXPECT_EQ(25184u, store.get_dictionary_memory_usage().usedBytes());
     EXPECT_EQ(155692u, store.getMemoryUsage().allocatedBytes());
-    EXPECT_EQ(49980u, store.getMemoryUsage().usedBytes());
+    EXPECT_EQ(49956u, store.getMemoryUsage().usedBytes());
 }
                 
 GTEST_MAIN_RUN_ALL_TESTS()
diff --git a/vespalib/src/vespa/vespalib/datastore/buffer_free_list.cpp b/vespalib/src/vespa/vespalib/datastore/buffer_free_list.cpp
index d44c2e45b2b..b77d9abe22b 100644
--- a/vespalib/src/vespa/vespalib/datastore/buffer_free_list.cpp
+++ b/vespalib/src/vespa/vespalib/datastore/buffer_free_list.cpp
@@ -14,13 +14,13 @@ BufferFreeList::attach()
 }
 
 void
-BufferFreeList::detach()
+BufferFreeList::detach() noexcept
 {
     assert(_free_list != nullptr);
     _free_list->detach(*this);
 }
 
-BufferFreeList::BufferFreeList(std::atomic<EntryCount>& dead_entries)
+BufferFreeList::BufferFreeList(std::atomic<EntryCount>& dead_entries) noexcept
     : _dead_entries(dead_entries),
       _free_list(),
       _free_refs()
@@ -34,7 +34,7 @@ BufferFreeList::~BufferFreeList()
 }
 
 void
-BufferFreeList::enable(FreeList& free_list)
+BufferFreeList::enable(FreeList& free_list) noexcept
 {
     assert(_free_list == nullptr);
     assert(_free_refs.empty());
@@ -42,7 +42,7 @@ BufferFreeList::enable(FreeList& free_list)
 }
 
 void
-BufferFreeList::disable()
+BufferFreeList::disable() noexcept
 {
     if (!empty()) {
         detach();
@@ -59,7 +59,7 @@ BufferFreeList::push_entry(EntryRef ref) {
     _free_refs.push_back(ref);
 }
 EntryRef
-BufferFreeList::pop_entry() {
+BufferFreeList::pop_entry() noexcept {
     EntryRef ret = _free_refs.back();
     _free_refs.pop_back();
     if (empty()) {
diff --git a/vespalib/src/vespa/vespalib/datastore/buffer_free_list.h b/vespalib/src/vespa/vespalib/datastore/buffer_free_list.h
index 48fd2e0347c..4491f0638d3 100644
--- a/vespalib/src/vespa/vespalib/datastore/buffer_free_list.h
+++ b/vespalib/src/vespa/vespalib/datastore/buffer_free_list.h
@@ -4,7 +4,6 @@
 
 #include "entryref.h"
 #include "buffer_type.h"
-#include <vespa/vespalib/util/array.h>
 
 namespace vespalib::datastore {
 
@@ -17,29 +16,29 @@ class FreeList;
  */
 class BufferFreeList {
 private:
-    using EntryRefArray = vespalib::Array<EntryRef>;
+    using EntryRefArray = std::vector<EntryRef>;
 
     std::atomic<EntryCount>& _dead_entries;
-    FreeList* _free_list;
-    EntryRefArray _free_refs;
+    FreeList                *_free_list;
+    EntryRefArray            _free_refs;
 
     void attach();
-    void detach();
+    void detach() noexcept;
 
 public:
-    BufferFreeList(std::atomic<EntryCount>& dead_entrie);
+    explicit BufferFreeList(std::atomic<EntryCount>& dead_entries) noexcept;
     ~BufferFreeList();
-    BufferFreeList(BufferFreeList&&) = default; // Needed for emplace_back() during setup.
+    BufferFreeList(BufferFreeList&&) noexcept = default; // Needed for emplace_back() during setup.
     BufferFreeList(const BufferFreeList&) = delete;
     BufferFreeList& operator=(const BufferFreeList&) = delete;
     BufferFreeList& operator=(BufferFreeList&&) = delete;
-    void enable(FreeList& free_list);
-    void disable();
+    void enable(FreeList& free_list) noexcept;
+    void disable() noexcept;
 
-    bool enabled() const { return _free_list != nullptr; }
-    bool empty() const { return _free_refs.empty(); }
+    bool enabled() const noexcept { return _free_list != nullptr; }
+    bool empty() const noexcept { return _free_refs.empty(); }
     void push_entry(EntryRef ref);
-    EntryRef pop_entry();
+    EntryRef pop_entry() noexcept;
 };
 
 }
diff --git a/vespalib/src/vespa/vespalib/datastore/buffer_stats.cpp b/vespalib/src/vespa/vespalib/datastore/buffer_stats.cpp
index b1fd6460d24..5705d9faefc 100644
--- a/vespalib/src/vespa/vespalib/datastore/buffer_stats.cpp
+++ b/vespalib/src/vespa/vespalib/datastore/buffer_stats.cpp
@@ -5,7 +5,7 @@
 
 namespace vespalib::datastore {
 
-BufferStats::BufferStats()
+BufferStats::BufferStats() noexcept
     : _alloc_entries(0),
       _used_entries(0),
       _hold_entries(0),
@@ -16,7 +16,7 @@ BufferStats::BufferStats()
 }
 
 void
-BufferStats::add_to_mem_stats(size_t entry_size, MemoryStats& stats) const
+BufferStats::add_to_mem_stats(size_t entry_size, MemoryStats& stats) const noexcept
 {
     size_t extra_used = extra_used_bytes();
     stats._alloc_entries += capacity();
@@ -29,13 +29,13 @@ BufferStats::add_to_mem_stats(size_t entry_size, MemoryStats& stats) const
     stats._holdBytes += (hold_entries() * entry_size) + extra_hold_bytes();
 }
 
-InternalBufferStats::InternalBufferStats()
+InternalBufferStats::InternalBufferStats() noexcept
     : BufferStats()
 {
 }
 
 void
-InternalBufferStats::clear()
+InternalBufferStats::clear() noexcept
 {
     _alloc_entries.store(0, std::memory_order_relaxed);
     _used_entries.store(0, std::memory_order_relaxed);
@@ -46,7 +46,7 @@ InternalBufferStats::clear()
 }
 
 void
-InternalBufferStats::dec_hold_entries(size_t value)
+InternalBufferStats::dec_hold_entries(size_t value) noexcept
 {
     EntryCount elems = hold_entries();
     assert(elems >= value);
diff --git a/vespalib/src/vespa/vespalib/datastore/buffer_stats.h b/vespalib/src/vespa/vespalib/datastore/buffer_stats.h
index 12ac8ae4995..59446ddc989 100644
--- a/vespalib/src/vespa/vespalib/datastore/buffer_stats.h
+++ b/vespalib/src/vespa/vespalib/datastore/buffer_stats.h
@@ -32,24 +32,24 @@ protected:
     std::atomic<size_t> _extra_hold_bytes;
 
 public:
-    BufferStats();
+    BufferStats() noexcept;
 
-    size_t size() const { return _used_entries.load(std::memory_order_relaxed); }
-    size_t capacity() const { return _alloc_entries.load(std::memory_order_relaxed); }
-    size_t remaining() const { return capacity() - size(); }
+    size_t size() const noexcept { return _used_entries.load(std::memory_order_relaxed); }
+    size_t capacity() const noexcept { return _alloc_entries.load(std::memory_order_relaxed); }
+    size_t remaining() const noexcept { return capacity() - size(); }
 
-    void pushed_back(size_t num_entries) {
+    void pushed_back(size_t num_entries) noexcept {
         _used_entries.store(size() + num_entries, std::memory_order_relaxed);
     }
 
-    size_t dead_entries() const { return _dead_entries.load(std::memory_order_relaxed); }
-    size_t hold_entries() const { return _hold_entries.load(std::memory_order_relaxed); }
-    size_t extra_used_bytes() const { return _extra_used_bytes.load(std::memory_order_relaxed); }
-    size_t extra_hold_bytes() const { return _extra_hold_bytes.load(std::memory_order_relaxed); }
+    size_t dead_entries() const noexcept { return _dead_entries.load(std::memory_order_relaxed); }
+    size_t hold_entries() const noexcept { return _hold_entries.load(std::memory_order_relaxed); }
+    size_t extra_used_bytes() const noexcept { return _extra_used_bytes.load(std::memory_order_relaxed); }
+    size_t extra_hold_bytes() const noexcept { return _extra_hold_bytes.load(std::memory_order_relaxed); }
 
-    void inc_extra_used_bytes(size_t value) { _extra_used_bytes.store(extra_used_bytes() + value, std::memory_order_relaxed); }
+    void inc_extra_used_bytes(size_t value) noexcept { _extra_used_bytes.store(extra_used_bytes() + value, std::memory_order_relaxed); }
 
-    void add_to_mem_stats(size_t entry_size, MemoryStats& stats) const;
+    void add_to_mem_stats(size_t entry_size, MemoryStats& stats) const noexcept;
 };
 
 /**
@@ -57,19 +57,19 @@ public:
  */
 class InternalBufferStats : public BufferStats {
 public:
-    InternalBufferStats();
-    void clear();
-    void set_alloc_entries(size_t value) { _alloc_entries.store(value, std::memory_order_relaxed); }
-    void set_dead_entries(size_t value) { _dead_entries.store(value, std::memory_order_relaxed); }
-    void set_hold_entries(size_t value) { _hold_entries.store(value, std::memory_order_relaxed); }
-    void inc_dead_entries(size_t value) { _dead_entries.store(dead_entries() + value, std::memory_order_relaxed); }
-    void inc_hold_entries(size_t value) { _hold_entries.store(hold_entries() + value, std::memory_order_relaxed); }
-    void dec_hold_entries(size_t value);
-    void inc_extra_hold_bytes(size_t value) { _extra_hold_bytes.store(extra_hold_bytes() + value, std::memory_order_relaxed); }
-    std::atomic<EntryCount>& used_entries_ref() { return _used_entries; }
-    std::atomic<EntryCount>& dead_entries_ref() { return _dead_entries; }
-    std::atomic<size_t>& extra_used_bytes_ref() { return _extra_used_bytes; }
-    std::atomic<size_t>& extra_hold_bytes_ref() { return _extra_hold_bytes; }
+    InternalBufferStats() noexcept;
+    void clear() noexcept;
+    void set_alloc_entries(size_t value) noexcept { _alloc_entries.store(value, std::memory_order_relaxed); }
+    void set_dead_entries(size_t value) noexcept { _dead_entries.store(value, std::memory_order_relaxed); }
+    void set_hold_entries(size_t value) noexcept { _hold_entries.store(value, std::memory_order_relaxed); }
+    void inc_dead_entries(size_t value) noexcept { _dead_entries.store(dead_entries() + value, std::memory_order_relaxed); }
+    void inc_hold_entries(size_t value) noexcept { _hold_entries.store(hold_entries() + value, std::memory_order_relaxed); }
+    void dec_hold_entries(size_t value) noexcept;
+    void inc_extra_hold_bytes(size_t value) noexcept { _extra_hold_bytes.store(extra_hold_bytes() + value, std::memory_order_relaxed); }
+    std::atomic<EntryCount>& used_entries_ref() noexcept { return _used_entries; }
+    std::atomic<EntryCount>& dead_entries_ref() noexcept { return _dead_entries; }
+    std::atomic<size_t>& extra_used_bytes_ref() noexcept { return _extra_used_bytes; }
+    std::atomic<size_t>& extra_hold_bytes_ref() noexcept { return _extra_hold_bytes; }
 };
 
 }
diff --git a/vespalib/src/vespa/vespalib/datastore/buffer_type.cpp b/vespalib/src/vespa/vespalib/datastore/buffer_type.cpp
index ca15a5cc5fd..b593b44adfc 100644
--- a/vespalib/src/vespa/vespalib/datastore/buffer_type.cpp
+++ b/vespalib/src/vespa/vespalib/datastore/buffer_type.cpp
@@ -16,7 +16,7 @@ constexpr float DEFAULT_ALLOC_GROW_FACTOR = 0.2;
 }
 
 void
-BufferTypeBase::CleanContext::extraBytesCleaned(size_t value)
+BufferTypeBase::CleanContext::extraBytesCleaned(size_t value) noexcept
 {
     size_t extra_used_bytes = _extraUsedBytes.load(std::memory_order_relaxed);
     size_t extra_hold_bytes = _extraHoldBytes.load(std::memory_order_relaxed);
@@ -68,7 +68,7 @@ BufferTypeBase::~BufferTypeBase()
 }
 
 EntryCount
-BufferTypeBase::get_reserved_entries(uint32_t bufferId) const
+BufferTypeBase::get_reserved_entries(uint32_t bufferId) const noexcept
 {
     return bufferId == 0 ? 1u : 0u;
 }
@@ -99,7 +99,7 @@ BufferTypeBase::on_hold(uint32_t buffer_id, const std::atomic<EntryCount>* used_
 }
 
 void
-BufferTypeBase::on_free(EntryCount used_entries)
+BufferTypeBase::on_free(EntryCount used_entries) noexcept
 {
     --_holdBuffers;
     assert(_hold_used_entries >= used_entries);
@@ -130,7 +130,7 @@ BufferTypeBase::is_dynamic_array_buffer_type() const noexcept
 }
 
 void
-BufferTypeBase::clamp_max_entries(uint32_t max_entries)
+BufferTypeBase::clamp_max_entries(uint32_t max_entries) noexcept
 {
     _max_entries = std::min(_max_entries, max_entries);
     _min_entries = std::min(_min_entries, _max_entries);
@@ -186,7 +186,7 @@ BufferTypeBase::calc_entries_to_alloc(uint32_t bufferId, EntryCount free_entries
 }
 
 uint32_t
-BufferTypeBase::get_scaled_num_entries_for_new_buffer() const
+BufferTypeBase::get_scaled_num_entries_for_new_buffer() const noexcept
 {
     uint32_t active_buffers_count = get_active_buffers_count();
     if (active_buffers_count <= 1u || _num_entries_for_new_buffer == 0u) {
@@ -200,7 +200,7 @@ BufferTypeBase::get_scaled_num_entries_for_new_buffer() const
     return scaled_result;
 }
 
-BufferTypeBase::AggregatedBufferCounts::AggregatedBufferCounts()
+BufferTypeBase::AggregatedBufferCounts::AggregatedBufferCounts() noexcept
     : _counts()
 {
 }
@@ -226,7 +226,7 @@ BufferTypeBase::AggregatedBufferCounts::remove_buffer(const std::atomic<EntryCou
 }
 
 BufferTypeBase::BufferCounts
-BufferTypeBase::AggregatedBufferCounts::last_buffer() const
+BufferTypeBase::AggregatedBufferCounts::last_buffer() const noexcept
 {
     BufferCounts result;
     assert(!_counts.empty());
@@ -237,7 +237,7 @@ BufferTypeBase::AggregatedBufferCounts::last_buffer() const
 }
 
 BufferTypeBase::BufferCounts
-BufferTypeBase::AggregatedBufferCounts::all_buffers() const
+BufferTypeBase::AggregatedBufferCounts::all_buffers() const noexcept
 {
     BufferCounts result;
     for (const auto& elem : _counts) {
diff --git a/vespalib/src/vespa/vespalib/datastore/buffer_type.h b/vespalib/src/vespa/vespalib/datastore/buffer_type.h
index 3edafbc8e69..08e165afb98 100644
--- a/vespalib/src/vespa/vespalib/datastore/buffer_type.h
+++ b/vespalib/src/vespa/vespalib/datastore/buffer_type.h
@@ -28,11 +28,11 @@ public:
         std::atomic<size_t> &_extraUsedBytes;
         std::atomic<size_t> &_extraHoldBytes;
     public:
-        CleanContext(std::atomic<size_t>& extraUsedBytes, std::atomic<size_t>& extraHoldBytes)
+        CleanContext(std::atomic<size_t>& extraUsedBytes, std::atomic<size_t>& extraHoldBytes) noexcept
             : _extraUsedBytes(extraUsedBytes),
               _extraHoldBytes(extraHoldBytes)
         {}
-        void extraBytesCleaned(size_t value);
+        void extraBytesCleaned(size_t value) noexcept;
     };
 
     BufferTypeBase(const BufferTypeBase &rhs) = delete;
@@ -50,7 +50,7 @@ public:
      * Return number of reserved entries at start of buffer, to avoid
      * invalid reference.
      */
-    virtual EntryCount get_reserved_entries(uint32_t bufferId) const;
+    virtual EntryCount get_reserved_entries(uint32_t bufferId) const noexcept;
 
     /**
      * Initialize reserved elements at start of buffer.
@@ -62,7 +62,7 @@ public:
     size_t getArraySize() const noexcept { return _arraySize; }
     virtual void on_active(uint32_t bufferId, std::atomic<EntryCount>* used_entries, std::atomic<EntryCount>* dead_entries, void* buffer);
     void on_hold(uint32_t buffer_id, const std::atomic<EntryCount>* used_entries, const std::atomic<EntryCount>* dead_entries);
-    virtual void on_free(EntryCount used_entries);
+    virtual void on_free(EntryCount used_entries) noexcept;
     void resume_primary_buffer(uint32_t buffer_id, std::atomic<EntryCount>* used_entries, std::atomic<EntryCount>* dead_entries);
     virtual const alloc::MemoryAllocator* get_memory_allocator() const;
     virtual bool is_dynamic_array_buffer_type() const noexcept;
@@ -72,20 +72,20 @@ public:
      */
     virtual size_t calc_entries_to_alloc(uint32_t bufferId, EntryCount free_entries_needed, bool resizing) const;
 
-    void clamp_max_entries(uint32_t max_entries);
+    void clamp_max_entries(uint32_t max_entries) noexcept;
 
-    uint32_t get_active_buffers_count() const { return _active_buffers.size(); }
+    uint32_t get_active_buffers_count() const noexcept { return _active_buffers.size(); }
     const std::vector<uint32_t>& get_active_buffers() const noexcept { return _active_buffers; }
-    size_t get_max_entries() const { return _max_entries; }
-    uint32_t get_scaled_num_entries_for_new_buffer() const;
+    size_t get_max_entries() const noexcept { return _max_entries; }
+    uint32_t get_scaled_num_entries_for_new_buffer() const noexcept;
     uint32_t get_num_entries_for_new_buffer() const noexcept { return _num_entries_for_new_buffer; }
 protected:
 
     struct BufferCounts {
         EntryCount used_entries;
         EntryCount dead_entries;
-        BufferCounts() : used_entries(0), dead_entries(0) {}
-        BufferCounts(EntryCount used_entries_in, EntryCount dead_entries_in)
+        BufferCounts() noexcept : used_entries(0), dead_entries(0) {}
+        BufferCounts(EntryCount used_entries_in, EntryCount dead_entries_in) noexcept
             : used_entries(used_entries_in), dead_entries(dead_entries_in)
         {}
     };
@@ -106,12 +106,12 @@ protected:
         std::vector<ActiveBufferCounts> _counts;
 
     public:
-        AggregatedBufferCounts();
+        AggregatedBufferCounts() noexcept;
         void add_buffer(const std::atomic<EntryCount>* used_entries, const std::atomic<EntryCount>* dead_entries);
         void remove_buffer(const std::atomic<EntryCount>* used_entries, const std::atomic<EntryCount>* dead_entries);
-        BufferCounts last_buffer() const;
-        BufferCounts all_buffers() const;
-        bool empty() const { return _counts.empty(); }
+        BufferCounts last_buffer() const noexcept;
+        BufferCounts all_buffers() const noexcept;
+        bool empty() const noexcept { return _counts.empty(); }
     };
 
     uint32_t _entry_size;   // Number of bytes in an allocation unit
diff --git a/vespalib/src/vespa/vespalib/datastore/bufferstate.cpp b/vespalib/src/vespa/vespalib/datastore/bufferstate.cpp
index 8a2f824ecb3..49f126d4a7c 100644
--- a/vespalib/src/vespa/vespalib/datastore/bufferstate.cpp
+++ b/vespalib/src/vespa/vespalib/datastore/bufferstate.cpp
@@ -10,7 +10,7 @@ using vespalib::alloc::MemoryAllocator;
 
 namespace vespalib::datastore {
 
-BufferState::BufferState()
+BufferState::BufferState() noexcept
     : _stats(),
       _free_list(_stats.dead_entries_ref()),
       _typeHandler(nullptr),
@@ -36,11 +36,11 @@ namespace {
 struct AllocResult {
     size_t entries;
     size_t bytes;
-    AllocResult(size_t entries_, size_t bytes_) : entries(entries_), bytes(bytes_) {}
+    AllocResult(size_t entries_, size_t bytes_) noexcept : entries(entries_), bytes(bytes_) {}
 };
 
 size_t
-roundUpToMatchAllocator(size_t sz)
+roundUpToMatchAllocator(size_t sz) noexcept
 {
     if (sz == 0) {
         return 0;
@@ -57,10 +57,7 @@ roundUpToMatchAllocator(size_t sz)
 }
 
 AllocResult
-calc_allocation(uint32_t bufferId,
-                BufferTypeBase &typeHandler,
-                size_t free_entries_needed,
-                bool resizing)
+calc_allocation(uint32_t bufferId, BufferTypeBase &typeHandler, size_t free_entries_needed, bool resizing)
 {
     size_t alloc_entries = typeHandler.calc_entries_to_alloc(bufferId, free_entries_needed, resizing);
     size_t entry_size = typeHandler.entry_size();
@@ -72,16 +69,14 @@ calc_allocation(uint32_t bufferId,
         allocBytes = maxAllocBytes;
     }
     size_t adjusted_alloc_entries = (allocBytes - buffer_underflow_size) / entry_size;
-    return AllocResult(adjusted_alloc_entries, allocBytes);
+    return {adjusted_alloc_entries, allocBytes};
 }
 
 }
 
 void
-BufferState::on_active(uint32_t bufferId, uint32_t typeId,
-                       BufferTypeBase *typeHandler,
-                       size_t free_entries_needed,
-                       std::atomic<void*>& buffer)
+BufferState::on_active(uint32_t bufferId, uint32_t typeId, BufferTypeBase *typeHandler,
+                       size_t free_entries_needed, std::atomic<void*>& buffer)
 {
     assert(buffer.load(std::memory_order_relaxed) == nullptr);
     assert(_buffer.get() == nullptr);
@@ -207,15 +202,12 @@ BufferState::free_entries(EntryRef ref, size_t num_entries, size_t ref_offset)
     auto type_handler = getTypeHandler();
     auto buffer_underflow_size = type_handler->buffer_underflow_size();
     type_handler->clean_hold(get_buffer(buffer_underflow_size), ref_offset, num_entries,
-                            BufferTypeBase::CleanContext(_stats.extra_used_bytes_ref(),
-                                                         _stats.extra_hold_bytes_ref()));
+                             BufferTypeBase::CleanContext(_stats.extra_used_bytes_ref(), _stats.extra_hold_bytes_ref()));
 }
 
 void
-BufferState::fallback_resize(uint32_t bufferId,
-                             size_t free_entries_needed,
-                            std::atomic<void*>& buffer,
-                            Alloc &holdBuffer)
+BufferState::fallback_resize(uint32_t bufferId, size_t free_entries_needed,
+                            std::atomic<void*>& buffer, Alloc &holdBuffer)
 {
     assert(getState() == State::ACTIVE);
     auto type_handler = getTypeHandler();
diff --git a/vespalib/src/vespa/vespalib/datastore/bufferstate.h b/vespalib/src/vespa/vespalib/datastore/bufferstate.h
index 070982080ff..ad841ae3a18 100644
--- a/vespalib/src/vespa/vespalib/datastore/bufferstate.h
+++ b/vespalib/src/vespa/vespalib/datastore/bufferstate.h
@@ -31,11 +31,7 @@ class BufferState
 public:
     using Alloc = vespalib::alloc::Alloc;
 
-    enum class State : uint8_t {
-        FREE,
-        ACTIVE,
-        HOLD
-    };
+    enum class State : uint8_t { FREE, ACTIVE, HOLD };
 
 private:
     InternalBufferStats _stats;
@@ -56,7 +52,7 @@ public:
      * compaction should always be used to free up whole buffers.
      */
 
-    BufferState();
+    BufferState() noexcept;
     BufferState(const BufferState &) = delete;
     BufferState & operator=(const BufferState &) = delete;
     ~BufferState();
@@ -103,31 +99,31 @@ public:
      */
     void free_entries(EntryRef ref, size_t num_entries, size_t ref_offset);
 
-    BufferStats& stats() { return _stats; }
-    const BufferStats& stats() const { return _stats; }
+    BufferStats& stats() noexcept { return _stats; }
+    const BufferStats& stats() const noexcept { return _stats; }
 
-    void enable_free_list(FreeList& type_free_list) { _free_list.enable(type_free_list); }
-    void disable_free_list() { _free_list.disable(); }
+    void enable_free_list(FreeList& type_free_list) noexcept { _free_list.enable(type_free_list); }
+    void disable_free_list() noexcept { _free_list.disable(); }
 
-    size_t size() const { return _stats.size(); }
-    size_t capacity() const { return _stats.capacity(); }
-    size_t remaining() const { return _stats.remaining(); }
+    size_t size() const noexcept { return _stats.size(); }
+    size_t capacity() const noexcept { return _stats.capacity(); }
+    size_t remaining() const noexcept { return _stats.remaining(); }
     void dropBuffer(uint32_t buffer_id, std::atomic<void*>& buffer);
-    uint32_t getTypeId() const { return _typeId; }
-    uint32_t getArraySize() const { return _arraySize; }
-    bool getCompacting() const { return _compacting; }
-    void setCompacting() { _compacting = true; }
+    uint32_t getTypeId() const noexcept { return _typeId; }
+    uint32_t getArraySize() const noexcept { return _arraySize; }
+    bool getCompacting() const noexcept { return _compacting; }
+    void setCompacting() noexcept { _compacting = true; }
     void fallback_resize(uint32_t bufferId, size_t free_entries_needed, std::atomic<void*>& buffer, Alloc &holdBuffer);
 
-    bool isActive(uint32_t typeId) const {
+    bool isActive(uint32_t typeId) const noexcept {
         return (isActive() && (_typeId == typeId));
     }
-    bool isActive() const { return (getState() == State::ACTIVE); }
-    bool isOnHold() const { return (getState() == State::HOLD); }
-    bool isFree() const { return (getState() == State::FREE); }
-    State getState() const { return _state.load(std::memory_order_relaxed); }
-    const BufferTypeBase *getTypeHandler() const { return _typeHandler.load(std::memory_order_relaxed); }
-    BufferTypeBase *getTypeHandler() { return _typeHandler.load(std::memory_order_relaxed); }
+    bool isActive() const noexcept { return (getState() == State::ACTIVE); }
+    bool isOnHold() const noexcept { return (getState() == State::HOLD); }
+    bool isFree() const noexcept { return (getState() == State::FREE); }
+    State getState() const noexcept { return _state.load(std::memory_order_relaxed); }
+    const BufferTypeBase *getTypeHandler() const noexcept { return _typeHandler.load(std::memory_order_relaxed); }
+    BufferTypeBase *getTypeHandler() noexcept { return _typeHandler.load(std::memory_order_relaxed); }
 
     void resume_primary_buffer(uint32_t buffer_id);
 };
@@ -141,7 +137,7 @@ public:
     uint32_t getTypeId() const noexcept { return _typeId; }
     uint32_t get_array_size() const noexcept { return _array_size; }
     BufferState * get_state_relaxed() noexcept { return _state.load(std::memory_order_relaxed); }
-    const BufferState * get_state_acquire() const { return _state.load(std::memory_order_acquire); }
+    const BufferState * get_state_acquire() const noexcept  { return _state.load(std::memory_order_acquire); }
     uint32_t get_entry_size() const noexcept { return _entry_size; }
     void setTypeId(uint32_t typeId) noexcept { _typeId = typeId; }
     void set_array_size(uint32_t arraySize) noexcept { _array_size = arraySize; }
diff --git a/vespalib/src/vespa/vespalib/datastore/datastore.h b/vespalib/src/vespa/vespalib/datastore/datastore.h
index 0226c780cf1..b4fe9ce2ac7 100644
--- a/vespalib/src/vespa/vespalib/datastore/datastore.h
+++ b/vespalib/src/vespa/vespalib/datastore/datastore.h
@@ -49,7 +49,7 @@ public:
 
     void reclaim_all_entry_refs() override;
 
-    bool getCompacting(EntryRef ref) {
+    bool getCompacting(EntryRef ref) noexcept {
         return getBufferState(RefType(ref).bufferId()).getCompacting();
     }
 
diff --git a/vespalib/src/vespa/vespalib/datastore/datastorebase.cpp b/vespalib/src/vespa/vespalib/datastore/datastorebase.cpp
index c15d4784cc9..fd1d2c9a8d1 100644
--- a/vespalib/src/vespa/vespalib/datastore/datastorebase.cpp
+++ b/vespalib/src/vespa/vespalib/datastore/datastorebase.cpp
@@ -48,7 +48,7 @@ primary_buffer_too_dead(const BufferState &state)
 }
 
 DataStoreBase::FallbackHold::FallbackHold(size_t bytesSize, BufferState::Alloc &&buffer, size_t used_entries,
-                                          BufferTypeBase *typeHandler, uint32_t typeId)
+                                          BufferTypeBase *typeHandler, uint32_t typeId) noexcept
     : GenerationHeldBase(bytesSize),
       _buffer(std::move(buffer)),
       _used_entries(used_entries),
@@ -68,7 +68,7 @@ class DataStoreBase::BufferHold : public GenerationHeldBase {
     uint32_t _bufferId;
 
 public:
-    BufferHold(size_t bytesSize, DataStoreBase &dsb, uint32_t bufferId)
+    BufferHold(size_t bytesSize, DataStoreBase &dsb, uint32_t bufferId) noexcept
         : GenerationHeldBase(bytesSize),
           _dsb(dsb),
           _bufferId(bufferId)
@@ -159,7 +159,7 @@ DataStoreBase::consider_grow_active_buffer(uint32_t type_id, size_t entries_need
 }
 
 uint32_t
-DataStoreBase::getFirstFreeBufferId() {
+DataStoreBase::getFirstFreeBufferId() noexcept {
     uint32_t buffer_id = 0;
     for (auto & buffer : _buffers) {
         BufferState * state = buffer.get_state_relaxed();
@@ -268,7 +268,7 @@ DataStoreBase::dropBuffers()
 }
 
 vespalib::MemoryUsage
-DataStoreBase::getDynamicMemoryUsage() const
+DataStoreBase::getDynamicMemoryUsage() const noexcept
 {
     auto stats = getMemStats();
     vespalib::MemoryUsage usage;
@@ -280,7 +280,7 @@ DataStoreBase::getDynamicMemoryUsage() const
 }
 
 vespalib::MemoryUsage
-DataStoreBase::getMemoryUsage() const {
+DataStoreBase::getMemoryUsage() const noexcept {
     auto usage = getDynamicMemoryUsage();
     size_t extra_allocated = 0;
     extra_allocated += _buffers.capacity() * sizeof(BufferAndMeta);
@@ -319,7 +319,7 @@ DataStoreBase::enableFreeLists()
 }
 
 void
-DataStoreBase::disableFreeLists()
+DataStoreBase::disableFreeLists() noexcept
 {
     for_each_buffer([](BufferState & state) { state.disable_free_list(); });
     _freeListsEnabled = false;
@@ -335,7 +335,7 @@ DataStoreBase::disable_entry_hold_list()
 }
 
 MemoryStats
-DataStoreBase::getMemStats() const
+DataStoreBase::getMemStats() const noexcept
 {
     MemoryStats stats;
 
@@ -368,7 +368,7 @@ DataStoreBase::getMemStats() const
 }
 
 vespalib::AddressSpace
-DataStoreBase::getAddressSpaceUsage() const
+DataStoreBase::getAddressSpaceUsage() const noexcept
 {
     uint32_t buffer_id_limit = get_bufferid_limit_acquire();
     size_t used_entries = 0;
@@ -520,7 +520,7 @@ DataStoreBase::start_compact_worst_buffers(CompactionSpec compaction_spec, const
 }
 
 void
-DataStoreBase::inc_hold_buffer_count()
+DataStoreBase::inc_hold_buffer_count() noexcept
 {
     assert(_hold_buffer_count < std::numeric_limits<uint32_t>::max());
     ++_hold_buffer_count;
diff --git a/vespalib/src/vespa/vespalib/datastore/datastorebase.h b/vespalib/src/vespa/vespalib/datastore/datastorebase.h
index bce2d2096f2..fb525f9378b 100644
--- a/vespalib/src/vespa/vespalib/datastore/datastorebase.h
+++ b/vespalib/src/vespa/vespalib/datastore/datastorebase.h
@@ -64,10 +64,10 @@ public:
      */
     void switch_primary_buffer(uint32_t typeId, size_t entries_needed);
 
-    vespalib::MemoryUsage getMemoryUsage() const;
-    vespalib::MemoryUsage getDynamicMemoryUsage() const;
+    vespalib::MemoryUsage getMemoryUsage() const noexcept;
+    vespalib::MemoryUsage getDynamicMemoryUsage() const noexcept;
 
-    vespalib::AddressSpace getAddressSpaceUsage() const;
+    vespalib::AddressSpace getAddressSpaceUsage() const noexcept;
 
     /**
      * Get the primary buffer id for the given type id.
@@ -135,7 +135,7 @@ public:
     /**
      * Disable free list management.
      */
-    void disableFreeLists();
+    void disableFreeLists() noexcept;
     void disable_entry_hold_list();
 
     bool has_free_lists_enabled() const { return _freeListsEnabled; }
@@ -143,38 +143,38 @@ public:
     /**
      * Returns the free list for the given type id.
      */
-    FreeList &getFreeList(uint32_t typeId) {
+    FreeList &getFreeList(uint32_t typeId) noexcept {
         return _free_lists[typeId];
     }
 
     /**
      * Returns aggregated memory statistics for all buffers in this data store.
      */
-    MemoryStats getMemStats() const;
+    MemoryStats getMemStats() const noexcept;
 
     /**
      * Assume that no readers are present while data structure is being initialized.
      */
-    void setInitializing(bool initializing) { _initializing = initializing; }
+    void setInitializing(bool initializing) noexcept { _initializing = initializing; }
 
-    uint32_t getTypeId(uint32_t bufferId) const {
+    uint32_t getTypeId(uint32_t bufferId) const noexcept {
         return _buffers[bufferId].getTypeId();
     }
 
     void finishCompact(const std::vector<uint32_t> &toHold);
 
-    vespalib::GenerationHolder &getGenerationHolder() {
+    vespalib::GenerationHolder &getGenerationHolder() noexcept {
         return _genHolder;
     }
 
     // need object location before construction
-    static vespalib::GenerationHolder &getGenerationHolderLocation(DataStoreBase &self) {
+    static vespalib::GenerationHolder &getGenerationHolderLocation(DataStoreBase &self) noexcept {
         return self._genHolder;
     }
 
     std::unique_ptr<CompactingBuffers> start_compact_worst_buffers(CompactionSpec compaction_spec, const CompactionStrategy &compaction_strategy);
-    uint64_t get_compaction_count() const { return _compaction_count.load(std::memory_order_relaxed); }
-    void inc_compaction_count() const { ++_compaction_count; }
+    uint64_t get_compaction_count() const noexcept { return _compaction_count.load(std::memory_order_relaxed); }
+    void inc_compaction_count() const noexcept { ++_compaction_count; }
     bool has_held_buffers() const noexcept { return _hold_buffer_count != 0u; }
 
     /**
@@ -184,9 +184,9 @@ public:
      */
     virtual void reclaim_entry_refs(generation_t oldest_used_gen) = 0;
 
-    uint32_t get_entry_size(uint32_t type_id) { return _typeHandlers[type_id]->entry_size(); }
+    uint32_t get_entry_size(uint32_t type_id) noexcept { return _typeHandlers[type_id]->entry_size(); }
 
-    void* getBuffer(uint32_t bufferId) { return _buffers[bufferId].get_buffer_relaxed(); }
+    void* getBuffer(uint32_t bufferId) noexcept { return _buffers[bufferId].get_buffer_relaxed(); }
 
 protected:
     DataStoreBase(uint32_t numBuffers, uint32_t offset_bits, size_t max_entries);
@@ -196,7 +196,7 @@ protected:
         EntryRef ref;
         size_t   num_entries;
 
-        EntryRefHoldElem(EntryRef ref_in, size_t num_entries_in)
+        EntryRefHoldElem(EntryRef ref_in, size_t num_entries_in) noexcept
             : ref(ref_in),
               num_entries(num_entries_in)
         {}
@@ -223,7 +223,7 @@ private:
         uint32_t           _typeId;
 
         FallbackHold(size_t bytesSize, BufferState::Alloc &&buffer, size_t used_entries,
-                     BufferTypeBase *typeHandler, uint32_t typeId);
+                     BufferTypeBase *typeHandler, uint32_t typeId) noexcept;
 
         ~FallbackHold() override;
     };
@@ -247,12 +247,12 @@ private:
      */
     void on_active(uint32_t bufferId, uint32_t typeId, size_t entries_needed);
 
-    void inc_hold_buffer_count();
+    void inc_hold_buffer_count() noexcept;
     void fallback_resize(uint32_t bufferId, size_t entries_needed);
-    uint32_t getFirstFreeBufferId();
+    uint32_t getFirstFreeBufferId() noexcept;
 
     template<typename FuncType>
-    void for_each_buffer(FuncType func) {
+    void for_each_buffer(FuncType func) noexcept {
         uint32_t buffer_id_limit = get_bufferid_limit_relaxed();
         for (uint32_t i = 0; i < buffer_id_limit; i++) {
             func(*(_buffers[i].get_state_relaxed()));
diff --git a/vespalib/src/vespa/vespalib/datastore/free_list.cpp b/vespalib/src/vespa/vespalib/datastore/free_list.cpp
index d69a23d7883..10e8cf8c030 100644
--- a/vespalib/src/vespa/vespalib/datastore/free_list.cpp
+++ b/vespalib/src/vespa/vespalib/datastore/free_list.cpp
@@ -6,7 +6,7 @@
 
 namespace vespalib::datastore {
 
-FreeList::FreeList()
+FreeList::FreeList() noexcept
     : _free_lists()
 {
 }
@@ -23,7 +23,7 @@ FreeList::attach(BufferFreeList& buf_list)
 }
 
 void
-FreeList::detach(BufferFreeList& buf_list)
+FreeList::detach(BufferFreeList& buf_list) noexcept
 {
     if (!_free_lists.empty() && (_free_lists.back() == &buf_list)) {
         _free_lists.pop_back();
diff --git a/vespalib/src/vespa/vespalib/datastore/free_list.h b/vespalib/src/vespa/vespalib/datastore/free_list.h
index 7789d7b8f37..5f1fb2184e7 100644
--- a/vespalib/src/vespa/vespalib/datastore/free_list.h
+++ b/vespalib/src/vespa/vespalib/datastore/free_list.h
@@ -19,18 +19,18 @@ private:
     std::vector<BufferFreeList*> _free_lists;
 
 public:
-    FreeList();
+    FreeList() noexcept;
     ~FreeList();
-    FreeList(FreeList&&) = default; // Needed for emplace_back() during setup.
+    FreeList(FreeList&&) noexcept = default; // Needed for emplace_back() during setup.
     FreeList(const FreeList&) = delete;
     FreeList& operator=(const FreeList&) = delete;
     FreeList& operator=(BufferFreeList&&) = delete;
     void attach(BufferFreeList& buf_list);
-    void detach(BufferFreeList& buf_list);
+    void detach(BufferFreeList& buf_list) noexcept;
 
-    bool empty() const { return _free_lists.empty(); }
-    size_t size() const { return _free_lists.size(); }
-    EntryRef pop_entry() {
+    bool empty() const noexcept { return _free_lists.empty(); }
+    size_t size() const noexcept { return _free_lists.size(); }
+    EntryRef pop_entry() noexcept {
         return _free_lists.back()->pop_entry();
     }
 };