Merge pull request #26387 from vespa-engine/balder/track-datastore-static-memory

Balder/track datastore static memory

14 files changed, 111 insertions, 66 deletions

diff --git a/searchlib/src/tests/attribute/attribute_test.cpp b/searchlib/src/tests/attribute/attribute_test.cpp
index 18896ca24c1..16b5ef78951 100644
--- a/searchlib/src/tests/attribute/attribute_test.cpp
+++ b/searchlib/src/tests/attribute/attribute_test.cpp
@@ -898,6 +898,7 @@ AttributeTest::testSingle()
             AttributePtr ptr = createAttribute("sv-int32", Config(BasicType::INT32, CollectionType::SINGLE));
             ptr->updateStat(true);
             EXPECT_EQ(12288u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(0u, ptr->getStatus().getUsed());
             addDocs(ptr, numDocs);
             testSingle<IntegerAttribute, AttributeVector::largeint_t, int32_t>(ptr, values);
         }
@@ -911,7 +912,8 @@ AttributeTest::testSingle()
             cfg.setFastSearch(true);
             AttributePtr ptr = createAttribute("sv-post-int32", cfg);
             ptr->updateStat(true);
-            EXPECT_EQ(231640u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(887756u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(656444u, ptr->getStatus().getUsed());
             addDocs(ptr, numDocs);
             testSingle<IntegerAttribute, AttributeVector::largeint_t, int32_t>(ptr, values);
         }
@@ -923,6 +925,7 @@ AttributeTest::testSingle()
             AttributePtr ptr = createAttribute("sv-float", Config(BasicType::FLOAT, CollectionType::SINGLE));
             ptr->updateStat(true);
             EXPECT_EQ(12288u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(0u, ptr->getStatus().getUsed());
             addDocs(ptr, numDocs);
             testSingle<FloatingPointAttribute, double, float>(ptr, values);
         }
@@ -931,7 +934,8 @@ AttributeTest::testSingle()
             cfg.setFastSearch(true);
             AttributePtr ptr = createAttribute("sv-post-float", cfg);
             ptr->updateStat(true);
-            EXPECT_EQ(231640u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(887756u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(656444u, ptr->getStatus().getUsed());
             addDocs(ptr, numDocs);
             testSingle<FloatingPointAttribute, double, float>(ptr, values);
         }
@@ -943,7 +947,8 @@ AttributeTest::testSingle()
         {
             AttributePtr ptr = createAttribute("sv-string", Config(BasicType::STRING, CollectionType::SINGLE));
             ptr->updateStat(true);
-            EXPECT_EQ(74648u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(403552u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(328576u, ptr->getStatus().getUsed());
             addDocs(ptr, numDocs);
             testSingle<StringAttribute, string, string>(ptr, values);
         }
@@ -952,7 +957,8 @@ AttributeTest::testSingle()
             cfg.setFastSearch(true);
             AttributePtr ptr = createAttribute("sv-fs-string", cfg);
             ptr->updateStat(true);
-            EXPECT_EQ(245024u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(902256u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(657088u, ptr->getStatus().getUsed());
             addDocs(ptr, numDocs);
             testSingle<StringAttribute, string, string>(ptr, values);
         }
@@ -1083,7 +1089,8 @@ AttributeTest::testArray()
         {
             AttributePtr ptr = createAttribute("a-int32", Config(BasicType::INT32, CollectionType::ARRAY));
             ptr->updateStat(true);
-            EXPECT_EQ(12320u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(1474480u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(1462192u, ptr->getStatus().getUsed());
             addDocs(ptr, numDocs);
             testArray<IntegerAttribute, AttributeVector::largeint_t>(ptr, values);
         }
@@ -1092,7 +1099,8 @@ AttributeTest::testArray()
             cfg.setFastSearch(true);
             AttributePtr ptr = createAttribute("flags", cfg);
             ptr->updateStat(true);
-            EXPECT_EQ(12320u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(1474480u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(1462192u, ptr->getStatus().getUsed());
             addDocs(ptr, numDocs);
             testArray<IntegerAttribute, AttributeVector::largeint_t>(ptr, values);
         }
@@ -1101,7 +1109,8 @@ AttributeTest::testArray()
             cfg.setFastSearch(true);
             AttributePtr ptr = createAttribute("a-fs-int32", cfg);
             ptr->updateStat(true);
-            EXPECT_EQ(253608u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(2371884u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(2118656u, ptr->getStatus().getUsed());
             addDocs(ptr, numDocs);
             testArray<IntegerAttribute, AttributeVector::largeint_t>(ptr, values);
         }
@@ -1119,7 +1128,8 @@ AttributeTest::testArray()
             cfg.setFastSearch(true);
             AttributePtr ptr = createAttribute("a-fs-float", cfg);
             ptr->updateStat(true);
-            EXPECT_EQ(253608u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(2371884u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(2118656u, ptr->getStatus().getUsed());
             addDocs(ptr, numDocs);
             testArray<FloatingPointAttribute, double>(ptr, values);
         }
@@ -1130,7 +1140,8 @@ AttributeTest::testArray()
         {
             AttributePtr ptr = createAttribute("a-string", Config(BasicType::STRING, CollectionType::ARRAY));
             ptr->updateStat(true);
-            EXPECT_EQ(74680u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(1865744u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(1790768u, ptr->getStatus().getUsed());
             addDocs(ptr, numDocs);
             testArray<StringAttribute, string>(ptr, values);
         }
@@ -1139,7 +1150,8 @@ AttributeTest::testArray()
             cfg.setFastSearch(true);
             AttributePtr ptr = createAttribute("afs-string", cfg);
             ptr->updateStat(true);
-            EXPECT_EQ(266992u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(2386384u, ptr->getStatus().getAllocated());
+            EXPECT_EQ(2119300u, ptr->getStatus().getUsed());
             addDocs(ptr, numDocs);
             testArray<StringAttribute, string>(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 4f7a7934d4c..1b1c1181666 100644
--- a/searchlib/src/tests/memoryindex/memory_index/memory_index_test.cpp
+++ b/searchlib/src/tests/memoryindex/memory_index/memory_index_test.cpp
@@ -462,22 +462,26 @@ 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_SIZE = 188172u;
+    constexpr size_t BASE_ALLOCATED = 1172040u;
+    constexpr size_t BASE_USED = 984116u;
     {
         MySetup setup;
         Index index(setup);
         EXPECT_EQ(0u, index.index.getStaticMemoryFootprint());
         EXPECT_EQ(index.index.getStaticMemoryFootprint(), index.index.getMemoryUsage().allocatedBytes());
+        EXPECT_EQ(0u, index.index.getMemoryUsage().usedBytes());
     }
     {
         Index index(MySetup().field("f1"));
-        EXPECT_EQ(BASE_SIZE, index.index.getStaticMemoryFootprint());
+        EXPECT_EQ(BASE_ALLOCATED, index.index.getStaticMemoryFootprint());
         EXPECT_EQ(index.index.getStaticMemoryFootprint(), index.index.getMemoryUsage().allocatedBytes());
+        EXPECT_EQ(BASE_USED, index.index.getMemoryUsage().usedBytes());
     }
     {
         Index index(MySetup().field("f1").field("f2"));
-        EXPECT_EQ(2 * BASE_SIZE, index.index.getStaticMemoryFootprint());
+        EXPECT_EQ(2 * BASE_ALLOCATED, index.index.getStaticMemoryFootprint());
         EXPECT_EQ(index.index.getStaticMemoryFootprint(), index.index.getMemoryUsage().allocatedBytes());
+        EXPECT_EQ(2 * BASE_USED, index.index.getMemoryUsage().usedBytes());
     }
 }
 
@@ -511,12 +515,12 @@ TEST(MemoryIndexTest, require_that_we_can_fake_bit_vector)
 
         Searchable &searchable = index.index;
         Blueprint::UP res = searchable.createBlueprint(requestContext, fields, makeTerm(foo));
-        EXPECT_TRUE(res.get() != NULL);
+        EXPECT_TRUE(res);
 
         res->fetchPostings(search::queryeval::ExecuteInfo::TRUE);
         SearchIterator::UP search = res->createSearch(*match_data, true);
-        EXPECT_TRUE(search.get() != NULL);
-        EXPECT_TRUE(dynamic_cast<BooleanMatchIteratorWrapper *>(search.get()) != NULL);
+        EXPECT_TRUE(search);
+        EXPECT_TRUE(dynamic_cast<BooleanMatchIteratorWrapper *>(search.get()) != nullptr);
         search->initFullRange();
         EXPECT_EQ("1,3", toString(*search));
     }
diff --git a/searchlib/src/tests/predicate/document_features_store_test.cpp b/searchlib/src/tests/predicate/document_features_store_test.cpp
index fbd4629cc4a..c37fe2739ca 100644
--- a/searchlib/src/tests/predicate/document_features_store_test.cpp
+++ b/searchlib/src/tests/predicate/document_features_store_test.cpp
@@ -165,17 +165,17 @@ TEST("require that both features and ranges are removed by 'remove'") {
 
 TEST("require that both features and ranges counts towards memory usage") {
     DocumentFeaturesStore features_store(10);
-    EXPECT_EQUAL(364u, features_store.getMemoryUsage().usedBytes());
+    EXPECT_EQUAL(328152u, features_store.getMemoryUsage().usedBytes());
 
     PredicateTreeAnnotations annotations;
     annotations.features.push_back(PredicateHash::hash64("foo=100-199"));
     features_store.insert(annotations, doc_id);
-    EXPECT_EQUAL(372u, features_store.getMemoryUsage().usedBytes());
+    EXPECT_EQUAL(328160u, features_store.getMemoryUsage().usedBytes());
 
     annotations.features.clear();
     annotations.range_features.push_back({"foo", 100, 199});
     features_store.insert(annotations, doc_id + 1);
-    EXPECT_EQUAL(468u, features_store.getMemoryUsage().usedBytes());
+    EXPECT_EQUAL(328256u, features_store.getMemoryUsage().usedBytes());
 }
 
 TEST("require that DocumentFeaturesStore can be serialized") {
@@ -205,17 +205,17 @@ TEST("require that serialization cleans up wordstore") {
     PredicateTreeAnnotations annotations;
     annotations.range_features.push_back({"foo", 100, 199});
     features_store.insert(annotations, doc_id);
-    EXPECT_EQUAL(460u, features_store.getMemoryUsage().usedBytes());
+    EXPECT_EQUAL(328248u, features_store.getMemoryUsage().usedBytes());
     annotations.range_features.push_back({"bar", 100, 199});
     features_store.insert(annotations, doc_id + 1);
-    EXPECT_EQUAL(848u, features_store.getMemoryUsage().usedBytes());
+    EXPECT_EQUAL(328636u, features_store.getMemoryUsage().usedBytes());
     features_store.remove(doc_id + 1);
-    EXPECT_EQUAL(800u, features_store.getMemoryUsage().usedBytes());
+    EXPECT_EQUAL(328588u, features_store.getMemoryUsage().usedBytes());
 
     vespalib::DataBuffer buffer;
     features_store.serialize(buffer);
     DocumentFeaturesStore features_store2(buffer);
-    EXPECT_EQUAL(460u, features_store2.getMemoryUsage().usedBytes());
+    EXPECT_EQUAL(328248u, features_store2.getMemoryUsage().usedBytes());
 }
 
 
diff --git a/searchlib/src/vespa/searchlib/attribute/attributevector.cpp b/searchlib/src/vespa/searchlib/attribute/attributevector.cpp
index 7f8f3f92f9e..e6b584d29b2 100644
--- a/searchlib/src/vespa/searchlib/attribute/attributevector.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/attributevector.cpp
@@ -590,7 +590,6 @@ AttributeVector::getEstimatedSaveByteSize() const
     uint64_t idxFileSize = 0;
     uint64_t udatFileSize = 0;
     size_t fixedWidth = getFixedWidth();
-    vespalib::MemoryUsage values_mem_usage = getEnumStoreValuesMemoryUsage();
 
     if (hasMultiValue()) {
         idxFileSize = headerSize + sizeof(uint32_t) * (docIdLimit + 1);
@@ -603,6 +602,7 @@ AttributeVector::getEstimatedSaveByteSize() const
         if (fixedWidth != 0) {
             udatFileSize = headerSize + fixedWidth * uniqueValueCount;
         } else {
+            vespalib::MemoryUsage values_mem_usage = getEnumStoreValuesMemoryUsage();
             size_t unique_values_bytes = values_mem_usage.usedBytes() -
                     (values_mem_usage.deadBytes() + values_mem_usage.allocatedBytesOnHold());
             size_t ref_count_mem_usage = sizeof(uint32_t) * uniqueValueCount;
diff --git a/searchlib/src/vespa/searchlib/attribute/enumattribute.hpp b/searchlib/src/vespa/searchlib/attribute/enumattribute.hpp
index 6d6022d59dd..c5188b89129 100644
--- a/searchlib/src/vespa/searchlib/attribute/enumattribute.hpp
+++ b/searchlib/src/vespa/searchlib/attribute/enumattribute.hpp
@@ -74,7 +74,7 @@ template <typename B>
 vespalib::MemoryUsage
 EnumAttribute<B>::getEnumStoreValuesMemoryUsage() const
 {
-    return _enumStore.get_values_memory_usage();
+    return _enumStore.get_dynamic_values_memory_usage();
 }
 
 template <typename B>
diff --git a/searchlib/src/vespa/searchlib/attribute/enumstore.h b/searchlib/src/vespa/searchlib/attribute/enumstore.h
index 0a0b2040b2a..df3a595ae34 100644
--- a/searchlib/src/vespa/searchlib/attribute/enumstore.h
+++ b/searchlib/src/vespa/searchlib/attribute/enumstore.h
@@ -91,7 +91,12 @@ public:
     uint32_t get_num_uniques() const override { return _dict->get_num_uniques(); }
     bool is_folded() const { return _is_folded;}
 
-    vespalib::MemoryUsage get_values_memory_usage() const override { return _store.get_allocator().get_data_store().getMemoryUsage(); }
+    vespalib::MemoryUsage get_values_memory_usage() const override {
+        return _store.get_allocator().get_data_store().getMemoryUsage();
+    }
+    vespalib::MemoryUsage get_dynamic_values_memory_usage() const {
+        return _store.get_allocator().get_data_store().getDynamicMemoryUsage();
+    }
     vespalib::MemoryUsage get_dictionary_memory_usage() const override { return _dict->get_memory_usage(); }
 
     vespalib::AddressSpace get_values_address_space_usage() const override;
diff --git a/vespalib/src/tests/btree/btree_test.cpp b/vespalib/src/tests/btree/btree_test.cpp
index 2a465f2c60a..ef64549e16a 100644
--- a/vespalib/src/tests/btree/btree_test.cpp
+++ b/vespalib/src/tests/btree/btree_test.cpp
@@ -1064,6 +1064,7 @@ adjustAllocatedBytes(size_t nodeCount, size_t nodeSize)
 
 TEST_F(BTreeTest, require_that_memory_usage_is_calculated)
 {
+    constexpr size_t BASE = 163912;
     typedef BTreeNodeAllocator<int32_t, int8_t,
         btree::NoAggregated,
         MyTraits::INTERNAL_SLOTS, MyTraits::LEAF_SLOTS> NodeAllocator;
@@ -1082,6 +1083,8 @@ TEST_F(BTreeTest, require_that_memory_usage_is_calculated)
     const uint32_t initialLeafNodes = 128u;
     mu.incAllocatedBytes(adjustAllocatedBytes(initialInternalNodes, sizeof(INode)));
     mu.incAllocatedBytes(adjustAllocatedBytes(initialLeafNodes, sizeof(LNode)));
+    mu.incAllocatedBytes(BASE);
+    mu.incUsedBytes(BASE);
     mu.incUsedBytes(sizeof(INode));
     mu.incDeadBytes(sizeof(INode));
     EXPECT_TRUE(assertMemoryUsage(mu, tm.getMemoryUsage()));
@@ -1112,6 +1115,8 @@ TEST_F(BTreeTest, require_that_memory_usage_is_calculated)
     mu = vespalib::MemoryUsage();
     mu.incAllocatedBytes(adjustAllocatedBytes(initialInternalNodes, sizeof(INode)));
     mu.incAllocatedBytes(adjustAllocatedBytes(initialLeafNodes, sizeof(LNode)));
+    mu.incAllocatedBytes(BASE);
+    mu.incUsedBytes(BASE);
     mu.incUsedBytes(sizeof(INode) * 2);
     mu.incDeadBytes(sizeof(INode) * 2);
     mu.incUsedBytes(sizeof(LNode));
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 063ac445933..3ebe8fdba1a 100644
--- a/vespalib/src/tests/datastore/array_store/array_store_test.cpp
+++ b/vespalib/src/tests/datastore/array_store/array_store_test.cpp
@@ -218,8 +218,8 @@ TEST_P(NumberStoreTest, control_static_sizes) {
 #endif
     EXPECT_EQ(112u, sizeof(NumberStoreTest::ArrayStoreType::SmallBufferType));
     MemoryUsage usage = store.getMemoryUsage();
-    EXPECT_EQ(960u, usage.allocatedBytes());
-    EXPECT_EQ(32u, usage.usedBytes());
+    EXPECT_EQ(1312160u, usage.allocatedBytes());
+    EXPECT_EQ(1311232u, usage.usedBytes());
 }
 
 TEST_P(NumberStoreTest, add_and_get_small_arrays_of_trivial_type)
diff --git a/vespalib/src/tests/datastore/datastore/datastore_test.cpp b/vespalib/src/tests/datastore/datastore/datastore_test.cpp
index bffd32816a4..794be39ae9b 100644
--- a/vespalib/src/tests/datastore/datastore/datastore_test.cpp
+++ b/vespalib/src/tests/datastore/datastore/datastore_test.cpp
@@ -474,6 +474,7 @@ TEST(DataStoreTest, require_that_memory_stats_are_calculated)
 
 TEST(DataStoreTest, require_that_memory_usage_is_calculated)
 {
+    constexpr size_t BASE = 676;
     MyStore s;
     MyRef r = s.addEntry(10);
     s.addEntry(20);
@@ -482,8 +483,8 @@ TEST(DataStoreTest, require_that_memory_usage_is_calculated)
     s.holdBuffer(r.bufferId());
     s.assign_generation(100);
     vespalib::MemoryUsage m = s.getMemoryUsage();
-    EXPECT_EQ(MyRef::offsetSize() * sizeof(int), m.allocatedBytes());
-    EXPECT_EQ(5 * sizeof(int), m.usedBytes());
+    EXPECT_EQ(MyRef::offsetSize() * sizeof(int) + BASE, m.allocatedBytes());
+    EXPECT_EQ(5 * sizeof(int) + BASE, m.usedBytes());
     EXPECT_EQ(0 * sizeof(int), m.deadBytes());
     EXPECT_EQ(5 * sizeof(int), m.allocatedBytesOnHold());
     s.reclaim_memory(101);
@@ -491,27 +492,28 @@ TEST(DataStoreTest, require_that_memory_usage_is_calculated)
 
 TEST(DataStoreTest, require_that_we_can_disable_elemement_hold_list)
 {
+    constexpr size_t BASE = 676;
     MyStore s;
     MyRef r1 = s.addEntry(10);
     MyRef r2 = s.addEntry(20);
     MyRef r3 = s.addEntry(30);
     (void) r3;
     vespalib::MemoryUsage m = s.getMemoryUsage();
-    EXPECT_EQ(MyRef::offsetSize() * sizeof(int), m.allocatedBytes());
-    EXPECT_EQ(4 * sizeof(int), m.usedBytes());
+    EXPECT_EQ(MyRef::offsetSize() * sizeof(int) + BASE, m.allocatedBytes());
+    EXPECT_EQ(4 * sizeof(int) + BASE, m.usedBytes());
     EXPECT_EQ(1 * sizeof(int), m.deadBytes());
     EXPECT_EQ(0 * sizeof(int), m.allocatedBytesOnHold());
     s.holdElem(r1, 1);
     m = s.getMemoryUsage();
-    EXPECT_EQ(MyRef::offsetSize() * sizeof(int), m.allocatedBytes());
-    EXPECT_EQ(4 * sizeof(int), m.usedBytes());
+    EXPECT_EQ(MyRef::offsetSize() * sizeof(int) + BASE, m.allocatedBytes());
+    EXPECT_EQ(4 * sizeof(int) + BASE, m.usedBytes());
     EXPECT_EQ(1 * sizeof(int), m.deadBytes());
     EXPECT_EQ(1 * sizeof(int), m.allocatedBytesOnHold());
     s.disableElemHoldList();
     s.holdElem(r2, 1);
     m = s.getMemoryUsage();
-    EXPECT_EQ(MyRef::offsetSize() * sizeof(int), m.allocatedBytes());
-    EXPECT_EQ(4 * sizeof(int), m.usedBytes());
+    EXPECT_EQ(MyRef::offsetSize() * sizeof(int) + BASE, m.allocatedBytes());
+    EXPECT_EQ(4 * sizeof(int) + BASE, m.usedBytes());
     EXPECT_EQ(2 * sizeof(int), m.deadBytes());
     EXPECT_EQ(1 * sizeof(int), m.allocatedBytesOnHold());
     s.assign_generation(100);
@@ -536,30 +538,31 @@ void assertGrowStats(GrowthStats expSizes,
 
 TEST(DataStoreTest, require_that_buffer_growth_works)
 {
+    constexpr size_t BASE = 41032u;
     // Always switch to new buffer, min size 4
     assertGrowStats({ 4, 4, 4, 4, 8, 16, 16, 32, 64, 64 },
-                    { 4 }, 20, 4, 0);
+                    { 4 }, 20 + BASE, 4, 0);
     // Resize if buffer size is less than 4, min size 0
     assertGrowStats({ 4, 4, 8, 32, 32, 64, 64, 128, 128, 128 },
-                    { 0, 1, 2, 4 }, 4, 0, 4);
+                    { 0, 1, 2, 4 }, 4 + BASE, 0, 4);
     // Always switch to new buffer, min size 16
     assertGrowStats({ 16, 16, 16, 32, 32, 64, 128, 128, 128 },
-                    { 16 }, 68, 16, 0);
+                    { 16 }, 68 + BASE, 16, 0);
     // Resize if buffer size is less than 16, min size 0
     assertGrowStats({ 16, 32, 32, 128, 128, 128, 128, 128, 128 },
-                    { 0, 1, 2, 4, 8, 16 }, 4, 0, 16);
+                    { 0, 1, 2, 4, 8, 16 }, 4 + BASE, 0, 16);
     // Resize if buffer size is less than 16, min size 4
     assertGrowStats({ 16, 32, 32, 128, 128, 128, 128, 128, 128 },
-                    { 4, 8, 16 }, 20, 4, 16);
+                    { 4, 8, 16 }, 20 + BASE, 4, 16);
     // Always switch to new buffer, min size 0
     assertGrowStats({ 1, 1, 1, 1, 1, 2, 2, 4, 8, 8, 16, 32 },
-                    { 0, 1 }, 4, 0, 0);
+                    { 0, 1 }, 4 + BASE, 0, 0);
 
     // Buffers with sizes larger than the huge page size of the mmap allocator.
     ASSERT_EQ(524288u, HUGE_PAGE_ARRAY_SIZE);
     assertGrowStats({ 262144, 524288, 524288, 524288 * 3, 524288 * 3, 524288 * 5, 524288 * 5, 524288 * 5, 524288 * 5, 524288 * 5 },
                     { 0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144 },
-                    4, 0, HUGE_PAGE_ARRAY_SIZE / 2, HUGE_PAGE_ARRAY_SIZE * 5);
+                    4 + BASE, 0, HUGE_PAGE_ARRAY_SIZE / 2, HUGE_PAGE_ARRAY_SIZE * 5);
 }
 
 using RefType15 = EntryRefT<15>; // offsetSize=32768
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 76dfdb79c01..cf62d238d53 100644
--- a/vespalib/src/tests/datastore/unique_store/unique_store_test.cpp
+++ b/vespalib/src/tests/datastore/unique_store/unique_store_test.cpp
@@ -471,10 +471,13 @@ TEST_F(DoubleTest, nan_is_handled)
 
 TEST_F(DoubleTest, control_memory_usage) {
     EXPECT_EQ(464, sizeof(store));
-    EXPECT_EQ(32u, store.get_values_memory_usage().allocatedBytes());
-    EXPECT_EQ(98208u, store.get_dictionary_memory_usage().allocatedBytes());
-    EXPECT_EQ(98240u, store.getMemoryUsage().allocatedBytes());
     EXPECT_EQ(144u, sizeof(BufferState));
+    EXPECT_EQ(163908u, store.get_values_memory_usage().allocatedBytes());
+    EXPECT_EQ(163892u, store.get_values_memory_usage().usedBytes());
+    EXPECT_EQ(262120u, store.get_dictionary_memory_usage().allocatedBytes());
+    EXPECT_EQ(164176u, store.get_dictionary_memory_usage().usedBytes());
+    EXPECT_EQ(426028u, store.getMemoryUsage().allocatedBytes());
+    EXPECT_EQ(328068u, store.getMemoryUsage().usedBytes());
 }
                 
 GTEST_MAIN_RUN_ALL_TESTS()
diff --git a/vespalib/src/vespa/vespalib/datastore/array_store.h b/vespalib/src/vespa/vespalib/datastore/array_store.h
index d0ac6a216db..43bd469fca4 100644
--- a/vespalib/src/vespa/vespalib/datastore/array_store.h
+++ b/vespalib/src/vespa/vespalib/datastore/array_store.h
@@ -42,14 +42,14 @@ public:
     using SmallBufferType = typename TypeMapperT::SmallBufferType;
     using TypeMapper = TypeMapperT;
 private:
-    uint32_t _largeArrayTypeId;
-    uint32_t _maxSmallArrayTypeId;
-    size_t _maxSmallArraySize;
-    DataStoreType _store;
-    TypeMapper _mapper;
+    uint32_t                     _largeArrayTypeId;
+    uint32_t                     _maxSmallArrayTypeId;
+    size_t                       _maxSmallArraySize;
+    DataStoreType                _store;
+    TypeMapper                   _mapper;
     std::vector<SmallBufferType> _smallArrayTypes;
-    LargeBufferType _largeArrayType;
-    CompactionSpec _compaction_spec;
+    LargeBufferType              _largeArrayType;
+    CompactionSpec               _compaction_spec;
     using generation_t = vespalib::GenerationHandler::generation_t;
 
     void initArrayTypes(const ArrayStoreConfig &cfg, std::shared_ptr<alloc::MemoryAllocator> memory_allocator);
diff --git a/vespalib/src/vespa/vespalib/datastore/array_store.hpp b/vespalib/src/vespa/vespalib/datastore/array_store.hpp
index a0fdf3f6563..64aed0bd541 100644
--- a/vespalib/src/vespa/vespalib/datastore/array_store.hpp
+++ b/vespalib/src/vespa/vespalib/datastore/array_store.hpp
@@ -59,9 +59,9 @@ ArrayStore<EntryT, RefT, TypeMapperT>::ArrayStore(const ArrayStoreConfig &cfg, s
 template <typename EntryT, typename RefT, typename TypeMapperT>
 vespalib::MemoryUsage
 ArrayStore<EntryT, RefT, TypeMapperT>::getMemoryUsage() const {
-    vespalib::MemoryUsage usage =  _store.getMemoryUsage();
-    //TODO Must be accounted
-    // usage.incAllocatedBytes(_smallArrayTypes.capacity() * sizeof(SmallBufferType));
+    vespalib::MemoryUsage usage = _store.getMemoryUsage();
+    usage.incAllocatedBytes(_smallArrayTypes.capacity() * sizeof(SmallBufferType));
+    usage.incUsedBytes(_smallArrayTypes.size() * sizeof(SmallBufferType));
     return usage;
 }
 
diff --git a/vespalib/src/vespa/vespalib/datastore/datastorebase.cpp b/vespalib/src/vespa/vespalib/datastore/datastorebase.cpp
index 6bf5f4c16c4..42234194040 100644
--- a/vespalib/src/vespa/vespalib/datastore/datastorebase.cpp
+++ b/vespalib/src/vespa/vespalib/datastore/datastorebase.cpp
@@ -258,18 +258,9 @@ DataStoreBase::dropBuffers()
 }
 
 vespalib::MemoryUsage
-DataStoreBase::getMemoryUsage() const
+DataStoreBase::getDynamicMemoryUsage() const
 {
     auto stats = getMemStats();
-
-    size_t extra = 0;
-    extra += _buffers.capacity() * sizeof(BufferAndTypeId);
-    extra += _primary_buffer_ids.capacity() * sizeof(uint32_t);
-    extra += _states.capacity() * sizeof(BufferState);
-    extra += _typeHandlers.capacity() * sizeof(BufferTypeBase *);
-    extra += _free_lists.capacity() * sizeof(FreeList);
-    (void) extra; //TODO Must be accounted as static cost
-
     vespalib::MemoryUsage usage;
     usage.setAllocatedBytes(stats._allocBytes);
     usage.setUsedBytes(stats._usedBytes);
@@ -278,6 +269,27 @@ DataStoreBase::getMemoryUsage() const
     return usage;
 }
 
+vespalib::MemoryUsage
+DataStoreBase::getMemoryUsage() const {
+    auto usage = getDynamicMemoryUsage();
+    size_t extra_allocated = 0;
+    extra_allocated += _buffers.capacity() * sizeof(BufferAndTypeId);
+    extra_allocated += _primary_buffer_ids.capacity() * sizeof(uint32_t);
+    extra_allocated += _states.capacity() * sizeof(BufferState);
+    extra_allocated += _typeHandlers.capacity() * sizeof(BufferTypeBase *);
+    extra_allocated += _free_lists.capacity() * sizeof(FreeList);
+
+    size_t extra_used = 0;
+    extra_used += _buffers.size() * sizeof(BufferAndTypeId);
+    extra_used += _primary_buffer_ids.size() * sizeof(uint32_t);
+    extra_used += _states.size() * sizeof(BufferState);
+    extra_used += _typeHandlers.size() * sizeof(BufferTypeBase *);
+    extra_used += _free_lists.size() * sizeof(FreeList);
+    usage.incAllocatedBytes(extra_allocated);
+    usage.incUsedBytes(extra_used);
+    return usage;
+}
+
 void
 DataStoreBase::holdBuffer(uint32_t bufferId)
 {
diff --git a/vespalib/src/vespa/vespalib/datastore/datastorebase.h b/vespalib/src/vespa/vespalib/datastore/datastorebase.h
index 16426218d47..950e1967ee2 100644
--- a/vespalib/src/vespa/vespalib/datastore/datastorebase.h
+++ b/vespalib/src/vespa/vespalib/datastore/datastorebase.h
@@ -65,6 +65,7 @@ public:
     void switch_primary_buffer(uint32_t typeId, size_t elemsNeeded);
 
     vespalib::MemoryUsage getMemoryUsage() const;
+    vespalib::MemoryUsage getDynamicMemoryUsage() const;
 
     vespalib::AddressSpace getAddressSpaceUsage() const;