Add noexcept

4 files changed, 48 insertions, 52 deletions

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..c0c65ace7cf 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;
@@ -60,7 +60,7 @@ AllocResult
 calc_allocation(uint32_t bufferId,
                 BufferTypeBase &typeHandler,
                 size_t free_entries_needed,
-                bool resizing)
+                bool resizing) noexcept
 {
     size_t alloc_entries = typeHandler.calc_entries_to_alloc(bufferId, free_entries_needed, resizing);
     size_t entry_size = typeHandler.entry_size();
@@ -72,7 +72,7 @@ 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};
 }
 
 }
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; }