From 4b04c28e8ddea6be9cf87462ba7e9206e0f6ce70 Mon Sep 17 00:00:00 2001 From: Henning Baldersheim Date: Wed, 24 Apr 2024 11:35:28 +0000 Subject: Use std::vector instead of vespalib::Array --- searchlib/src/tests/attribute/attribute_test.cpp | 32 +++++++++++----------- .../memoryindex/memory_index/memory_index_test.cpp | 2 +- .../predicate/document_features_store_test.cpp | 16 ++++++----- vespalib/src/tests/btree/btree_test.cpp | 2 +- .../datastore/array_store/array_store_test.cpp | 4 +-- .../tests/datastore/datastore/datastore_test.cpp | 8 +++--- .../datastore/unique_store/unique_store_test.cpp | 8 +++--- .../vespa/vespalib/datastore/buffer_free_list.cpp | 10 +++---- .../vespa/vespalib/datastore/buffer_free_list.h | 23 ++++++++-------- .../src/vespa/vespalib/datastore/free_list.cpp | 4 +-- vespalib/src/vespa/vespalib/datastore/free_list.h | 12 ++++---- 11 files changed, 61 insertions(+), 60 deletions(-) diff --git a/searchlib/src/tests/attribute/attribute_test.cpp b/searchlib/src/tests/attribute/attribute_test.cpp index ff8641640a9..5e0392c7da5 100644 --- a/searchlib/src/tests/attribute/attribute_test.cpp +++ b/searchlib/src/tests/attribute/attribute_test.cpp @@ -907,7 +907,7 @@ AttributeTest::testSingle() AttributePtr ptr = createAttribute("sv-post-int32", cfg); ptr->updateStat(true); EXPECT_EQ(338972u, ptr->getStatus().getAllocated()); - EXPECT_EQ(101632u, ptr->getStatus().getUsed()); + EXPECT_EQ(101512u, ptr->getStatus().getUsed()); addDocs(ptr, numDocs); testSingle(ptr, values); } @@ -929,7 +929,7 @@ AttributeTest::testSingle() AttributePtr ptr = createAttribute("sv-post-float", cfg); ptr->updateStat(true); EXPECT_EQ(338972u, ptr->getStatus().getAllocated()); - EXPECT_EQ(101632u, ptr->getStatus().getUsed()); + EXPECT_EQ(101512u, ptr->getStatus().getUsed()); addDocs(ptr, numDocs); testSingle(ptr, values); } @@ -942,7 +942,7 @@ AttributeTest::testSingle() AttributePtr ptr = createAttribute("sv-string", Config(BasicType::STRING, CollectionType::SINGLE)); ptr->updateStat(true); EXPECT_EQ(116528u + sizeof_large_string_entry, ptr->getStatus().getAllocated()); - EXPECT_EQ(52844u + sizeof_large_string_entry, ptr->getStatus().getUsed()); + EXPECT_EQ(52684u + sizeof_large_string_entry, ptr->getStatus().getUsed()); addDocs(ptr, numDocs); testSingle(ptr, values); } @@ -952,7 +952,7 @@ AttributeTest::testSingle() AttributePtr ptr = createAttribute("sv-fs-string", cfg); ptr->updateStat(true); EXPECT_EQ(344848u + sizeof_large_string_entry, ptr->getStatus().getAllocated()); - EXPECT_EQ(104556u + sizeof_large_string_entry, ptr->getStatus().getUsed()); + EXPECT_EQ(104300u + sizeof_large_string_entry, ptr->getStatus().getUsed()); addDocs(ptr, numDocs); testSingle(ptr, values); } @@ -1083,8 +1083,8 @@ AttributeTest::testArray() { AttributePtr ptr = createAttribute("a-int32", Config(BasicType::INT32, CollectionType::ARRAY)); ptr->updateStat(true); - EXPECT_EQ(297952u, ptr->getStatus().getAllocated()); - EXPECT_EQ(256092u, ptr->getStatus().getUsed()); + EXPECT_EQ(293856u, ptr->getStatus().getAllocated()); + EXPECT_EQ(253668u, ptr->getStatus().getUsed()); addDocs(ptr, numDocs); testArray(ptr, values); } @@ -1093,8 +1093,8 @@ AttributeTest::testArray() cfg.setFastSearch(true); AttributePtr ptr = createAttribute("flags", cfg); ptr->updateStat(true); - EXPECT_EQ(297952u, ptr->getStatus().getAllocated()); - EXPECT_EQ(256092u, ptr->getStatus().getUsed()); + EXPECT_EQ(293856u, ptr->getStatus().getAllocated()); + EXPECT_EQ(253668u, ptr->getStatus().getUsed()); addDocs(ptr, numDocs); testArray(ptr, values); } @@ -1103,8 +1103,8 @@ AttributeTest::testArray() cfg.setFastSearch(true); AttributePtr ptr = createAttribute("a-fs-int32", cfg); ptr->updateStat(true); - EXPECT_EQ(654588u, ptr->getStatus().getAllocated()); - EXPECT_EQ(357744u, ptr->getStatus().getUsed()); + EXPECT_EQ(650492u, ptr->getStatus().getAllocated()); + EXPECT_EQ(355200u, ptr->getStatus().getUsed()); addDocs(ptr, numDocs); testArray(ptr, values); } @@ -1122,8 +1122,8 @@ AttributeTest::testArray() cfg.setFastSearch(true); AttributePtr ptr = createAttribute("a-fs-float", cfg); ptr->updateStat(true); - EXPECT_EQ(654588u, ptr->getStatus().getAllocated()); - EXPECT_EQ(357744u, ptr->getStatus().getUsed()); + EXPECT_EQ(650492u, ptr->getStatus().getAllocated()); + EXPECT_EQ(355200u, ptr->getStatus().getUsed()); addDocs(ptr, numDocs); testArray(ptr, values); } @@ -1134,8 +1134,8 @@ AttributeTest::testArray() { AttributePtr ptr = createAttribute("a-string", Config(BasicType::STRING, CollectionType::ARRAY)); ptr->updateStat(true); - EXPECT_EQ(410256u + sizeof_large_string_entry, ptr->getStatus().getAllocated()); - EXPECT_EQ(308936u + sizeof_large_string_entry, ptr->getStatus().getUsed()); + EXPECT_EQ(406160u + sizeof_large_string_entry, ptr->getStatus().getAllocated()); + EXPECT_EQ(306352u + sizeof_large_string_entry, ptr->getStatus().getUsed()); addDocs(ptr, numDocs); testArray(ptr, values); } @@ -1144,8 +1144,8 @@ AttributeTest::testArray() cfg.setFastSearch(true); AttributePtr ptr = createAttribute("afs-string", cfg); ptr->updateStat(true); - EXPECT_EQ(660464u + sizeof_large_string_entry, ptr->getStatus().getAllocated()); - EXPECT_EQ(360668u + sizeof_large_string_entry, ptr->getStatus().getUsed()); + EXPECT_EQ(656368u + sizeof_large_string_entry, ptr->getStatus().getAllocated()); + EXPECT_EQ(357988u + sizeof_large_string_entry, ptr->getStatus().getUsed()); addDocs(ptr, numDocs); testArray(ptr, values); } diff --git a/searchlib/src/tests/memoryindex/memory_index/memory_index_test.cpp b/searchlib/src/tests/memoryindex/memory_index/memory_index_test.cpp index 1b51ba90f7c..7bd82ffdcad 100644 --- a/searchlib/src/tests/memoryindex/memory_index/memory_index_test.cpp +++ b/searchlib/src/tests/memoryindex/memory_index/memory_index_test.cpp @@ -469,7 +469,7 @@ TEST(MemoryIndexTest, require_that_num_docs_and_doc_id_limit_is_returned) TEST(MemoryIndexTest, require_that_we_understand_the_memory_footprint) { constexpr size_t BASE_ALLOCATED = 360936u; - constexpr size_t BASE_USED = 150804u; + constexpr size_t BASE_USED = 150676u; { MySetup setup; Index index(setup); diff --git a/searchlib/src/tests/predicate/document_features_store_test.cpp b/searchlib/src/tests/predicate/document_features_store_test.cpp index 0e77a1be878..3d479a6d39a 100644 --- a/searchlib/src/tests/predicate/document_features_store_test.cpp +++ b/searchlib/src/tests/predicate/document_features_store_test.cpp @@ -175,18 +175,19 @@ TEST("require that both features and ranges are removed by 'remove'") { } TEST("require that both features and ranges counts towards memory usage") { + constexpr size_t BASE_USED = 557152u; DocumentFeaturesStore features_store(10); - EXPECT_EQUAL(562024u, features_store.getMemoryUsage().usedBytes()); + EXPECT_EQUAL(BASE_USED, features_store.getMemoryUsage().usedBytes()); PredicateTreeAnnotations annotations; annotations.features.push_back(PredicateHash::hash64("foo=100-199")); features_store.insert(annotations, doc_id); - EXPECT_EQUAL(562376u, features_store.getMemoryUsage().usedBytes()); + EXPECT_EQUAL(BASE_USED + 352u, features_store.getMemoryUsage().usedBytes()); annotations.features.clear(); annotations.range_features.push_back({"foo", 100, 199}); features_store.insert(annotations, doc_id + 1); - EXPECT_EQUAL(562480u, features_store.getMemoryUsage().usedBytes()); + EXPECT_EQUAL(BASE_USED + 456u, features_store.getMemoryUsage().usedBytes()); } TEST("require that DocumentFeaturesStore can be serialized") { @@ -212,21 +213,22 @@ TEST("require that DocumentFeaturesStore can be serialized") { } TEST("require that serialization cleans up wordstore") { + constexpr size_t BASE_USED = 557592u; DocumentFeaturesStore features_store(10); PredicateTreeAnnotations annotations; annotations.range_features.push_back({"foo", 100, 199}); features_store.insert(annotations, doc_id); - EXPECT_EQUAL(562464u, features_store.getMemoryUsage().usedBytes()); + EXPECT_EQUAL(BASE_USED, features_store.getMemoryUsage().usedBytes()); annotations.range_features.push_back({"bar", 100, 199}); features_store.insert(annotations, doc_id + 1); - EXPECT_EQUAL(562524u, features_store.getMemoryUsage().usedBytes()); + EXPECT_EQUAL(BASE_USED +60u, features_store.getMemoryUsage().usedBytes()); features_store.remove(doc_id + 1); - EXPECT_EQUAL(562524u, features_store.getMemoryUsage().usedBytes()); + EXPECT_EQUAL(BASE_USED + 60u, features_store.getMemoryUsage().usedBytes()); vespalib::DataBuffer buffer; save_document_features_store(features_store, buffer); DocumentFeaturesStore features_store2(buffer); - EXPECT_EQUAL(562464u, features_store2.getMemoryUsage().usedBytes()); + EXPECT_EQUAL(BASE_USED, features_store2.getMemoryUsage().usedBytes()); } 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 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& dead_entries) +BufferFreeList::BufferFreeList(std::atomic& 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 namespace vespalib::datastore { @@ -17,29 +16,29 @@ class FreeList; */ class BufferFreeList { private: - using EntryRefArray = vespalib::Array; + using EntryRefArray = std::vector; std::atomic& _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& dead_entrie); + explicit BufferFreeList(std::atomic& 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/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 _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(); } }; -- cgit v1.2.3 From 40c6989ad209f62b8eb4c052796278f3482c4f7a Mon Sep 17 00:00:00 2001 From: Henning Baldersheim Date: Wed, 24 Apr 2024 13:08:22 +0000 Subject: Add noexcept --- .../src/vespa/vespalib/datastore/buffer_stats.cpp | 10 ++--- .../src/vespa/vespalib/datastore/buffer_stats.h | 48 +++++++++++----------- 2 files changed, 29 insertions(+), 29 deletions(-) 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 _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& used_entries_ref() { return _used_entries; } - std::atomic& dead_entries_ref() { return _dead_entries; } - std::atomic& extra_used_bytes_ref() { return _extra_used_bytes; } - std::atomic& 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& used_entries_ref() noexcept { return _used_entries; } + std::atomic& dead_entries_ref() noexcept { return _dead_entries; } + std::atomic& extra_used_bytes_ref() noexcept { return _extra_used_bytes; } + std::atomic& extra_hold_bytes_ref() noexcept { return _extra_hold_bytes; } }; } -- cgit v1.2.3 From 6c514bde43038a5031a99ecce6dbad8d14faf1c3 Mon Sep 17 00:00:00 2001 From: Henning Baldersheim Date: Wed, 24 Apr 2024 13:11:35 +0000 Subject: Add noexcept --- .../src/vespa/vespalib/datastore/buffer_type.cpp | 16 ++++---- .../src/vespa/vespalib/datastore/buffer_type.h | 28 ++++++------- .../src/vespa/vespalib/datastore/bufferstate.cpp | 10 ++--- .../src/vespa/vespalib/datastore/bufferstate.h | 46 ++++++++++------------ 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* 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 &_extraUsedBytes; std::atomic &_extraHoldBytes; public: - CleanContext(std::atomic& extraUsedBytes, std::atomic& extraHoldBytes) + CleanContext(std::atomic& extraUsedBytes, std::atomic& 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* used_entries, std::atomic* dead_entries, void* buffer); void on_hold(uint32_t buffer_id, const std::atomic* used_entries, const std::atomic* 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* used_entries, std::atomic* 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& 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 _counts; public: - AggregatedBufferCounts(); + AggregatedBufferCounts() noexcept; void add_buffer(const std::atomic* used_entries, const std::atomic* dead_entries); void remove_buffer(const std::atomic* used_entries, const std::atomic* 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& 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& 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; } -- cgit v1.2.3 From 5eb6eb5dddc63510f356c148eee5440892416253 Mon Sep 17 00:00:00 2001 From: Henning Baldersheim Date: Wed, 24 Apr 2024 13:16:38 +0000 Subject: Add noexcept --- vespalib/src/vespa/vespalib/datastore/datastore.h | 2 +- .../src/vespa/vespalib/datastore/datastorebase.cpp | 18 +++++----- .../src/vespa/vespalib/datastore/datastorebase.h | 38 +++++++++++----------- 3 files changed, 29 insertions(+), 29 deletions(-) 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::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 &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 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 - 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())); -- cgit v1.2.3 From d308c42b52505935a05f0deb2b859cf5ecd8a145 Mon Sep 17 00:00:00 2001 From: Henning Baldersheim Date: Wed, 24 Apr 2024 19:51:52 +0000 Subject: Remove incorrect noexcept --- .../src/vespa/vespalib/datastore/bufferstate.cpp | 20 ++++++-------------- 1 file changed, 6 insertions(+), 14 deletions(-) diff --git a/vespalib/src/vespa/vespalib/datastore/bufferstate.cpp b/vespalib/src/vespa/vespalib/datastore/bufferstate.cpp index c0c65ace7cf..49f126d4a7c 100644 --- a/vespalib/src/vespa/vespalib/datastore/bufferstate.cpp +++ b/vespalib/src/vespa/vespalib/datastore/bufferstate.cpp @@ -57,10 +57,7 @@ roundUpToMatchAllocator(size_t sz) noexcept } AllocResult -calc_allocation(uint32_t bufferId, - BufferTypeBase &typeHandler, - size_t free_entries_needed, - bool resizing) noexcept +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(); @@ -78,10 +75,8 @@ calc_allocation(uint32_t bufferId, } void -BufferState::on_active(uint32_t bufferId, uint32_t typeId, - BufferTypeBase *typeHandler, - size_t free_entries_needed, - std::atomic& buffer) +BufferState::on_active(uint32_t bufferId, uint32_t typeId, BufferTypeBase *typeHandler, + size_t free_entries_needed, std::atomic& 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& buffer, - Alloc &holdBuffer) +BufferState::fallback_resize(uint32_t bufferId, size_t free_entries_needed, + std::atomic& buffer, Alloc &holdBuffer) { assert(getState() == State::ACTIVE); auto type_handler = getTypeHandler(); -- cgit v1.2.3