[clang] [clang-tools-extra] [lldb] [llvm] [Allocator] Drop RedZoneSize (non-sanitizer) and BytesAllocated members (PR #205711)
via cfe-commits
cfe-commits at lists.llvm.org
Wed Jun 24 19:23:18 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-support
Author: Fangrui Song (MaskRay)
<details>
<summary>Changes</summary>
`RedZoneSize` is only read inside `#if LLVM_ADDRESS_SANITIZER_BUILD`.
Remove it for other builds.
`BytesAllocated` is incremented on every Allocate (a hot-path memory
read-modify-write) only to back `getBytesAllocated()`. Drop the member.
There is a measurable stage2 instruction-count reduction.
https://llvm-compile-time-tracker.com/compare.php?from=25a6b5be6853b2c493ef392d41e43dd35ad4839a&to=8ebc975635ad717deb392d20b50f1a1f6bb16054&stat=instructions:u
Migrate the in-tree consumers:
- TableGen dumpAllocationStats drops the line; the clangd debug log reports
getTotalMemory().
- clang's PPMemoryAllocationsTest measures getTotalMemory()/#define; over 1M
defines this is 120.06 B/define, matching the prior ~120 B, so the existing
bound holds.
- lldb's ConstString MemoryStats (https://reviews.llvm.org/D117914)
drops bytes_used/bytes_unused
Aided by Claude Opus 4.8
---
Patch is 22.77 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/205711.diff
14 Files Affected:
- (modified) clang-tools-extra/clangd/CompileCommands.cpp (+2-2)
- (modified) clang/unittests/Lex/PPMemoryAllocationsTest.cpp (+7-4)
- (modified) lldb/include/lldb/Utility/ConstString.h (-3)
- (modified) lldb/source/Target/Statistics.cpp (-2)
- (modified) lldb/source/Utility/ConstString.cpp (-1)
- (modified) lldb/test/API/commands/statistics/basic/TestStats.py (-2)
- (modified) llvm/include/llvm/Support/Allocator.h (+15-18)
- (modified) llvm/include/llvm/Support/PerThreadBumpPtrAllocator.h (+3-9)
- (modified) llvm/lib/TableGen/Record.cpp (-1)
- (modified) llvm/unittests/ADT/ConcurrentHashtableTest.cpp (-47)
- (modified) llvm/unittests/DebugInfo/MSF/MappedBlockStreamTest.cpp (-12)
- (modified) llvm/unittests/Support/AllocatorTest.cpp (+1-5)
- (modified) llvm/unittests/Support/PerThreadBumpPtrAllocatorTest.cpp (+3-5)
- (modified) llvm/unittests/Support/ThreadSafeAllocatorTest.cpp (+1-1)
``````````diff
diff --git a/clang-tools-extra/clangd/CompileCommands.cpp b/clang-tools-extra/clangd/CompileCommands.cpp
index e8005435e1836..b5965d163d7db 100644
--- a/clang-tools-extra/clangd/CompileCommands.cpp
+++ b/clang-tools-extra/clangd/CompileCommands.cpp
@@ -560,8 +560,8 @@ llvm::ArrayRef<ArgStripper::Rule> ArgStripper::rulesFor(llvm::StringRef Arg) {
dlog(" {0} #={1} *={2} Mode={3}", R.Text, R.ExactArgs, R.PrefixArgs,
int(R.Modes));
}
- dlog("Table spellings={0} rules={1} string-bytes={2}", Result->size(),
- RuleCount, Result->getAllocator().getBytesAllocated());
+ dlog("Table spellings={0} rules={1} allocator-bytes={2}", Result->size(),
+ RuleCount, Result->getAllocator().getTotalMemory());
#endif
// The static table will never be destroyed.
return Result.release();
diff --git a/clang/unittests/Lex/PPMemoryAllocationsTest.cpp b/clang/unittests/Lex/PPMemoryAllocationsTest.cpp
index f873774eb2019..ebdb0346b3bed 100644
--- a/clang/unittests/Lex/PPMemoryAllocationsTest.cpp
+++ b/clang/unittests/Lex/PPMemoryAllocationsTest.cpp
@@ -77,10 +77,13 @@ TEST_F(PPMemoryAllocationsTest, PPMacroDefinesAllocations) {
PP.LexTokensUntilEOF();
- size_t NumAllocated = PP.getPreprocessorAllocator().getBytesAllocated();
- float BytesPerDefine = float(NumAllocated) / float(NumMacros);
- llvm::errs() << "Num preprocessor allocations for " << NumMacros
- << " #define: " << NumAllocated << "\n";
+ // Use the total slab memory held by the preprocessor's allocator as a proxy.
+ // Over a million #defines the per-allocation slab overhead is negligible, so
+ // this closely tracks the bytes requested for storing the macro information.
+ size_t TotalMemory = PP.getPreprocessorAllocator().getTotalMemory();
+ float BytesPerDefine = float(TotalMemory) / float(NumMacros);
+ llvm::errs() << "Preprocessor allocator memory for " << NumMacros
+ << " #define: " << TotalMemory << "\n";
llvm::errs() << "Bytes per #define: " << BytesPerDefine << "\n";
// On arm64-apple-macos, we get around 120 bytes per define.
// Assume a reasonable upper bound based on that number that we don't want
diff --git a/lldb/include/lldb/Utility/ConstString.h b/lldb/include/lldb/Utility/ConstString.h
index 1bfefec9638a5..4452df1ecc6b1 100644
--- a/lldb/include/lldb/Utility/ConstString.h
+++ b/lldb/include/lldb/Utility/ConstString.h
@@ -393,10 +393,7 @@ class ConstString {
struct MemoryStats {
size_t GetBytesTotal() const { return bytes_total; }
- size_t GetBytesUsed() const { return bytes_used; }
- size_t GetBytesUnused() const { return bytes_total - bytes_used; }
size_t bytes_total = 0;
- size_t bytes_used = 0;
};
static MemoryStats GetMemoryStats();
diff --git a/lldb/source/Target/Statistics.cpp b/lldb/source/Target/Statistics.cpp
index 9fee5108e736a..6227d099642f2 100644
--- a/lldb/source/Target/Statistics.cpp
+++ b/lldb/source/Target/Statistics.cpp
@@ -111,8 +111,6 @@ json::Value ModuleStats::ToJSON() const {
llvm::json::Value ConstStringStats::ToJSON() const {
json::Object obj;
obj.try_emplace<int64_t>("bytesTotal", stats.GetBytesTotal());
- obj.try_emplace<int64_t>("bytesUsed", stats.GetBytesUsed());
- obj.try_emplace<int64_t>("bytesUnused", stats.GetBytesUnused());
return obj;
}
diff --git a/lldb/source/Utility/ConstString.cpp b/lldb/source/Utility/ConstString.cpp
index 3d79731a47d5a..8def38c03dceb 100644
--- a/lldb/source/Utility/ConstString.cpp
+++ b/lldb/source/Utility/ConstString.cpp
@@ -196,7 +196,6 @@ class Pool {
std::shared_lock<PoolMutex> lock(pool.m_mutex);
const Allocator &alloc = pool.m_string_map.getAllocator();
stats.bytes_total += alloc.getTotalMemory();
- stats.bytes_used += alloc.getBytesAllocated();
}
return stats;
}
diff --git a/lldb/test/API/commands/statistics/basic/TestStats.py b/lldb/test/API/commands/statistics/basic/TestStats.py
index a32b8feecc5cf..c65d1d8785160 100644
--- a/lldb/test/API/commands/statistics/basic/TestStats.py
+++ b/lldb/test/API/commands/statistics/basic/TestStats.py
@@ -348,8 +348,6 @@ def test_memory(self):
strings = memory["strings"]
strings_keys = [
"bytesTotal",
- "bytesUsed",
- "bytesUnused",
]
self.verify_keys(strings, '"strings"', strings_keys, None)
diff --git a/llvm/include/llvm/Support/Allocator.h b/llvm/include/llvm/Support/Allocator.h
index 92027cceea3bf..cebe4d6e925b3 100644
--- a/llvm/include/llvm/Support/Allocator.h
+++ b/llvm/include/llvm/Support/Allocator.h
@@ -96,11 +96,12 @@ class BumpPtrAllocatorImpl
BumpPtrAllocatorImpl(BumpPtrAllocatorImpl &&Old)
: AllocTy(std::move(Old.getAllocator())), CurPtr(Old.CurPtr),
EndSentinel(Old.EndSentinel), Slabs(std::move(Old.Slabs)),
- CustomSizedSlabs(std::move(Old.CustomSizedSlabs)),
- BytesAllocated(Old.BytesAllocated), RedZoneSize(Old.RedZoneSize) {
+ CustomSizedSlabs(std::move(Old.CustomSizedSlabs)) {
+#if LLVM_ADDRESS_SANITIZER_BUILD
+ RedZoneSize = Old.RedZoneSize;
+#endif
Old.CurPtr = nullptr;
Old.EndSentinel = 0;
- Old.BytesAllocated = 0;
Old.Slabs.clear();
Old.CustomSizedSlabs.clear();
}
@@ -116,15 +117,15 @@ class BumpPtrAllocatorImpl
CurPtr = RHS.CurPtr;
EndSentinel = RHS.EndSentinel;
- BytesAllocated = RHS.BytesAllocated;
+#if LLVM_ADDRESS_SANITIZER_BUILD
RedZoneSize = RHS.RedZoneSize;
+#endif
Slabs = std::move(RHS.Slabs);
CustomSizedSlabs = std::move(RHS.CustomSizedSlabs);
AllocTy::operator=(std::move(RHS.getAllocator()));
RHS.CurPtr = nullptr;
RHS.EndSentinel = 0;
- RHS.BytesAllocated = 0;
RHS.Slabs.clear();
RHS.CustomSizedSlabs.clear();
return *this;
@@ -141,7 +142,6 @@ class BumpPtrAllocatorImpl
return;
// Reset the state.
- BytesAllocated = 0;
CurPtr = (char *)Slabs.front();
EndSentinel = uintptr_t(CurPtr) + SlabSize + 1;
@@ -158,9 +158,6 @@ class BumpPtrAllocatorImpl
// Allocate(0, N) is valid, it returns a non-null pointer (which should not
// be dereferenced).
LLVM_ATTRIBUTE_RETURNS_NONNULL void *Allocate(size_t Size, Align Alignment) {
- // Keep track of how many bytes we've allocated.
- BytesAllocated += Size;
-
size_t SizeToAllocate = Size;
#if LLVM_ADDRESS_SANITIZER_BUILD
// Add trailing bytes as a "red zone" under ASan.
@@ -308,15 +305,18 @@ class BumpPtrAllocatorImpl
return TotalMemory;
}
- size_t getBytesAllocated() const { return BytesAllocated; }
+ /// BumpPtrAllocator no longer tracks the number of bytes requested; this
+ /// always returns 0. Use getTotalMemory() for the amount of memory held.
+ size_t getBytesAllocated() const { return 0; }
- void setRedZoneSize(size_t NewSize) {
+ void setRedZoneSize([[maybe_unused]] size_t NewSize) {
+#if LLVM_ADDRESS_SANITIZER_BUILD
RedZoneSize = NewSize;
+#endif
}
void PrintStats() const {
- detail::printBumpPtrAllocatorStats(Slabs.size(), BytesAllocated,
- getTotalMemory());
+ detail::printBumpPtrAllocatorStats(Slabs.size(), 0, getTotalMemory());
}
private:
@@ -335,14 +335,11 @@ class BumpPtrAllocatorImpl
/// Custom-sized slabs allocated for too-large allocation requests.
SmallVector<std::pair<void *, size_t>, 0> CustomSizedSlabs;
- /// How many bytes we've allocated.
- ///
- /// Used so that we can compute how much space was wasted.
- size_t BytesAllocated = 0;
-
+#if LLVM_ADDRESS_SANITIZER_BUILD
/// The number of bytes to put between allocations when running under
/// a sanitizer.
size_t RedZoneSize = 1;
+#endif
static size_t computeSlabSize(unsigned SlabIdx) {
// Scale the actual allocated slab size based on the number of slabs
diff --git a/llvm/include/llvm/Support/PerThreadBumpPtrAllocator.h b/llvm/include/llvm/Support/PerThreadBumpPtrAllocator.h
index f94d18f62e9ab..a11b0cb14bd66 100644
--- a/llvm/include/llvm/Support/PerThreadBumpPtrAllocator.h
+++ b/llvm/include/llvm/Support/PerThreadBumpPtrAllocator.h
@@ -82,15 +82,9 @@ class PerThreadAllocator
return TotalMemory;
}
- /// Return allocated size by all allocators.
- size_t getBytesAllocated() const {
- size_t BytesAllocated = 0;
-
- for (size_t Idx = 0; Idx < getNumberOfAllocators(); Idx++)
- BytesAllocated += Allocators[Idx].getBytesAllocated();
-
- return BytesAllocated;
- }
+ /// The underlying allocators no longer track the number of bytes requested;
+ /// this always returns 0. Use getTotalMemory() for the memory held.
+ size_t getBytesAllocated() const { return 0; }
/// Set red zone for all allocators.
void setRedZoneSize(size_t NewSize) {
diff --git a/llvm/lib/TableGen/Record.cpp b/llvm/lib/TableGen/Record.cpp
index e21588101dc37..e9d7febf12272 100644
--- a/llvm/lib/TableGen/Record.cpp
+++ b/llvm/lib/TableGen/Record.cpp
@@ -120,7 +120,6 @@ void detail::RecordKeeperImpl::dumpAllocationStats(raw_ostream &OS) const {
OS << "TheVarBitInitPool size = " << TheVarBitInitPool.size() << '\n';
OS << "TheVarDefInitPool size = " << TheVarDefInitPool.size() << '\n';
OS << "TheFieldInitPool size = " << TheFieldInitPool.size() << '\n';
- OS << "Bytes allocated = " << Allocator.getBytesAllocated() << '\n';
OS << "Total allocator memory = " << Allocator.getTotalMemory() << "\n\n";
OS << "Number of records instantiated = " << LastRecordID << '\n';
diff --git a/llvm/unittests/ADT/ConcurrentHashtableTest.cpp b/llvm/unittests/ADT/ConcurrentHashtableTest.cpp
index 05c480959142b..446b41795143e 100644
--- a/llvm/unittests/ADT/ConcurrentHashtableTest.cpp
+++ b/llvm/unittests/ADT/ConcurrentHashtableTest.cpp
@@ -49,7 +49,6 @@ TEST(ConcurrentHashTableTest, AddStringEntries) {
parallel::TaskGroup tg;
tg.spawn([&]() {
- size_t AllocatedBytesAtStart = Allocator.getBytesAllocated();
std::pair<String *, bool> res1 = HashTable.insert("1");
// Check entry is inserted.
EXPECT_TRUE(res1.first->getKey() == "1");
@@ -79,8 +78,6 @@ TEST(ConcurrentHashTableTest, AddStringEntries) {
// Check first entry is still valid.
EXPECT_TRUE(res1.first->getKey() == "1");
- // Check data was allocated by allocator.
- EXPECT_TRUE(Allocator.getBytesAllocated() > AllocatedBytesAtStart);
// Check statistic.
std::string StatisticString;
@@ -107,15 +104,10 @@ TEST(ConcurrentHashTableTest, AddStringMultiplueEntries) {
tg.spawn([&]() {
// Check insertion.
for (size_t I = 0; I < NumElements; I++) {
- BumpPtrAllocator &ThreadLocalAllocator =
- Allocator.getThreadLocalAllocator();
- size_t AllocatedBytesAtStart = ThreadLocalAllocator.getBytesAllocated();
std::string StringForElement = formatv("{0}", I);
std::pair<String *, bool> Entry = HashTable.insert(StringForElement);
EXPECT_TRUE(Entry.second);
EXPECT_TRUE(Entry.first->getKey() == StringForElement);
- EXPECT_TRUE(ThreadLocalAllocator.getBytesAllocated() >
- AllocatedBytesAtStart);
}
std::string StatisticString;
@@ -129,16 +121,10 @@ TEST(ConcurrentHashTableTest, AddStringMultiplueEntries) {
// Check insertion of duplicates.
for (size_t I = 0; I < NumElements; I++) {
- BumpPtrAllocator &ThreadLocalAllocator =
- Allocator.getThreadLocalAllocator();
- size_t AllocatedBytesAtStart = ThreadLocalAllocator.getBytesAllocated();
std::string StringForElement = formatv("{0}", I);
std::pair<String *, bool> Entry = HashTable.insert(StringForElement);
EXPECT_FALSE(Entry.second);
EXPECT_TRUE(Entry.first->getKey() == StringForElement);
- // Check no additional bytes were allocated for duplicate.
- EXPECT_TRUE(ThreadLocalAllocator.getBytesAllocated() ==
- AllocatedBytesAtStart);
}
// Check statistic.
@@ -165,15 +151,10 @@ TEST(ConcurrentHashTableTest, AddStringMultiplueEntriesWithResize) {
tg.spawn([&]() {
// Check insertion.
for (size_t I = 0; I < NumElements; I++) {
- BumpPtrAllocator &ThreadLocalAllocator =
- Allocator.getThreadLocalAllocator();
- size_t AllocatedBytesAtStart = ThreadLocalAllocator.getBytesAllocated();
std::string StringForElement = formatv("{0} {1}", I, I + 100);
std::pair<String *, bool> Entry = HashTable.insert(StringForElement);
EXPECT_TRUE(Entry.second);
EXPECT_TRUE(Entry.first->getKey() == StringForElement);
- EXPECT_TRUE(ThreadLocalAllocator.getBytesAllocated() >
- AllocatedBytesAtStart);
}
std::string StatisticString;
@@ -187,16 +168,10 @@ TEST(ConcurrentHashTableTest, AddStringMultiplueEntriesWithResize) {
// Check insertion of duplicates.
for (size_t I = 0; I < NumElements; I++) {
- BumpPtrAllocator &ThreadLocalAllocator =
- Allocator.getThreadLocalAllocator();
- size_t AllocatedBytesAtStart = ThreadLocalAllocator.getBytesAllocated();
std::string StringForElement = formatv("{0} {1}", I, I + 100);
std::pair<String *, bool> Entry = HashTable.insert(StringForElement);
EXPECT_FALSE(Entry.second);
EXPECT_TRUE(Entry.first->getKey() == StringForElement);
- // Check no additional bytes were allocated for duplicate.
- EXPECT_TRUE(ThreadLocalAllocator.getBytesAllocated() ==
- AllocatedBytesAtStart);
}
// Check statistic.
@@ -217,15 +192,10 @@ TEST(ConcurrentHashTableTest, AddStringEntriesParallel) {
// Check parallel insertion.
parallelFor(0, NumElements, [&](size_t I) {
- BumpPtrAllocator &ThreadLocalAllocator =
- Allocator.getThreadLocalAllocator();
- size_t AllocatedBytesAtStart = ThreadLocalAllocator.getBytesAllocated();
std::string StringForElement = formatv("{0}", I);
std::pair<String *, bool> Entry = HashTable.insert(StringForElement);
EXPECT_TRUE(Entry.second);
EXPECT_TRUE(Entry.first->getKey() == StringForElement);
- EXPECT_TRUE(ThreadLocalAllocator.getBytesAllocated() >
- AllocatedBytesAtStart);
});
std::string StatisticString;
@@ -239,16 +209,10 @@ TEST(ConcurrentHashTableTest, AddStringEntriesParallel) {
// Check parallel insertion of duplicates.
parallelFor(0, NumElements, [&](size_t I) {
- BumpPtrAllocator &ThreadLocalAllocator =
- Allocator.getThreadLocalAllocator();
- size_t AllocatedBytesAtStart = ThreadLocalAllocator.getBytesAllocated();
std::string StringForElement = formatv("{0}", I);
std::pair<String *, bool> Entry = HashTable.insert(StringForElement);
EXPECT_FALSE(Entry.second);
EXPECT_TRUE(Entry.first->getKey() == StringForElement);
- // Check no additional bytes were allocated for duplicate.
- EXPECT_TRUE(ThreadLocalAllocator.getBytesAllocated() ==
- AllocatedBytesAtStart);
});
// Check statistic.
@@ -268,15 +232,10 @@ TEST(ConcurrentHashTableTest, AddStringEntriesParallelWithResize) {
// Check parallel insertion.
parallelFor(0, NumElements, [&](size_t I) {
- BumpPtrAllocator &ThreadLocalAllocator =
- Allocator.getThreadLocalAllocator();
- size_t AllocatedBytesAtStart = ThreadLocalAllocator.getBytesAllocated();
std::string StringForElement = formatv("{0}", I);
std::pair<String *, bool> Entry = HashTable.insert(StringForElement);
EXPECT_TRUE(Entry.second);
EXPECT_TRUE(Entry.first->getKey() == StringForElement);
- EXPECT_TRUE(ThreadLocalAllocator.getBytesAllocated() >
- AllocatedBytesAtStart);
});
std::string StatisticString;
@@ -290,16 +249,10 @@ TEST(ConcurrentHashTableTest, AddStringEntriesParallelWithResize) {
// Check parallel insertion of duplicates.
parallelFor(0, NumElements, [&](size_t I) {
- BumpPtrAllocator &ThreadLocalAllocator =
- Allocator.getThreadLocalAllocator();
- size_t AllocatedBytesAtStart = ThreadLocalAllocator.getBytesAllocated();
std::string StringForElement = formatv("{0}", I);
std::pair<String *, bool> Entry = HashTable.insert(StringForElement);
EXPECT_FALSE(Entry.second);
EXPECT_TRUE(Entry.first->getKey() == StringForElement);
- // Check no additional bytes were allocated for duplicate.
- EXPECT_TRUE(ThreadLocalAllocator.getBytesAllocated() ==
- AllocatedBytesAtStart);
});
// Check statistic.
diff --git a/llvm/unittests/DebugInfo/MSF/MappedBlockStreamTest.cpp b/llvm/unittests/DebugInfo/MSF/MappedBlockStreamTest.cpp
index d1f04e9b28a34..86be4ee0f2aab 100644
--- a/llvm/unittests/DebugInfo/MSF/MappedBlockStreamTest.cpp
+++ b/llvm/unittests/DebugInfo/MSF/MappedBlockStreamTest.cpp
@@ -110,7 +110,6 @@ TEST(MappedBlockStreamTest, ReadOntoNonEmptyBuffer) {
StringRef Str = "ZYXWVUTSRQPONMLKJIHGFEDCBA";
EXPECT_THAT_ERROR(R.readFixedString(Str, 1), Succeeded());
EXPECT_EQ(Str, StringRef("A"));
- EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
}
// Tests that a read which crosses a block boundary, but where the subsequent
@@ -124,12 +123,10 @@ TEST(MappedBlockStreamTest, ZeroCopyReadContiguousBreak) {
StringRef Str;
EXPECT_THAT_ERROR(R.readFixedString(Str, 2), Succeeded());
EXPECT_EQ(Str, StringRef("AB"));
- EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
R.setOffset(6);
EXPECT_THAT_ERROR(R.readFixedString(Str, 4), Succeeded());
EXPECT_EQ(Str, StringRef("GHIJ"));
- EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
}
// Tests that a read which crosses a block boundary and cannot be referenced
@@ -143,7 +140,6 @@ TEST(MappedBlockStreamTest, CopyReadNonContiguousBreak) {
StringRef Str;
EXPECT_THAT_ERROR(R.readFixedString(Str, 10), Succeeded());
EXPECT_EQ(Str, StringRef("ABCDEFGHIJ"));
- EXPECT_EQ(10U, F.Allocator.getBytesAllocated());
}
// Test that an out of bounds read which doesn't cross a block boundary
@@ -157,7 +153,6 @@ TEST(MappedBlockStreamTest, InvalidReadSizeNoBreak) {
R.setOffset(10);
EXPECT_THAT_ERROR(R.readFixedString(Str, 1), Failed());
- EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
}
// Test that an out of bounds read which crosses a contiguous block boundary
@@ -171,7 +166,6 @@ TEST(MappedBlockStreamTest, InvalidReadSizeContiguousBreak) {
R.setOffset(6);
EXPECT_THAT_ERROR(R.readFixedString(Str, 5), Failed());
- EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
}
// Test that an out of bounds read which crosses a discontiguous block
@@ -184,7 +178,6 @@ TEST(MappedBlockStreamTest, InvalidReadSizeNonContiguousBreak) {
StringRef Str;
EXPECT_THAT_ERROR(R.readFixedString(Str, 11), Failed());
- EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
}
// Tests that a read which is entirely contained within a single block but
@@ -197,7 +190,6 @@ TEST(MappedBlockStreamTest, ZeroCopyReadNoBreak) {
StringRef Str;
EXPECT_THAT_ERROR(R.readFixedString(Str, 1), Succeeded());
EXPECT_EQ(Str, StringRef("A"));
- EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
}
// Tests that a read which is not aligned on the same boundary as a previous
@@ -212,13 +204,11 @@ TEST(MappedBlockStreamTest, UnalignedOverlappingRead) {
StringRef Str2;
EXPECT_THAT_ERROR(R.readFixedString(Str1, 7), Succeeded());
EXPECT_EQ(Str1, StringRef("ABCDEFG"));
- EXPECT_EQ(7U, F.Allocator.getBytesAllocated());
R.setOffset(2);
EXPECT_THAT_ERROR(R.readFixedString(Str2, 3), Succeeded());
EXPECT_EQ(Str2, StringRef("CDE"));
EXPECT_EQ(Str1.data() + 2, Str2.data());
- EXPECT_EQ(7U, F.Allocator.getBytesAllocated());
}
// Tests that a read which is not aligned on the same boundary as a previous
@@ -233,12 +223,10 @@ TEST(MappedBlockStreamTest, UnalignedOverlappingReadFail) {
StringRef Str2;
EXPECT_THAT_ERROR(R.readFixedString(Str1, 6), Succeeded());
EXPECT_EQ(Str1, StringRef("ABCDEF"));
- EXPECT_EQ(6U, F.Allocator.getBytesAllocated());
R.setOffset(4);
EXPECT_THAT_ERROR(R.readFixedString(Str2, 4), Succeeded());
EXPECT_EQ(Str2, StringRef("EFGH"));
- EXPECT_EQ(10U, F.Allocator.getBytesAllocated());
}
TEST(MappedBlockStreamTest, WriteBeyondEndOfStream) {
diff --git a/llvm/unittests/Support/AllocatorTest.cpp b/llvm/unittests/Support/AllocatorTest.cpp
index d6f80e0948dc4..744967de9004e 100644
--- a/llvm/unittests/Support/AllocatorTest.cpp
+++ b/llvm/unittests/Support/AllocatorTest.cpp
@@ -105,24 +105,20 @@ TEST(AllocatorTest, TestAlignment) {
// we end up creating a sla...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/205711
More information about the cfe-commits
mailing list