Skip to content

Change heap dumps to use HEAP2 as the default#127321

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
hoyosjs merged 6 commits into from
Apr 24, 2026
Merged

Change heap dumps to use HEAP2 as the default #127321

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
7fe8771
First basic HEAP2 and dump option cleanup
hoyosjs Apr 23, 2026
a731fb4
Remove first level of HEAP2 branches
hoyosjs Apr 23, 2026
594da9f
Update src/coreclr/debug/createdump/crashinfo.cpp
hoyosjs Apr 23, 2026
025eaa8
Apply suggestions from code review
hoyosjs Apr 23, 2026
6caf968
Fix final feedback
hoyosjs Apr 23, 2026
9ef63b9
Merge branch 'juhoyosa/heap2-default' of https://github.com/hoyosjs/r…
hoyosjs Apr 23, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
26 changes: 1 addition & 25 deletions src/coreclr/debug/createdump/crashinfo.cpp
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -379,33 +379,9 @@ CrashInfo::EnumerateMemoryRegionsWithDAC(DumpType dumpType)
TRACE("EnumerateMemoryRegionsWithDAC: Memory enumeration STARTED (%d %d)\n", m_enumMemoryPagesAdded, m_dataTargetPagesAdded);

// CLRDATA_ENUM_MEM_HEAP2 skips the expensive (in both time and memory usage) enumeration of the
// low level data structures and adds all the loader allocator heaps instead. The older 'DbgEnableFastHeapDumps'
// env var didn't generate a complete enough heap dump on Linux and this new path does.
// low level data structures and adds all the loader allocator heaps instead.
CLRDataEnumMemoryFlags flags = CLRDATA_ENUM_MEM_HEAP2;
Comment thread
hoyosjs marked this conversation as resolved.
MINIDUMP_TYPE minidumpType = GetMiniDumpType(dumpType);
if (dumpType == DumpType::Heap)
{
// This is the old fast heap env var for backwards compatibility for VS4Mac.
CLRConfigNoCache fastHeapDumps = CLRConfigNoCache::Get("DbgEnableFastHeapDumps", /*noprefix*/ false, &getenv);
DWORD val = 0;
if (fastHeapDumps.IsSet() && fastHeapDumps.TryAsInteger(10, val) && val == 1)
{
// Since on MacOS all the RW regions will be added for heap dumps by createdump, the
// only thing differentiating a MiniDumpNormal and a MiniDumpWithPrivateReadWriteMemory
// is that the later uses the EnumMemoryRegions APIs. This is kind of expensive on larger
// applications (4 minutes, or even more), and this should already be in RW pages. Change
// the dump type to the faster normal one. This one already ensures necessary DAC globals,
// etc. without the costly assembly, module, class, type runtime data structures enumeration.
minidumpType = MiniDumpNormal;
flags = CLRDATA_ENUM_MEM_DEFAULT;
}
// This env var allows the CLRDATA_ENUM_MEM_HEAP2 fast path to be opt-ed out
fastHeapDumps = CLRConfigNoCache::Get("EnableFastHeapDumps", /*noprefix*/ false, &getenv);
if (fastHeapDumps.IsSet() && fastHeapDumps.TryAsInteger(10, val) && val == 0)
{
flags = CLRDATA_ENUM_MEM_DEFAULT;
}
}
// Calls CrashInfo::EnumMemoryRegion for each memory region found by the DAC
HRESULT hr = m_pClrDataEnumRegions->EnumMemoryRegions(this, minidumpType, flags);
if (FAILED(hr))
Expand Down
109 changes: 27 additions & 82 deletions src/coreclr/debug/daccess/enummem.cpp
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -1865,97 +1865,51 @@ HRESULT ClrDataAccess::EnumMemWriteDataSegment()

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Custom Dump. Depending on the value of g_ECustomDumpFlavor, different dump
// will be taken. You can set this global variable using hosting API
// ICLRErrorReportingManager::BeginCustomDump.
// Custom dumps enumerate the minimal CLR state needed for
// MiniDumpWithFullAuxiliaryState: thread stacks, modules, CLR statics, and any
// memory reached implicitly from those roots.
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
HRESULT ClrDataAccess::EnumMemoryRegionsWorkerCustom()
{
SUPPORTS_DAC;

HRESULT status = S_OK;

ECustomDumpFlavor eFlavor;

eFlavor = DUMP_FLAVOR_Default;

m_enumMemFlags = CLRDATA_ENUM_MEM_MINI;

Comment thread
hoyosjs marked this conversation as resolved.
// clear all of the previous cached memory
Flush();

if (eFlavor == DUMP_FLAVOR_Mini)
// Iterating to all threads' stacks
CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemDumpAllThreadsStack(m_enumMemFlags); )
if (FAILED(status))
{
// Iterating to all threads' stacks
CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemDumpAllThreadsStack(m_enumMemFlags); )

// Iterating to module list.
CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemDumpModuleList(m_enumMemFlags); )

//
// iterating through static that we care
//
// collect CLR static
CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemCLRStatic(m_enumMemFlags); )

// we are done...

// now dump the memory get dragged in implicitly
m_dumpStats.m_cbImplicitly = m_instances.DumpAllInstances(m_enumMemCb);

return status;
}
else if (eFlavor == DUMP_FLAVOR_CriticalCLRState)
{
// We need to walk Threads stack to view managed frames.
// Iterating through module list

// Iterating to all threads' stacks
CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemDumpAllThreadsStack(m_enumMemFlags); )

// Iterating to module list.
CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemDumpModuleList(m_enumMemFlags); )

//
// iterating through static that we care
//
// collect CLR static
CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemCLRStatic(m_enumMemFlags); )

// Collecting some CLR secondary critical data
CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemCLRHeapCrticalStatic(m_enumMemFlags); )
CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemWriteDataSegment(); )

// we are done...

// now dump the memory get dragged in implicitly
m_dumpStats.m_cbImplicitly = m_instances.DumpAllInstances(m_enumMemCb);

}
else if (eFlavor == DUMP_FLAVOR_NonHeapCLRState)
// Iterating to module list.
CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemDumpModuleList(m_enumMemFlags); )
if (FAILED(status))
{
// since all CLR hosted heap will be dump by the host,
// the EE structures that are not loaded using LoadLibrary will
// be included by the host.
//
// Thus we only need to include mscorwks's critical data and ngen images

m_enumMemFlags = CLRDATA_ENUM_MEM_HEAP;

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemCLRStatic(m_enumMemFlags); )

// Collecting some CLR secondary critical data
CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemCLRHeapCrticalStatic(m_enumMemFlags); )

CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemWriteDataSegment(); )
CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemCollectImages(); )
return status;
}
else

//
// iterating through static that we care
//
// collect CLR static
CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED( status = EnumMemCLRStatic(m_enumMemFlags); )
if (FAILED(status))
{
status = E_INVALIDARG;
return status;
}

return S_OK;
// we are done...

// now dump the memory get dragged in implicitly
m_dumpStats.m_cbImplicitly = m_instances.DumpAllInstances(m_enumMemCb);

return status;
}
Comment thread
hoyosjs marked this conversation as resolved.

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Expand DownExpand Up@@ -1999,7 +1953,7 @@ HRESULT ClrDataAccess::EnumMemoryRegionsWrapper(IN CLRDataEnumMemoryFlags flags)
// triage micro-dump
status = EnumMemoryRegionsWorkerMicroTriage(flags);
}
else if (flags == CLRDATA_ENUM_MEM_HEAP || flags == CLRDATA_ENUM_MEM_HEAP2)
else if (flags == CLRDATA_ENUM_MEM_HEAP2)
{
status = EnumMemoryRegionsWorkerHeap(flags);
}
Expand DownExpand Up@@ -2091,16 +2045,7 @@ ClrDataAccess::EnumMemoryRegions(IN ICLRDataEnumMemoryRegionsCallback* callback,
ClearDumpStats();
if (miniDumpFlags & MiniDumpWithPrivateReadWriteMemory)
{
// heap dump
if (flags == CLRDATA_ENUM_MEM_HEAP2)
{
DacLogMessage("EnumMemoryRegions(CLRDATA_ENUM_MEM_HEAP2)\n");
}
else
{
flags = CLRDATA_ENUM_MEM_HEAP;
}
status = EnumMemoryRegionsWrapper(flags);
status = EnumMemoryRegionsWrapper(CLRDATA_ENUM_MEM_HEAP2);
}
else if (miniDumpFlags & MiniDumpWithFullAuxiliaryState)
{
Expand Down
23 changes: 0 additions & 23 deletions src/coreclr/debug/ee/functioninfo.cpp
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -2435,16 +2435,6 @@ DebuggerMethodInfo::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
DAC_ENUM_DTHIS();
SUPPORTS_DAC;

if (flags != CLRDATA_ENUM_MEM_MINI && flags != CLRDATA_ENUM_MEM_TRIAGE && flags != CLRDATA_ENUM_MEM_HEAP2)
{
// Modules are enumerated already for minidumps, save the empty calls.
if (m_module.IsValid())
{
m_module->EnumMemoryRegions(flags, true);
}

}

PTR_DebuggerJitInfo jitInfo = m_latestJitInfo;
while (jitInfo.IsValid())
{
Expand All@@ -2464,19 +2454,6 @@ DebuggerJitInfo::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
m_methodInfo->EnumMemoryRegions(flags);
}

if (flags != CLRDATA_ENUM_MEM_MINI && flags != CLRDATA_ENUM_MEM_TRIAGE && flags != CLRDATA_ENUM_MEM_HEAP2)
{
if (m_nativeCodeVersion.GetMethodDesc().IsValid())
{
m_nativeCodeVersion.GetMethodDesc()->EnumMemoryRegions(flags);
}

DacEnumMemoryRegion(PTR_TO_TADDR(GetSequenceMap()),
GetSequenceMapCount() * sizeof(DebuggerILToNativeMap));
DacEnumMemoryRegion(PTR_TO_TADDR(GetVarNativeInfo()),
GetVarNativeInfoCount() *
sizeof(ICorDebugInfo::NativeVarInfo));
}
}


Expand Down
15 changes: 0 additions & 15 deletions src/coreclr/vm/assembly.cpp
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -1904,21 +1904,6 @@ Assembly::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
{
GetLoaderAllocator()->EnumMemoryRegions(flags);
}
else
{
if (m_pClassLoader.IsValid())
{
m_pClassLoader->EnumMemoryRegions(flags);
}
if (m_pModule.IsValid())
{
m_pModule->EnumMemoryRegions(flags, true);
}
if (m_pPEAssembly.IsValid())
{
m_pPEAssembly->EnumMemoryRegions(flags);
}
}
}

#else // DACCESS_COMPILE
Expand Down
73 changes: 0 additions & 73 deletions src/coreclr/vm/ceeload.cpp
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -4565,79 +4565,6 @@ void Module::EnumMemoryRegions(CLRDataEnumMemoryFlags flags,
{
GetLoaderAllocator()->EnumMemoryRegions(flags);
}
else if (flags != CLRDATA_ENUM_MEM_MINI && flags != CLRDATA_ENUM_MEM_TRIAGE)
{
if (m_pAvailableClasses.IsValid())
{
m_pAvailableClasses->EnumMemoryRegions(flags);
}
if (m_pAvailableParamTypes.IsValid())
{
m_pAvailableParamTypes->EnumMemoryRegions(flags);
}
if (m_pInstMethodHashTable.IsValid())
{
m_pInstMethodHashTable->EnumMemoryRegions(flags);
}
if (m_pAvailableClassesCaseIns.IsValid())
{
m_pAvailableClassesCaseIns->EnumMemoryRegions(flags);
}

// Save the LookupMap structures.
m_MethodDefToDescMap.ListEnumMemoryRegions(flags);
m_FieldDefToDescMap.ListEnumMemoryRegions(flags);
m_MemberRefMap.ListEnumMemoryRegions(flags);
m_GenericParamToDescMap.ListEnumMemoryRegions(flags);
m_ManifestModuleReferencesMap.ListEnumMemoryRegions(flags);

LookupMap<PTR_MethodTable>::Iterator typeDefIter(&m_TypeDefToMethodTableMap);
while (typeDefIter.Next())
{
if (typeDefIter.GetElement())
{
typeDefIter.GetElement()->EnumMemoryRegions(flags);
}
}

LookupMap<PTR_TypeRef>::Iterator typeRefIter(&m_TypeRefToMethodTableMap);
while (typeRefIter.Next())
{
if (typeRefIter.GetElement())
{
TypeHandle th = TypeHandle::FromTAddr(dac_cast<TADDR>(typeRefIter.GetElement()));
th.EnumMemoryRegions(flags);
}
}

LookupMap<PTR_MethodDesc>::Iterator methodDefIter(&m_MethodDefToDescMap);
while (methodDefIter.Next())
{
if (methodDefIter.GetElement())
{
methodDefIter.GetElement()->EnumMemoryRegions(flags);
}
}

LookupMap<PTR_FieldDesc>::Iterator fieldDefIter(&m_FieldDefToDescMap);
while (fieldDefIter.Next())
{
if (fieldDefIter.GetElement())
{
fieldDefIter.GetElement()->EnumMemoryRegions(flags);
}
}

LookupMap<PTR_TypeVarTypeDesc>::Iterator genericParamIter(&m_GenericParamToDescMap);
while (genericParamIter.Next())
{
if (genericParamIter.GetElement())
{
genericParamIter.GetElement()->EnumMemoryRegions(flags);
}
}

} // !CLRDATA_ENUM_MEM_MINI && !CLRDATA_ENUM_MEM_TRIAGE && !CLRDATA_ENUM_MEM_HEAP2

LookupMap<PTR_Module>::Iterator asmRefIter(&m_ManifestModuleReferencesMap);
while (asmRefIter.Next())
Expand Down
15 changes: 0 additions & 15 deletions src/coreclr/vm/class.cpp
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -3249,21 +3249,6 @@ EEClass::EnumMemoryRegions(CLRDataEnumMemoryFlags flags, MethodTable * pMT)
if (HasOptionalFields())
DacEnumMemoryRegion(dac_cast<TADDR>(GetOptionalFields()), sizeof(EEClassOptionalFields));

if (flags != CLRDATA_ENUM_MEM_MINI && flags != CLRDATA_ENUM_MEM_TRIAGE && flags != CLRDATA_ENUM_MEM_HEAP2)
{
PTR_Module pModule = pMT->GetModule();
if (pModule.IsValid())
{
pModule->EnumMemoryRegions(flags, true);
}
PTR_MethodDescChunk chunk = GetChunks();
while (chunk.IsValid())
{
chunk->EnumMemoryRegions(flags);
chunk = chunk->GetNextChunk();
}
}

PTR_FieldDesc pFieldDescList = GetFieldDescList();
if (pFieldDescList.IsValid())
{
Expand Down
8 changes: 0 additions & 8 deletions src/coreclr/vm/methodtable.cpp
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -7789,14 +7789,6 @@ MethodTable::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
}
}

if (flags != CLRDATA_ENUM_MEM_MINI && flags != CLRDATA_ENUM_MEM_TRIAGE && flags != CLRDATA_ENUM_MEM_HEAP2)
{
DispatchMap * pMap = GetDispatchMap();
if (pMap != NULL)
{
pMap->EnumMemoryRegions(flags);
}
}
} // MethodTable::EnumMemoryRegions

#endif // DACCESS_COMPILE
Expand Down
9 changes: 0 additions & 9 deletions src/coreclr/vm/threads.cpp
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -6842,10 +6842,6 @@ Thread::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
WRAPPER_NO_CONTRACT;

DAC_ENUM_DTHIS();
if (flags != CLRDATA_ENUM_MEM_MINI && flags != CLRDATA_ENUM_MEM_TRIAGE && flags != CLRDATA_ENUM_MEM_HEAP2)
{
AppDomain::GetCurrentDomain()->EnumMemoryRegions(flags, true);
}

if (m_debuggerFilterContext.IsValid())
{
Expand DownExpand Up@@ -6933,11 +6929,6 @@ Thread::EnumMemoryRegionsWorker(CLRDataEnumMemoryFlags flags)
DacGetThreadContext(this, &context);
}

if (flags != CLRDATA_ENUM_MEM_MINI && flags != CLRDATA_ENUM_MEM_TRIAGE && flags != CLRDATA_ENUM_MEM_HEAP2)
{
AppDomain::GetCurrentDomain()->EnumMemoryRegions(flags, true);
}

FillRegDisplay(&regDisp, &context);
frameIter.Init(this, NULL, &regDisp, 0);
while (frameIter.IsValid())
Expand Down