Add size-segregated buckets in UnlockedLoaderHeap

[eduardo-vp]

I was working with the test in https://github.com/korchak-aleksandr/net10-regression-repro and found out that the free list in UnlockedLoaderHeap grows to thousands of elements, which makes allocations very slow since we do a linear scan of this free list for each one of them.

In these scenarios multiple threads might need the same generic instantiation simultaneously and they all race to create/publish it. Multiple threads can lose the race and quickly add blocks to the free list since they don't need that memory. Subsequent calls that need generic instantiations do a linear scan of the free list to find a memory block to reuse. This ends up taking a lot of time due to its size (can be up to ten of thousands).

This PR splits the single list into 32 lists, each corresponding to free blocks of 8 bytes, 16 bytes, ..., 256 bytes (which are the most common sizes). We have another one for blocks bigger than 256 bytes.

	.NET 10	.NET 10 + this PR
Time	91.2 s	3.9 s
Max RSS	114.1 MB	114.5 MB

[Copilot]

Pull request overview

This PR restructures UnlockedLoaderHeap’s free list to reduce allocation-time overhead in backout-heavy scenarios by replacing a single linear-scanned free list with size-segregated buckets for common small block sizes plus an overflow list for larger blocks.

Changes:

• Replaces m_pFirstFreeBlock with 32 size buckets (pointer-size increments) and a separate “large/overflow” free list.
• Updates free-block insertion/allocation logic to use bucketed O(1) reuse for small sizes, and retains linear scanning only for the overflow list (including a stress-log warning on long scans).
• Adjusts debug-only free-list dumping and validation to iterate across all buckets and the overflow list.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 3 comments.

File	Description
src/coreclr/utilcode/loaderheap.cpp	Implements bucket initialization, bucket-aware allocation/insertion, overflow scan warning, and updates debug dump/validation to traverse buckets.
src/coreclr/utilcode/loaderheap_shared.h	Updates LoaderHeapFreeBlock API to no longer take an explicit head pointer (heap chooses bucket internally).
src/coreclr/inc/loaderheap.h	Adds bucket/overflow free list fields and related constants to UnlockedLoaderHeap.

[jkotas]

In these scenarios multiple threads might need the same generic instantiation simultaneously and they all race to create/publish it

Where is this race condition exactly? Can we add a lock there instead?

The freelist in LoaderHeap is meant to be only used in error conditions to backout types that failed to load, or to deal with rare race condition. If you see the freelist growing this much, it means that the loader heap is not used correctly. We should fix that instead.

[eduardo-vp]

I'll take a look, this the part where many threads lose

runtime/src/coreclr/vm/genmeth.cpp

Lines 493 to 542 in 24547a7

	InstantiatedMethodDesc *pOldMD = FindLoadedInstantiatedMethodDesc(pExactMT,
	pGenericMDescInRepMT->GetMemberDef(),
	methodInst,
	getWrappedCode,
	pGenericMDescInRepMT->IsAsyncVariantMethod());
	if (pOldMD == NULL)
	{
	// No one else got there first, our MethodDesc wins.
	amt.SuppressRelease();
	#ifdef _DEBUG
	SString name;
	TypeString::AppendMethodDebug(name, pNewMD);
	const char* pDebugNameUTF8 = name.GetUTF8();
	const char* verb = "Created";
	if (pWrappedMD)
	LOG((LF_CLASSLOADER, LL_INFO1000,
	"GENERICS: %s instantiating-stub method desc %s with dictionary size %d\n",
	verb, pDebugNameUTF8, infoSize));
	else
	LOG((LF_CLASSLOADER, LL_INFO1000,
	"GENERICS: %s instantiated method desc %s\n",
	verb, pDebugNameUTF8));
	S_SIZE_T safeLen = S_SIZE_T(strlen(pDebugNameUTF8))+S_SIZE_T(1);
	if(safeLen.IsOverflow()) COMPlusThrowHR(COR_E_OVERFLOW);
	size_t len = safeLen.Value();
	pNewMD->m_pszDebugMethodName = (char*) (void*)pAllocator->GetLowFrequencyHeap()->AllocMem(safeLen);
	_ASSERTE(pNewMD->m_pszDebugMethodName);
	strcpy_s((char *) pNewMD->m_pszDebugMethodName, len, pDebugNameUTF8);
	pNewMD->m_pszDebugClassName = pExactMT->GetDebugClassName();
	pNewMD->m_pszDebugMethodSignature = (LPUTF8)pNewMD->m_pszDebugMethodName;
	#endif // _DEBUG
	// Generic methods can't be varargs. code:MethodTableBuilder::ValidateMethods should have checked it.
	_ASSERTE(!pNewMD->IsVarArg());
	// Verify that we are not creating redundant MethodDescs
	_ASSERTE(!pNewMD->IsTightlyBoundToMethodTable());
	// The method desc is fully set up; now add to the table
	InstMethodHashTable* pTable = pExactMDLoaderModule->GetInstMethodHashTable();
	pTable->InsertMethodDesc(pNewMD);
	}
	else
	pNewMD = pOldMD;
	// CrstHolder goes out of scope here
	}