[llvm] ca59c69 - [Allocator] Drop RedZoneSize (non-sanitizer) and BytesAllocated members (#205711)
via llvm-commits
llvm-commits at lists.llvm.org
Sat Jun 27 19:16:05 PDT 2026
Author: Fangrui Song
Date: 2026-06-28T02:15:56Z
New Revision: ca59c69132eef55cc42bf8854706590dfddf5584
URL: https://github.com/llvm/llvm-project/commit/ca59c69132eef55cc42bf8854706590dfddf5584
DIFF: https://github.com/llvm/llvm-project/commit/ca59c69132eef55cc42bf8854706590dfddf5584.diff
LOG: [Allocator] Drop RedZoneSize (non-sanitizer) and BytesAllocated members (#205711)
`RedZoneSize` is only read inside `#if LLVM_ADDRESS_SANITIZER_BUILD`.
Additionally gate it under `LLVM_ENABLE_ABI_BREAKING_CHECKS` so that
release-non-assertions builds don't incur the overhead. To support
non-asan build with asan library users, the variable is only omitted in
`!LLVM_ENABLE_ABI_BREAKING_CHECKS` 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
Added:
Modified:
clang-tools-extra/clangd/CompileCommands.cpp
clang/unittests/Lex/PPMemoryAllocationsTest.cpp
lldb/include/lldb/Utility/ConstString.h
lldb/source/Target/Statistics.cpp
lldb/source/Utility/ConstString.cpp
lldb/test/API/commands/statistics/basic/TestStats.py
llvm/include/llvm/Support/Allocator.h
llvm/include/llvm/Support/PerThreadBumpPtrAllocator.h
llvm/lib/Support/Allocator.cpp
llvm/lib/TableGen/Record.cpp
llvm/tools/llubi/lib/Context.cpp
llvm/tools/llubi/lib/Context.h
llvm/unittests/ADT/ConcurrentHashtableTest.cpp
llvm/unittests/DebugInfo/MSF/MappedBlockStreamTest.cpp
llvm/unittests/Support/AllocatorTest.cpp
llvm/unittests/Support/PerThreadBumpPtrAllocatorTest.cpp
llvm/unittests/Support/ThreadSafeAllocatorTest.cpp
Removed:
################################################################################
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 ea8e8a829ee55..bb0ca118e2015 100644
--- a/llvm/include/llvm/Support/Allocator.h
+++ b/llvm/include/llvm/Support/Allocator.h
@@ -18,6 +18,7 @@
#define LLVM_SUPPORT_ALLOCATOR_H
#include "llvm/ADT/SmallVector.h"
+#include "llvm/Config/abi-breaking.h"
#include "llvm/Support/Alignment.h"
#include "llvm/Support/AllocatorBase.h"
#include "llvm/Support/Compiler.h"
@@ -36,9 +37,7 @@ namespace detail {
// We call out to an external function to actually print the message as the
// printing code uses Allocator.h in its implementation.
-LLVM_ABI void printBumpPtrAllocatorStats(unsigned NumSlabs,
- size_t BytesAllocated,
- size_t TotalMemory);
+LLVM_ABI void printBumpPtrAllocatorStats(unsigned NumSlabs, size_t TotalMemory);
} // end namespace detail
@@ -96,11 +95,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_ENABLE_ABI_BREAKING_CHECKS
+ RedZoneSize = Old.RedZoneSize;
+#endif
Old.CurPtr = nullptr;
Old.EndSentinel = 0;
- Old.BytesAllocated = 0;
Old.Slabs.clear();
Old.CustomSizedSlabs.clear();
}
@@ -116,15 +116,15 @@ class BumpPtrAllocatorImpl
CurPtr = RHS.CurPtr;
EndSentinel = RHS.EndSentinel;
- BytesAllocated = RHS.BytesAllocated;
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
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 +141,6 @@ class BumpPtrAllocatorImpl
return;
// Reset the state.
- BytesAllocated = 0;
CurPtr = (char *)Slabs.front();
EndSentinel = uintptr_t(CurPtr) + SlabSize + 1;
@@ -158,12 +157,10 @@ 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.
+#if LLVM_ADDRESS_SANITIZER_BUILD && LLVM_ENABLE_ABI_BREAKING_CHECKS
+ // Add trailing bytes as a "red zone" under ASan. RedZoneSize only exists
+ // when both conditions are true.
SizeToAllocate += RedZoneSize;
#endif
SizeToAllocate = alignToPowerOf2(SizeToAllocate, MinAlign);
@@ -308,15 +305,14 @@ class BumpPtrAllocatorImpl
return TotalMemory;
}
- size_t getBytesAllocated() const { return BytesAllocated; }
-
- void setRedZoneSize(size_t NewSize) {
+ void setRedZoneSize([[maybe_unused]] size_t NewSize) {
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
RedZoneSize = NewSize;
+#endif
}
void PrintStats() const {
- detail::printBumpPtrAllocatorStats(Slabs.size(), BytesAllocated,
- getTotalMemory());
+ detail::printBumpPtrAllocatorStats(Slabs.size(), getTotalMemory());
}
private:
@@ -335,14 +331,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;
-
- /// The number of bytes to put between allocations when running under
- /// a sanitizer.
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
+ /// 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
@@ -472,8 +465,6 @@ template <typename T> class SpecificBumpPtrAllocator {
std::optional<int64_t> identifyObject(const void *Ptr) {
return Allocator.identifyObject(Ptr);
}
-
- size_t getBytesAllocated() const { return Allocator.getBytesAllocated(); }
};
} // end namespace llvm
diff --git a/llvm/include/llvm/Support/PerThreadBumpPtrAllocator.h b/llvm/include/llvm/Support/PerThreadBumpPtrAllocator.h
index f94d18f62e9ab..0448fb2a12a9b 100644
--- a/llvm/include/llvm/Support/PerThreadBumpPtrAllocator.h
+++ b/llvm/include/llvm/Support/PerThreadBumpPtrAllocator.h
@@ -82,16 +82,6 @@ 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;
- }
-
/// Set red zone for all allocators.
void setRedZoneSize(size_t NewSize) {
for (size_t Idx = 0; Idx < getNumberOfAllocators(); Idx++)
diff --git a/llvm/lib/Support/Allocator.cpp b/llvm/lib/Support/Allocator.cpp
index 1af5744bf301e..6ff68f1be3d63 100644
--- a/llvm/lib/Support/Allocator.cpp
+++ b/llvm/lib/Support/Allocator.cpp
@@ -17,12 +17,9 @@ namespace llvm {
namespace detail {
-void printBumpPtrAllocatorStats(unsigned NumSlabs, size_t BytesAllocated,
- size_t TotalMemory) {
+void printBumpPtrAllocatorStats(unsigned NumSlabs, size_t TotalMemory) {
errs() << "\nNumber of memory regions: " << NumSlabs << '\n'
- << "Bytes used: " << BytesAllocated << '\n'
<< "Bytes allocated: " << TotalMemory << '\n'
- << "Bytes wasted: " << (TotalMemory - BytesAllocated)
<< " (includes alignment, etc)\n";
}
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/tools/llubi/lib/Context.cpp b/llvm/tools/llubi/lib/Context.cpp
index bd7c966a1c7e9..e89f7a43b45c6 100644
--- a/llvm/tools/llubi/lib/Context.cpp
+++ b/llvm/tools/llubi/lib/Context.cpp
@@ -368,9 +368,8 @@ const MaterializedConstant *Context::getConstantValue(Constant *C) {
if (Val.isNone())
return nullptr;
if (!Val.isCacheable()) {
- assert(NoncacheableConstBuffer.getBytesAllocated() <=
- 1024 * sizeof(MaterializedConstant) &&
- "Unbounded temporary buffer.");
+ assert(NoncacheableConstCount <= 1024 && "Unbounded temporary buffer.");
+ ++NoncacheableConstCount;
return new (NoncacheableConstBuffer.Allocate())
MaterializedConstant(std::move(Val));
}
@@ -380,6 +379,7 @@ const MaterializedConstant *Context::getConstantValue(Constant *C) {
void Context::resetNoncacheableConstantBuffer() {
NoncacheableConstBuffer.DestroyAll();
+ NoncacheableConstCount = 0;
}
APInt Context::getTag(uint32_t BitWidth, Provenance &Prov) {
diff --git a/llvm/tools/llubi/lib/Context.h b/llvm/tools/llubi/lib/Context.h
index d8e3450c4accd..097f0d1e0ab8b 100644
--- a/llvm/tools/llubi/lib/Context.h
+++ b/llvm/tools/llubi/lib/Context.h
@@ -306,6 +306,7 @@ class Context {
// Temporary buffer for non-cacheable constants (e.g.,
// undef/ptrtoint/inttoptr).
SpecificBumpPtrAllocator<MaterializedConstant> NoncacheableConstBuffer;
+ size_t NoncacheableConstCount = 0;
DenseMap<Function *, Pointer> FuncAddrMap;
DenseMap<BasicBlock *, Pointer> BlockAddrMap;
DenseMap<uint64_t, std::pair<Function *, IntrusiveRefCntPtr<MemoryObject>>>
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 slab for it.
TEST(AllocatorTest, TestZero) {
BumpPtrAllocator Alloc;
- Alloc.setRedZoneSize(0); // else our arithmetic is all off
+ Alloc.setRedZoneSize(0); // else the slab count below is off under ASan
EXPECT_EQ(0u, Alloc.GetNumSlabs());
- EXPECT_EQ(0u, Alloc.getBytesAllocated());
void *Empty = Alloc.Allocate(0, 1);
EXPECT_NE(Empty, nullptr) << "Allocate is __attribute__((returns_nonnull))";
EXPECT_EQ(1u, Alloc.GetNumSlabs()) << "Allocated a slab to point to";
- EXPECT_EQ(0u, Alloc.getBytesAllocated());
void *Large = Alloc.Allocate(4096, 1);
EXPECT_EQ(1u, Alloc.GetNumSlabs());
- EXPECT_EQ(4096u, Alloc.getBytesAllocated());
EXPECT_EQ(Empty, Large);
void *Empty2 = Alloc.Allocate(0, 1);
EXPECT_NE(Empty2, nullptr);
EXPECT_EQ(1u, Alloc.GetNumSlabs());
- EXPECT_EQ(4096u, Alloc.getBytesAllocated());
}
// Test allocating just over the slab size. This tests a bug where before the
diff --git a/llvm/unittests/Support/PerThreadBumpPtrAllocatorTest.cpp b/llvm/unittests/Support/PerThreadBumpPtrAllocatorTest.cpp
index d30de997f0fd1..4ac5ac4e1ff3b 100644
--- a/llvm/unittests/Support/PerThreadBumpPtrAllocatorTest.cpp
+++ b/llvm/unittests/Support/PerThreadBumpPtrAllocatorTest.cpp
@@ -26,13 +26,11 @@ TEST(PerThreadBumpPtrAllocatorTest, Simple) {
(uint64_t *)Allocator.Allocate(sizeof(uint64_t), alignof(uint64_t));
*Var = 0xFE;
EXPECT_EQ(0xFEul, *Var);
- EXPECT_EQ(sizeof(uint64_t), Allocator.getBytesAllocated());
- EXPECT_TRUE(Allocator.getBytesAllocated() <= Allocator.getTotalMemory());
+ EXPECT_LE(sizeof(uint64_t), Allocator.getTotalMemory());
PerThreadBumpPtrAllocator Allocator2(std::move(Allocator));
- EXPECT_EQ(sizeof(uint64_t), Allocator2.getBytesAllocated());
- EXPECT_TRUE(Allocator2.getBytesAllocated() <= Allocator2.getTotalMemory());
+ EXPECT_LE(sizeof(uint64_t), Allocator2.getTotalMemory());
EXPECT_EQ(0xFEul, *Var);
});
@@ -49,7 +47,7 @@ TEST(PerThreadBumpPtrAllocatorTest, ParallelAllocation) {
*ptr = Idx;
});
- EXPECT_EQ(sizeof(uint64_t) * NumAllocations, Allocator.getBytesAllocated());
+ EXPECT_LE(sizeof(uint64_t) * NumAllocations, Allocator.getTotalMemory());
EXPECT_EQ(Allocator.getNumberOfAllocators(), parallel::getThreadCount());
}
diff --git a/llvm/unittests/Support/ThreadSafeAllocatorTest.cpp b/llvm/unittests/Support/ThreadSafeAllocatorTest.cpp
index b3d9430fc0f30..107a3a8b59cca 100644
--- a/llvm/unittests/Support/ThreadSafeAllocatorTest.cpp
+++ b/llvm/unittests/Support/ThreadSafeAllocatorTest.cpp
@@ -117,7 +117,7 @@ TEST(ThreadSafeAllocatorTest, AllocWithAlign) {
Threads.wait();
Alloc.applyLocked([](BumpPtrAllocator &Alloc) {
- EXPECT_EQ(4950U * sizeof(int), Alloc.getBytesAllocated());
+ EXPECT_LE(4950U * sizeof(int), Alloc.getTotalMemory());
});
}
More information about the llvm-commits
mailing list