Improve transient_memory_for_flush calculation.

toregge · toregge · commit e1241225fb68 · 2026-06-09T11:58:40.000+02:00
diff --git a/searchcore/src/tests/proton/documentmetastore/documentmetastore_test.cpp b/searchcore/src/tests/proton/documentmetastore/documentmetastore_test.cpp
@@ -598,7 +598,8 @@ TEST(DocumentMetaStoreTest, gids_can_be_saved_and_loaded) {
     uint64_t expSaveBytesSize =
         DocumentMetaStore::minHeaderLen + (1000 - 4) * DocumentMetaStore::entry_size(true, false);
     EXPECT_EQ(expSaveBytesSize, dms1.getEstimatedSaveByteSize());
-    EXPECT_EQ(0, dms1.transient_memory_for_flush());
+    EXPECT_EQ(0, dms1.transient_memory_for_flush(false));
+    EXPECT_EQ(expSaveBytesSize, dms1.transient_memory_for_flush(true));
     TuneFileAttributes      tuneFileAttributes;
     DummyFileHeaderContext  fileHeaderContext;
     AttributeFileSaveTarget saveTarget(tuneFileAttributes, fileHeaderContext);
diff --git a/searchcore/src/vespa/searchcore/proton/attribute/flushableattribute.cpp b/searchcore/src/vespa/searchcore/proton/attribute/flushableattribute.cpp
@@ -245,8 +245,7 @@ double FlushableAttribute::get_replay_operation_cost() const {
 }
 
 size_t FlushableAttribute::transient_memory_for_flush() const noexcept {
-    size_t flush_buffer_size = _hwInfo.disk().slow() ? _attr->getEstimatedSaveByteSize() : 0;
-    return _attr->transient_memory_for_flush() + flush_buffer_size;
+    return _attr->transient_memory_for_flush(_hwInfo.disk().slow());
 }
 
 std::chrono::steady_clock::duration FlushableAttribute::last_flush_duration() const noexcept {
diff --git a/searchcore/src/vespa/searchcore/proton/documentmetastore/documentmetastore.cpp b/searchcore/src/vespa/searchcore/proton/documentmetastore/documentmetastore.cpp
@@ -1146,8 +1146,9 @@ uint64_t DocumentMetaStore::getEstimatedSaveByteSize() const {
     return estimate;
 }
 
-size_t DocumentMetaStore::transient_memory_for_flush() const noexcept {
-    return 0;
+size_t DocumentMetaStore::transient_memory_for_flush(bool slow_disk) const noexcept {
+    size_t flush_buffer_size = slow_disk ? getEstimatedSaveByteSize() : 0;
+    return flush_buffer_size;
 }
 
 uint32_t DocumentMetaStore::getVersion() const {
diff --git a/searchcore/src/vespa/searchcore/proton/documentmetastore/documentmetastore.h b/searchcore/src/vespa/searchcore/proton/documentmetastore/documentmetastore.h
@@ -306,7 +306,7 @@ class DocumentMetaStore final : public DocumentMetaStoreAttribute,
     void onShrinkLidSpace() override;
     size_t getEstimatedShrinkLidSpaceGain() const override;
     uint64_t getEstimatedSaveByteSize() const override;
-    [[nodiscard]] size_t transient_memory_for_flush() const noexcept override;
+    [[nodiscard]] size_t transient_memory_for_flush(bool slow_disk) const noexcept override;
     uint32_t getVersion() const override;
 
     /*
diff --git a/searchcore/src/vespa/searchcore/proton/documentmetastore/documentmetastoreflushtarget.cpp b/searchcore/src/vespa/searchcore/proton/documentmetastore/documentmetastoreflushtarget.cpp
@@ -225,8 +225,7 @@ uint64_t DocumentMetaStoreFlushTarget::getApproxBytesToWriteToDisk() const {
 }
 
 size_t DocumentMetaStoreFlushTarget::transient_memory_for_flush() const noexcept {
-    size_t flush_buffer_size = _hwInfo.disk().slow() ? _dms->getEstimatedSaveByteSize() : 0;
-    return flush_buffer_size + _dms->transient_memory_for_flush();
+    return _dms->transient_memory_for_flush(_hwInfo.disk().slow());
 }
 
 std::chrono::steady_clock::duration DocumentMetaStoreFlushTarget::last_flush_duration() const noexcept {
diff --git a/searchlib/src/tests/attribute/array_bool_attribute/array_bool_attribute_test.cpp b/searchlib/src/tests/attribute/array_bool_attribute/array_bool_attribute_test.cpp
@@ -538,7 +538,8 @@ TEST_F(ArrayBoolAttributeTest, estimated_save_byte_size) {
     // 4096 + (8+7)/8 + 6*5 = 4096 + 1 + 30 = 4127 (with 1 reserved doc, 5 added = 6 docs)
     uint64_t expected = 4096 + (8 + 7) / 8 + 6 * 5;
     EXPECT_EQ(expected, estimate);
-    EXPECT_EQ(6 * sizeof(vespalib::datastore::EntryRef), _attr->transient_memory_for_flush());
+    EXPECT_EQ(6 * sizeof(vespalib::datastore::EntryRef), _attr->transient_memory_for_flush(false));
+    EXPECT_EQ(6 * sizeof(vespalib::datastore::EntryRef) + estimate, _attr->transient_memory_for_flush(true));
 }
 
 class ArrayBoolExtAttributeTest : public ::testing::Test {
diff --git a/searchlib/src/tests/attribute/attribute_test.cpp b/searchlib/src/tests/attribute/attribute_test.cpp
@@ -139,6 +139,26 @@ bool preciseEstimatedSize(const AttributeVector& a) {
     return true;
 }
 
+bool single_normal_numeric_attribute(const AttributeVector& a) {
+    if (a.getCollectionType() != search::attribute::CollectionType::SINGLE) {
+        return false;
+    }
+    if (a.getConfig().fastSearch()) {
+        return false;
+    }
+    switch (a.getBasicType()) {
+    case BasicType::INT8:
+    case BasicType::INT16:
+    case BasicType::INT32:
+    case BasicType::INT64:
+    case BasicType::DOUBLE:
+    case BasicType::FLOAT:
+        return true;
+    default:
+        return false;
+    }
+}
+
 string baseFileName(const string& attrName) {
     return tmpDir + "/" + attrName;
 }
@@ -472,7 +492,20 @@ template <typename VectorType, typename BufferType> void AttributeTest::testRelo
             exp_transient_memory_for_flush =
                 BitVector::legacy_num_bytes_with_single_guard_bit(a->getCommittedDocIdLimit());
         }
-        EXPECT_EQ(exp_transient_memory_for_flush, a->transient_memory_for_flush());
+        if (a->getBasicType() == BasicType::UINT2 && !multivalue_attr) {
+            exp_transient_memory_for_flush = 4 * ((a->getCommittedDocIdLimit() + 15) / 16);
+        }
+        if (a->getBasicType() == BasicType::UINT4 && !multivalue_attr) {
+            exp_transient_memory_for_flush = 4 * ((a->getCommittedDocIdLimit() + 7) / 8);
+        }
+        EXPECT_EQ(exp_transient_memory_for_flush, a->transient_memory_for_flush(false));
+        if (single_normal_numeric_attribute(*a)) {
+            // Buffer handover from attribute saver to attribute memory file writer
+            EXPECT_EQ((size_t)a->getEstimatedSaveByteSize(), a->transient_memory_for_flush(true));
+        } else {
+            EXPECT_EQ((size_t)a->getEstimatedSaveByteSize() + exp_transient_memory_for_flush,
+                      a->transient_memory_for_flush(true));
+        }
         double actSize = statSize(*b);
         EXPECT_LE(actSize, a->size_on_disk());
         EXPECT_EQ(stat_size_on_disk(*b), a->size_on_disk());
diff --git a/searchlib/src/tests/attribute/predicate_attribute/predicate_attribute_test.cpp b/searchlib/src/tests/attribute/predicate_attribute/predicate_attribute_test.cpp
@@ -123,7 +123,8 @@ TEST_F(PredicateAttributeTest, save_and_load_predicate_attribute) {
     auto                  attr = make_sample_predicate_attribute();
     std::filesystem::path file_name(tmp_dir);
     file_name.append(attr_name);
-    EXPECT_NE(0, attr->transient_memory_for_flush());
+    EXPECT_NE(0, attr->transient_memory_for_flush(false));
+    EXPECT_NE(0, attr->transient_memory_for_flush(true));
     attr->save(file_name.native());
     EXPECT_NE(0, attr->size_on_disk());
     auto attr2 = make_attribute(file_name.native(), attr->getConfig(), false);
@@ -132,7 +133,8 @@ TEST_F(PredicateAttributeTest, save_and_load_predicate_attribute) {
     EXPECT_TRUE(attr2->isLoaded());
     EXPECT_EQ(11, attr2->getCommittedDocIdLimit());
     EXPECT_EQ(attr->size_on_disk(), attr2->size_on_disk());
-    EXPECT_EQ(attr->transient_memory_for_flush(), attr2->transient_memory_for_flush());
+    EXPECT_EQ(attr->transient_memory_for_flush(false), attr2->transient_memory_for_flush(false));
+    EXPECT_EQ(attr->transient_memory_for_flush(true), attr2->transient_memory_for_flush(true));
 }
 
 TEST_F(PredicateAttributeTest, buffer_size_mismatch_is_fatal_during_load) {
diff --git a/searchlib/src/tests/attribute/raw_attribute/raw_attribute_test.cpp b/searchlib/src/tests/attribute/raw_attribute/raw_attribute_test.cpp
@@ -232,7 +232,8 @@ TEST_F(RawAttributeTest, save_and_load) {
     EXPECT_EQ(0, _attr->size_on_disk());
     EXPECT_EQ(zero_flush_duration, _attr->last_flush_duration());
     auto estimated_write_bytes = _attr->getEstimatedSaveByteSize();
-    EXPECT_EQ(11 * sizeof(EntryRef), _attr->transient_memory_for_flush());
+    EXPECT_EQ(11 * sizeof(EntryRef), _attr->transient_memory_for_flush(false));
+    EXPECT_EQ(11 * sizeof(EntryRef) + estimated_write_bytes, _attr->transient_memory_for_flush(true));
     _attr->save();
     EXPECT_EQ(std::filesystem::file_size(attr_path), estimated_write_bytes);
     auto saved_size_on_disk = _attr->size_on_disk();
diff --git a/searchlib/src/tests/attribute/tensorattribute/tensorattribute_test.cpp b/searchlib/src/tests/attribute/tensorattribute/tensorattribute_test.cpp
@@ -1698,18 +1698,24 @@ TEST_F(SparseTensorAttributeTest, size_on_disk_factor_is_calculated_and_used) {
     }
     EXPECT_LT(10, attr.getCommittedDocIdLimit());
     EXPECT_THAT(attr.getEstimatedSaveByteSize(), AllOf(Ge(40_Ki), Le(50_Ki)));
-    EXPECT_EQ(attr.getCommittedDocIdLimit() * sizeof(EntryRef), attr.transient_memory_for_flush());
+    EXPECT_EQ(attr.getCommittedDocIdLimit() * sizeof(EntryRef), attr.transient_memory_for_flush(false));
+    EXPECT_EQ(attr.getCommittedDocIdLimit() * sizeof(EntryRef) + attr.getEstimatedSaveByteSize(),
+              attr.transient_memory_for_flush(true));
     attr.save((_test_dir / "tensor").string());
     auto size_on_disk = attr.size_on_disk();
     EXPECT_LT(60_Ki, size_on_disk);
     EXPECT_THAT(attr.getEstimatedSaveByteSize(), AllOf(Ge(size_on_disk - 4_Ki), Le(size_on_disk + 4_Ki)));
-    EXPECT_EQ(attr.getCommittedDocIdLimit() * sizeof(EntryRef), attr.transient_memory_for_flush());
+    EXPECT_EQ(attr.getCommittedDocIdLimit() * sizeof(EntryRef), attr.transient_memory_for_flush(false));
+    EXPECT_EQ(attr.getCommittedDocIdLimit() * sizeof(EntryRef) + attr.getEstimatedSaveByteSize(),
+              attr.transient_memory_for_flush(true));
     auto real_attr2 = std::make_shared<SerializedFastValueAttribute>((_test_dir / "tensor").string(), cfg);
     AttributeVector& attr2 = *real_attr2;
     ASSERT_TRUE(attr2.load());
     EXPECT_EQ(size_on_disk, attr2.size_on_disk());
     EXPECT_THAT(attr2.getEstimatedSaveByteSize(), AllOf(Ge(size_on_disk - 4_Ki), Le(size_on_disk + 4_Ki)));
-    EXPECT_EQ(attr2.getCommittedDocIdLimit() * sizeof(EntryRef), attr2.transient_memory_for_flush());
+    EXPECT_EQ(attr2.getCommittedDocIdLimit() * sizeof(EntryRef), attr2.transient_memory_for_flush(false));
+    EXPECT_EQ(attr2.getCommittedDocIdLimit() * sizeof(EntryRef) + attr2.getEstimatedSaveByteSize(),
+              attr2.transient_memory_for_flush(true));
     EXPECT_EQ(dynamic_memory_usage, attr2.getStatus().get_used_minus_dead_and_onhold() - initial_memory_usage);
     EXPECT_EQ(attr.getEstimatedSaveByteSize(), attr2.getEstimatedSaveByteSize());
 }
diff --git a/searchlib/src/vespa/searchlib/attribute/attributevector.cpp b/searchlib/src/vespa/searchlib/attribute/attributevector.cpp
@@ -615,23 +615,11 @@ uint64_t AttributeVector::getEstimatedSaveByteSize() const {
     return datFileSize + weightFileSize + idxFileSize + udatFileSize;
 }
 
-size_t AttributeVector::transient_memory_for_flush() const noexcept {
-    uint32_t    committedDocIdLimit = getCommittedDocIdLimit();
-    const auto& cfg = getConfig();
-    size_t      elem_size = 4;
-    if (!cfg.collectionType().isMultiValue() && !hasEnum()) {
-        BasicType::Type basicType(getBasicType());
-        switch (basicType) {
-        case BasicType::Type::PREDICATE:
-        case BasicType::Type::TENSOR:
-        case BasicType::Type::REFERENCE:
-        case BasicType::Type::RAW:
-            break;
-        default:
-            elem_size = cfg.basicType().fixedSize();
-        }
-    }
-    return elem_size * committedDocIdLimit;
+size_t AttributeVector::transient_memory_for_flush(bool slow_disk) const noexcept {
+    uint32_t committedDocIdLimit = getCommittedDocIdLimit();
+    size_t   elem_size = 4;
+    size_t   flush_buffer_size = slow_disk ? getEstimatedSaveByteSize() : 0;
+    return elem_size * committedDocIdLimit + flush_buffer_size;
 }
 
 size_t AttributeVector::getEstimatedShrinkLidSpaceGain() const {
diff --git a/searchlib/src/vespa/searchlib/attribute/attributevector.h b/searchlib/src/vespa/searchlib/attribute/attributevector.h
@@ -494,7 +494,7 @@ class AttributeVector : public attribute::IAttributeVector,
 
     virtual std::unique_ptr<AttributeSaver> onInitSave(std::string_view fileName);
     virtual uint64_t getEstimatedSaveByteSize() const;
-    [[nodiscard]] virtual size_t transient_memory_for_flush() const noexcept;
+    [[nodiscard]] virtual size_t transient_memory_for_flush(bool slow_disk) const noexcept;
 
     static bool isEnumerated(const vespalib::GenericHeader& header);
 
diff --git a/searchlib/src/vespa/searchlib/attribute/predicate_attribute.cpp b/searchlib/src/vespa/searchlib/attribute/predicate_attribute.cpp
@@ -152,8 +152,9 @@ std::unique_ptr<AttributeSaver> PredicateAttribute::onInitSave(std::string_view
         PredicateAttributeSaver::IntervalRangeVectorSnapshot(interval_range_vector_view), _max_interval_range);
 }
 
-size_t PredicateAttribute::transient_memory_for_flush() const noexcept {
-    return _transient_memory_for_flush_stats.load(std::memory_order_relaxed);
+size_t PredicateAttribute::transient_memory_for_flush(bool slow_disk) const noexcept {
+    size_t flush_buffer_size = slow_disk ? getEstimatedSaveByteSize() : 0;
+    return _transient_memory_for_flush_stats.load(std::memory_order_relaxed) + flush_buffer_size;
 }
 
 void PredicateAttribute::update_transient_memory_for_flush() noexcept {
diff --git a/searchlib/src/vespa/searchlib/attribute/predicate_attribute.h b/searchlib/src/vespa/searchlib/attribute/predicate_attribute.h
@@ -50,7 +50,7 @@ class PredicateAttribute : public NotImplementedAttribute {
     predicate::PredicateIndex& getIndex() { return *_index; }
 
     std::unique_ptr<AttributeSaver> onInitSave(std::string_view fileName) override;
-    [[nodiscard]] size_t transient_memory_for_flush() const noexcept override;
+    [[nodiscard]] size_t transient_memory_for_flush(bool slow_disk) const noexcept override;
     bool onLoad(vespalib::Executor* executor) override;
     void onCommit() override;
     void reclaim_memory(vespalib::Generation oldest_used_gen) override;
diff --git a/searchlib/src/vespa/searchlib/attribute/singleboolattribute.cpp b/searchlib/src/vespa/searchlib/attribute/singleboolattribute.cpp
@@ -241,8 +241,9 @@ uint64_t SingleBoolAttribute::getEstimatedSaveByteSize() const {
     return headerSize + BitVector::legacy_num_bytes_with_single_guard_bit(getCommittedDocIdLimit());
 }
 
-size_t SingleBoolAttribute::transient_memory_for_flush() const noexcept {
-    return BitVector::legacy_num_bytes_with_single_guard_bit(getCommittedDocIdLimit());
+size_t SingleBoolAttribute::transient_memory_for_flush(bool slow_disk) const noexcept {
+    size_t flush_buffer_size = slow_disk ? getEstimatedSaveByteSize() : 0;
+    return BitVector::legacy_num_bytes_with_single_guard_bit(getCommittedDocIdLimit()) + flush_buffer_size;
 }
 
 void SingleBoolAttribute::reclaim_memory(Generation oldest_used_gen) {
diff --git a/searchlib/src/vespa/searchlib/attribute/singleboolattribute.h b/searchlib/src/vespa/searchlib/attribute/singleboolattribute.h
@@ -32,7 +32,7 @@ class SingleBoolAttribute final : public IntegerAttributeTemplate<int8_t> {
     void reclaim_memory(vespalib::Generation oldest_used_gen) override;
     void before_inc_generation(vespalib::Generation current_gen) override;
     uint64_t getEstimatedSaveByteSize() const override;
-    [[nodiscard]] size_t transient_memory_for_flush() const noexcept override;
+    [[nodiscard]] size_t transient_memory_for_flush(bool slow_disk) const noexcept override;
 
     std::unique_ptr<attribute::SearchContext> getSearch(std::unique_ptr<QueryTermSimple>      term,
                                                         const attribute::SearchContextParams& params) const override;
diff --git a/searchlib/src/vespa/searchlib/attribute/singlenumericattribute.h b/searchlib/src/vespa/searchlib/attribute/singlenumericattribute.h
@@ -115,6 +115,7 @@ template <typename B> class SingleValueNumericAttribute final : public B {
     void clearDocs(DocId lidLow, DocId lidLimit, bool in_shrink_lid_space) override;
     void onShrinkLidSpace() override;
     std::unique_ptr<AttributeSaver> onInitSave(std::string_view fileName) override;
+    [[nodiscard]] size_t transient_memory_for_flush(bool slow_disk) const noexcept override;
 };
 
 } // namespace search
diff --git a/searchlib/src/vespa/searchlib/attribute/singlenumericattribute.hpp b/searchlib/src/vespa/searchlib/attribute/singlenumericattribute.hpp
@@ -190,4 +190,10 @@ std::unique_ptr<AttributeSaver> SingleValueNumericAttribute<B>::onInitSave(std::
                                                               numDocs * sizeof(T));
 }
 
+template <typename B>
+size_t SingleValueNumericAttribute<B>::transient_memory_for_flush(bool slow_disk) const noexcept {
+    uint32_t committedDocIdLimit = this->getCommittedDocIdLimit();
+    return slow_disk ? this->getEstimatedSaveByteSize() : committedDocIdLimit * sizeof(T);
+}
+
 } // namespace search
diff --git a/searchlib/src/vespa/searchlib/attribute/singlesmallnumericattribute.cpp b/searchlib/src/vespa/searchlib/attribute/singlesmallnumericattribute.cpp
@@ -180,6 +180,13 @@ uint64_t SingleValueSmallNumericAttribute::getEstimatedSaveByteSize() const {
     return headerSize + sz;
 }
 
+size_t SingleValueSmallNumericAttribute::transient_memory_for_flush(bool slow_disk) const noexcept {
+    const size_t num_docs(getCommittedDocIdLimit());
+    const size_t num_data_words((num_docs + _valueShiftMask) >> _wordShift);
+    size_t       flush_buffer_size = slow_disk ? getEstimatedSaveByteSize() : 0;
+    return num_data_words * sizeof(Word) + flush_buffer_size;
+}
+
 namespace {
 
 template <typename TT> uint32_t log2bits();
diff --git a/searchlib/src/vespa/searchlib/attribute/singlesmallnumericattribute.h b/searchlib/src/vespa/searchlib/attribute/singlesmallnumericattribute.h
@@ -129,6 +129,7 @@ class SingleValueSmallNumericAttribute : public IntegerAttributeTemplate<int8_t>
     void clearDocs(DocId lidLow, DocId lidLimit, bool in_shrink_lid_space) override;
     void onShrinkLidSpace() override;
     uint64_t getEstimatedSaveByteSize() const override;
+    [[nodiscard]] size_t transient_memory_for_flush(bool slow_disk) const noexcept override;
 };
 
 class SingleValueSemiNibbleNumericAttribute : public SingleValueSmallNumericAttribute {

Original file line number	Diff line number	Diff line change
`@@ -245,8 +245,7 @@ double FlushableAttribute::get_replay_operation_cost() const {`
`245`	`245`	`}`
`246`	`246`
`247`	`247`	`size_t FlushableAttribute::transient_memory_for_flush() const noexcept {`
`248`		`- size_t flush_buffer_size = _hwInfo.disk().slow() ? _attr->getEstimatedSaveByteSize() : 0;`
`249`		`- return _attr->transient_memory_for_flush() + flush_buffer_size;`
	`248`	`+ return _attr->transient_memory_for_flush(_hwInfo.disk().slow());`
`250`	`249`	`}`
`251`	`250`
`252`	`251`	`std::chrono::steady_clock::duration FlushableAttribute::last_flush_duration() const noexcept {`
Original file line number	Diff line number	Diff line change
`@@ -1146,8 +1146,9 @@ uint64_t DocumentMetaStore::getEstimatedSaveByteSize() const {`
`1146`	`1146`	`return estimate;`
`1147`	`1147`	`}`
`1148`	`1148`
`1149`		`-size_t DocumentMetaStore::transient_memory_for_flush() const noexcept {`
`1150`		`- return 0;`
	`1149`	`+size_t DocumentMetaStore::transient_memory_for_flush(bool slow_disk) const noexcept {`
	`1150`	`+ size_t flush_buffer_size = slow_disk ? getEstimatedSaveByteSize() : 0;`
	`1151`	`+ return flush_buffer_size;`
`1151`	`1152`	`}`
`1152`	`1153`
`1153`	`1154`	`uint32_t DocumentMetaStore::getVersion() const {`
Original file line number	Diff line number	Diff line change
`@@ -225,8 +225,7 @@ uint64_t DocumentMetaStoreFlushTarget::getApproxBytesToWriteToDisk() const {`
`225`	`225`	`}`
`226`	`226`
`227`	`227`	`size_t DocumentMetaStoreFlushTarget::transient_memory_for_flush() const noexcept {`
`228`		`- size_t flush_buffer_size = _hwInfo.disk().slow() ? _dms->getEstimatedSaveByteSize() : 0;`
`229`		`- return flush_buffer_size + _dms->transient_memory_for_flush();`
	`228`	`+ return _dms->transient_memory_for_flush(_hwInfo.disk().slow());`
`230`	`229`	`}`
`231`	`230`
`232`	`231`	`std::chrono::steady_clock::duration DocumentMetaStoreFlushTarget::last_flush_duration() const noexcept {`
Original file line number	Diff line number	Diff line change
`@@ -538,7 +538,8 @@ TEST_F(ArrayBoolAttributeTest, estimated_save_byte_size) {`
`538`	`538`	`// 4096 + (8+7)/8 + 6*5 = 4096 + 1 + 30 = 4127 (with 1 reserved doc, 5 added = 6 docs)`
`539`	`539`	`uint64_t expected = 4096 + (8 + 7) / 8 + 6 * 5;`
`540`	`540`	`EXPECT_EQ(expected, estimate);`
`541`		`- EXPECT_EQ(6 * sizeof(vespalib::datastore::EntryRef), _attr->transient_memory_for_flush());`
	`541`	`+ EXPECT_EQ(6 * sizeof(vespalib::datastore::EntryRef), _attr->transient_memory_for_flush(false));`
	`542`	`+ EXPECT_EQ(6 * sizeof(vespalib::datastore::EntryRef) + estimate, _attr->transient_memory_for_flush(true));`
`542`	`543`	`}`
`543`	`544`
`544`	`545`	`class ArrayBoolExtAttributeTest : public ::testing::Test {`