Move tracking of datastore buffer statistics to separate classes.

4 files changed, 54 insertions, 54 deletions

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 1e8632aee95..1708b0fd948 100644
--- a/vespalib/src/tests/datastore/array_store/array_store_test.cpp
+++ b/vespalib/src/tests/datastore/array_store/array_store_test.cpp
@@ -20,7 +20,7 @@ using vespalib::alloc::MemoryAllocator;
 using vespalib::alloc::test::MemoryAllocatorObserver;
 
 using AllocStats = MemoryAllocatorObserver::Stats;
-using BufferStats = vespalib::datastore::test::BufferStats;
+using TestBufferStats = vespalib::datastore::test::BufferStats;
 using MemStats = vespalib::datastore::test::MemStats;
 
 namespace {
@@ -98,16 +98,16 @@ struct ArrayStoreTest : public TestT
     }
     void assertBufferState(EntryRef ref, const MemStats& expStats) const {
         EXPECT_EQ(expStats._used, store.bufferState(ref).size());
-        EXPECT_EQ(expStats._hold, store.bufferState(ref).getHoldElems());
-        EXPECT_EQ(expStats._dead, store.bufferState(ref).getDeadElems());
+        EXPECT_EQ(expStats._hold, store.bufferState(ref).stats().hold_elems());
+        EXPECT_EQ(expStats._dead, store.bufferState(ref).stats().dead_elems());
     }
-    void assert_buffer_stats(EntryRef ref, const BufferStats& exp_stats) const {
+    void assert_buffer_stats(EntryRef ref, const TestBufferStats& exp_stats) const {
         auto& state = store.bufferState(ref);
         EXPECT_EQ(exp_stats._used, state.size());
-        EXPECT_EQ(exp_stats._hold, state.getHoldElems());
-        EXPECT_EQ(exp_stats._dead, state.getDeadElems());
-        EXPECT_EQ(exp_stats._extra_used, state.getExtraUsedBytes());
-        EXPECT_EQ(exp_stats._extra_hold, state.getExtraHoldBytes());
+        EXPECT_EQ(exp_stats._hold, state.stats().hold_elems());
+        EXPECT_EQ(exp_stats._dead, state.stats().dead_elems());
+        EXPECT_EQ(exp_stats._extra_used, state.stats().extra_used_bytes());
+        EXPECT_EQ(exp_stats._extra_hold, state.stats().extra_hold_bytes());
     }
     void assertMemoryUsage(const MemStats expStats) const {
         MemoryUsage act = store.getMemoryUsage();
@@ -280,13 +280,13 @@ TEST_P(NumberStoreFreeListsDisabledTest, large_arrays_are_NOT_allocated_from_fre
 
 TEST_P(NumberStoreTest, track_size_of_large_array_allocations_with_free_lists_enabled) {
     EntryRef ref = add({1,2,3,4});
-    assert_buffer_stats(ref, BufferStats().used(2).hold(0).dead(1).extra_used(16));
+    assert_buffer_stats(ref, TestBufferStats().used(2).hold(0).dead(1).extra_used(16));
     remove({1,2,3,4});
-    assert_buffer_stats(ref, BufferStats().used(2).hold(1).dead(1).extra_hold(16).extra_used(16));
+    assert_buffer_stats(ref, TestBufferStats().used(2).hold(1).dead(1).extra_hold(16).extra_used(16));
     trimHoldLists();
-    assert_buffer_stats(ref, BufferStats().used(2).hold(0).dead(2).extra_used(0));
+    assert_buffer_stats(ref, TestBufferStats().used(2).hold(0).dead(2).extra_used(0));
     add({5,6,7,8,9});
-    assert_buffer_stats(ref, BufferStats().used(2).hold(0).dead(1).extra_used(20));
+    assert_buffer_stats(ref, TestBufferStats().used(2).hold(0).dead(1).extra_used(20));
 }
 
 TEST_F(SmallOffsetNumberStoreTest, new_underlying_buffer_is_allocated_when_current_is_full)
diff --git a/vespalib/src/tests/datastore/datastore/datastore_test.cpp b/vespalib/src/tests/datastore/datastore/datastore_test.cpp
index 9522aa1e0dc..bf389e5e78e 100644
--- a/vespalib/src/tests/datastore/datastore/datastore_test.cpp
+++ b/vespalib/src/tests/datastore/datastore/datastore_test.cpp
@@ -55,7 +55,7 @@ public:
 
 
 using GrowthStats = std::vector<int>;
-using BufferStats = std::vector<int>;
+using BufferIds = std::vector<int>;
 
 constexpr float ALLOC_GROW_FACTOR = 0.4;
 constexpr size_t HUGE_PAGE_ARRAY_SIZE = (MemoryAllocator::HUGEPAGE_SIZE / sizeof(int));
@@ -124,8 +124,8 @@ public:
             ++i;
         }
     }
-    BufferStats getBuffers(size_t bufs) {
-        BufferStats buffers;
+    BufferIds getBuffers(size_t bufs) {
+        BufferIds buffers;
         while (buffers.size() < bufs) {
             RefType iRef = (_type.getArraySize() == 1) ?
                            (_store.template allocator<DataType>(_typeId).alloc().ref) :
@@ -143,8 +143,8 @@ public:
 using MyRef = MyStore::RefType;
 
 void
-assertMemStats(const DataStoreBase::MemStats &exp,
-               const DataStoreBase::MemStats &act)
+assertMemStats(const MemoryStats &exp,
+               const MemoryStats &act)
 {
     EXPECT_EQ(exp._allocElems, act._allocElems);
     EXPECT_EQ(exp._usedElems, act._usedElems);
@@ -414,7 +414,7 @@ TEST(DataStoreTest, require_that_we_can_use_free_lists_with_raw_allocator)
 TEST(DataStoreTest, require_that_memory_stats_are_calculated)
 {
     MyStore s;
-    DataStoreBase::MemStats m;
+    MemoryStats m;
     m._allocElems = MyRef::offsetSize();
     m._usedElems = 1; // ref = 0 is reserved
     m._deadElems = 1; // ref = 0 is reserved
@@ -466,7 +466,7 @@ TEST(DataStoreTest, require_that_memory_stats_are_calculated)
 
     { // increase extra used bytes
         auto prev_stats = s.getMemStats();
-        s.get_active_buffer_state().incExtraUsedBytes(50);
+        s.get_active_buffer_state().stats().inc_extra_used_bytes(50);
         auto curr_stats = s.getMemStats();
         EXPECT_EQ(prev_stats._allocBytes + 50, curr_stats._allocBytes);
         EXPECT_EQ(prev_stats._usedBytes + 50, curr_stats._usedBytes);
@@ -474,7 +474,7 @@ TEST(DataStoreTest, require_that_memory_stats_are_calculated)
 
     { // increase extra hold bytes
         auto prev_stats = s.getMemStats();
-        s.get_active_buffer_state().incExtraHoldBytes(30);
+        s.get_active_buffer_state().stats().inc_extra_hold_bytes(30);
         auto curr_stats = s.getMemStats();
         EXPECT_EQ(prev_stats._holdBytes + 30, curr_stats._holdBytes);
     }
@@ -655,7 +655,7 @@ TEST(DataStoreTest, can_set_memory_allocator)
 namespace {
 
 void
-assertBuffers(BufferStats exp_buffers, size_t num_arrays_for_new_buffer)
+assertBuffers(BufferIds exp_buffers, size_t num_arrays_for_new_buffer)
 {
     EXPECT_EQ(exp_buffers, IntGrowStore(1, 1, 1024, num_arrays_for_new_buffer).getBuffers(exp_buffers.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 56c1d0c0f63..6612ef998c5 100644
--- a/vespalib/src/tests/datastore/unique_store/unique_store_test.cpp
+++ b/vespalib/src/tests/datastore/unique_store/unique_store_test.cpp
@@ -21,10 +21,10 @@ enum class DictionaryType { BTREE, HASH, BTREE_AND_HASH };
 using namespace vespalib::datastore;
 using vespalib::ArrayRef;
 using generation_t = vespalib::GenerationHandler::generation_t;
-using vespalib::datastore::test::BufferStats;
 using vespalib::alloc::MemoryAllocator;
 using vespalib::alloc::test::MemoryAllocatorObserver;
 using AllocStats = MemoryAllocatorObserver::Stats;
+using TestBufferStats = vespalib::datastore::test::BufferStats;
 
 template <typename UniqueStoreT>
 struct TestBaseValues {
@@ -94,10 +94,10 @@ struct TestBase : public ::testing::Test {
     uint32_t getBufferId(EntryRef ref) const {
         return EntryRefType(ref).bufferId();
     }
-    void assertBufferState(EntryRef ref, const BufferStats expStats) const {
+    void assertBufferState(EntryRef ref, const TestBufferStats expStats) const {
         EXPECT_EQ(expStats._used, store.bufferState(ref).size());
-        EXPECT_EQ(expStats._hold, store.bufferState(ref).getHoldElems());
-        EXPECT_EQ(expStats._dead, store.bufferState(ref).getDeadElems());
+        EXPECT_EQ(expStats._hold, store.bufferState(ref).stats().hold_elems());
+        EXPECT_EQ(expStats._dead, store.bufferState(ref).stats().dead_elems());
     }
     void assertStoreContent() const {
         for (const auto &elem : refStore) {
@@ -320,9 +320,9 @@ TYPED_TEST(TestBase, elements_are_put_on_hold_when_value_is_removed)
     EntryRef ref = this->add(this->values()[0]);
     size_t reserved = this->get_reserved(ref);
     size_t array_size = this->get_array_size(ref);
-    this->assertBufferState(ref, BufferStats().used(array_size + reserved).hold(0).dead(reserved));
+    this->assertBufferState(ref, TestBufferStats().used(array_size + reserved).hold(0).dead(reserved));
     this->store.remove(ref);
-    this->assertBufferState(ref, BufferStats().used(array_size + reserved).hold(array_size).dead(reserved));
+    this->assertBufferState(ref, TestBufferStats().used(array_size + reserved).hold(array_size).dead(reserved));
 }
 
 TYPED_TEST(TestBase, elements_are_reference_counted)
@@ -333,11 +333,11 @@ TYPED_TEST(TestBase, elements_are_reference_counted)
     // Note: The first buffer have the first element reserved -> we expect 2 elements used here.
     size_t reserved = this->get_reserved(ref);
     size_t array_size = this->get_array_size(ref);
-    this->assertBufferState(ref, BufferStats().used(array_size + reserved).hold(0).dead(reserved));
+    this->assertBufferState(ref, TestBufferStats().used(array_size + reserved).hold(0).dead(reserved));
     this->store.remove(ref);
-    this->assertBufferState(ref, BufferStats().used(array_size + reserved).hold(0).dead(reserved));
+    this->assertBufferState(ref, TestBufferStats().used(array_size + reserved).hold(0).dead(reserved));
     this->store.remove(ref);
-    this->assertBufferState(ref, BufferStats().used(array_size + reserved).hold(array_size).dead(reserved));
+    this->assertBufferState(ref, TestBufferStats().used(array_size + reserved).hold(array_size).dead(reserved));
 }
 
 TEST_F(SmallOffsetNumberTest, new_underlying_buffer_is_allocated_when_current_is_full)
@@ -367,7 +367,7 @@ TYPED_TEST(TestBase, store_can_be_compacted)
     this->trimHoldLists();
     size_t reserved = this->get_reserved(val0Ref);
     size_t array_size = this->get_array_size(val0Ref);
-    this->assertBufferState(val0Ref, BufferStats().used(reserved + 3 * array_size).dead(reserved + array_size));
+    this->assertBufferState(val0Ref, TestBufferStats().used(reserved + 3 * array_size).dead(reserved + array_size));
     uint32_t val1BufferId = this->getBufferId(val0Ref);
 
     EXPECT_EQ(2u, this->refStore.size());
@@ -396,7 +396,7 @@ TYPED_TEST(TestBase, store_can_be_instantiated_with_builder)
     EntryRef val1Ref = builder.mapEnumValueToEntryRef(2);
     size_t reserved = this->get_reserved(val0Ref);
     size_t array_size = this->get_array_size(val0Ref);
-    this->assertBufferState(val0Ref, BufferStats().used(2 * array_size + reserved).dead(reserved)); // Note: First element is reserved
+    this->assertBufferState(val0Ref, TestBufferStats().used(2 * array_size + reserved).dead(reserved)); // Note: First element is reserved
     EXPECT_TRUE(val0Ref.valid());
     EXPECT_TRUE(val1Ref.valid());
     EXPECT_NE(val0Ref.ref(), val1Ref.ref());
diff --git a/vespalib/src/tests/datastore/unique_store_string_allocator/unique_store_string_allocator_test.cpp b/vespalib/src/tests/datastore/unique_store_string_allocator/unique_store_string_allocator_test.cpp
index 777da0c2b16..f68dd4dde66 100644
--- a/vespalib/src/tests/datastore/unique_store_string_allocator/unique_store_string_allocator_test.cpp
+++ b/vespalib/src/tests/datastore/unique_store_string_allocator/unique_store_string_allocator_test.cpp
@@ -11,7 +11,7 @@
 using namespace vespalib::datastore;
 using vespalib::MemoryUsage;
 using generation_t = vespalib::GenerationHandler::generation_t;
-using BufferStats = vespalib::datastore::test::BufferStats;
+using TestBufferStats = vespalib::datastore::test::BufferStats;
 using vespalib::alloc::MemoryAllocator;
 using vespalib::alloc::test::MemoryAllocatorObserver;
 using AllocStats = MemoryAllocatorObserver::Stats;
@@ -60,12 +60,12 @@ struct TestBase : public ::testing::Test {
     const BufferState &buffer_state(EntryRef ref) const {
         return allocator.get_data_store().getBufferState(get_buffer_id(ref));
     }
-    void assert_buffer_state(EntryRef ref, const BufferStats expStats) const {
+    void assert_buffer_state(EntryRef ref, const TestBufferStats expStats) const {
         EXPECT_EQ(expStats._used, buffer_state(ref).size());
-        EXPECT_EQ(expStats._hold, buffer_state(ref).getHoldElems());
-        EXPECT_EQ(expStats._dead, buffer_state(ref).getDeadElems());
-        EXPECT_EQ(expStats._extra_used, buffer_state(ref).getExtraUsedBytes());
-        EXPECT_EQ(expStats._extra_hold, buffer_state(ref).getExtraHoldBytes());
+        EXPECT_EQ(expStats._hold, buffer_state(ref).stats().hold_elems());
+        EXPECT_EQ(expStats._dead, buffer_state(ref).stats().dead_elems());
+        EXPECT_EQ(expStats._extra_used, buffer_state(ref).stats().extra_used_bytes());
+        EXPECT_EQ(expStats._extra_hold, buffer_state(ref).stats().extra_hold_bytes());
     }
     void trim_hold_lists() {
         allocator.get_data_store().transferHoldLists(generation++);
@@ -86,32 +86,32 @@ TEST_F(StringTest, can_add_and_get_values)
 TEST_F(StringTest, elements_are_put_on_hold_when_value_is_removed)
 {
     EntryRef ref = add(small.c_str());
-    assert_buffer_state(ref, BufferStats().used(16).hold(0).dead(0));
+    assert_buffer_state(ref, TestBufferStats().used(16).hold(0).dead(0));
     remove(ref);
-    assert_buffer_state(ref, BufferStats().used(16).hold(16).dead(0));
+    assert_buffer_state(ref, TestBufferStats().used(16).hold(16).dead(0));
     trim_hold_lists();
-    assert_buffer_state(ref, BufferStats().used(16).hold(0).dead(16));
+    assert_buffer_state(ref, TestBufferStats().used(16).hold(0).dead(16));
 }
 
 TEST_F(StringTest, extra_bytes_used_is_tracked)
 {
     EntryRef ref = add(spaces1000.c_str());
     // Note: The first buffer have the first element reserved -> we expect 2 elements used here.
-    assert_buffer_state(ref, BufferStats().used(2).hold(0).dead(1).extra_used(1001));
+    assert_buffer_state(ref, TestBufferStats().used(2).hold(0).dead(1).extra_used(1001));
     remove(ref);
-    assert_buffer_state(ref, BufferStats().used(2).hold(1).dead(1).extra_used(1001).extra_hold(1001));
+    assert_buffer_state(ref, TestBufferStats().used(2).hold(1).dead(1).extra_used(1001).extra_hold(1001));
     trim_hold_lists();
-    assert_buffer_state(ref, BufferStats().used(2).hold(0).dead(2));
+    assert_buffer_state(ref, TestBufferStats().used(2).hold(0).dead(2));
     ref = add(spaces1000.c_str());
-    assert_buffer_state(ref, BufferStats().used(2).hold(0).dead(1).extra_used(1001));
+    assert_buffer_state(ref, TestBufferStats().used(2).hold(0).dead(1).extra_used(1001));
     EntryRef ref2 = move(ref);
     assert_get(ref2, spaces1000.c_str());
-    assert_buffer_state(ref, BufferStats().used(3).hold(0).dead(1).extra_used(2002));
+    assert_buffer_state(ref, TestBufferStats().used(3).hold(0).dead(1).extra_used(2002));
     remove(ref);
     remove(ref2);
-    assert_buffer_state(ref, BufferStats().used(3).hold(2).dead(1).extra_used(2002).extra_hold(2002));
+    assert_buffer_state(ref, TestBufferStats().used(3).hold(2).dead(1).extra_used(2002).extra_hold(2002));
     trim_hold_lists();
-    assert_buffer_state(ref, BufferStats().used(3).hold(0).dead(3));
+    assert_buffer_state(ref, TestBufferStats().used(3).hold(0).dead(3));
 }
 
 TEST_F(StringTest, string_length_determines_buffer)
@@ -139,8 +139,8 @@ TEST_F(StringTest, free_list_is_used_when_enabled)
     EntryRef ref4 = add(spaces1000.c_str());
     EXPECT_EQ(ref1, ref3);
     EXPECT_EQ(ref2, ref4);
-    assert_buffer_state(ref1, BufferStats().used(16).hold(0).dead(0));
-    assert_buffer_state(ref2, BufferStats().used(2).hold(0).dead(1).extra_used(1001));
+    assert_buffer_state(ref1, TestBufferStats().used(16).hold(0).dead(0));
+    assert_buffer_state(ref2, TestBufferStats().used(2).hold(0).dead(1).extra_used(1001));
 }
 
 TEST_F(StringTest, free_list_is_not_used_when_disabled)
@@ -155,8 +155,8 @@ TEST_F(StringTest, free_list_is_not_used_when_disabled)
     EntryRef ref4 = add(spaces1000.c_str());
     EXPECT_NE(ref1, ref3);
     EXPECT_NE(ref2, ref4);
-    assert_buffer_state(ref1, BufferStats().used(32).hold(0).dead(16));
-    assert_buffer_state(ref2, BufferStats().used(3).hold(0).dead(2).extra_used(1001));
+    assert_buffer_state(ref1, TestBufferStats().used(32).hold(0).dead(16));
+    assert_buffer_state(ref2, TestBufferStats().used(3).hold(0).dead(2).extra_used(1001));
 }
 
 TEST_F(StringTest, free_list_is_never_used_for_move)
@@ -173,8 +173,8 @@ TEST_F(StringTest, free_list_is_never_used_for_move)
     EntryRef ref6 = move(ref2);
     EXPECT_NE(ref5, ref3);
     EXPECT_NE(ref6, ref4);
-    assert_buffer_state(ref1, BufferStats().used(48).hold(0).dead(16));
-    assert_buffer_state(ref2, BufferStats().used(4).hold(0).dead(2).extra_used(2002));
+    assert_buffer_state(ref1, TestBufferStats().used(48).hold(0).dead(16));
+    assert_buffer_state(ref2, TestBufferStats().used(4).hold(0).dead(2).extra_used(2002));
 }
 
 TEST_F(StringTest, provided_memory_allocator_is_used)