diff --git a/src/coreclr/inc/clrconfigvalues.h b/src/coreclr/inc/clrconfigvalues.h index 0e3e115ddfe042..2845790e2b71cd 100644 --- a/src/coreclr/inc/clrconfigvalues.h +++ b/src/coreclr/inc/clrconfigvalues.h @@ -462,6 +462,7 @@ RETAIL_CONFIG_DWORD_INFO(EXTERNAL_PerfMapEnabled, W("PerfMapEnabled"), 0, "This RETAIL_CONFIG_STRING_INFO_EX(EXTERNAL_PerfMapJitDumpPath, W("PerfMapJitDumpPath"), "Specifies a path to write the perf jitdump file. Defaults to /tmp", CLRConfig::LookupOptions::TrimWhiteSpaceFromStringValue) RETAIL_CONFIG_DWORD_INFO(EXTERNAL_PerfMapIgnoreSignal, W("PerfMapIgnoreSignal"), 0, "When perf map is enabled, this option will configure the specified signal to be accepted and ignored as a marker in the perf logs. It is disabled by default") RETAIL_CONFIG_DWORD_INFO(EXTERNAL_PerfMapShowOptimizationTiers, W("PerfMapShowOptimizationTiers"), 1, "Shows optimization tiers in the perf map for methods, as part of the symbol name. Useful for seeing separate stack frames for different optimization tiers of each method.") +RETAIL_CONFIG_DWORD_INFO(EXTERNAL_PerfMapStubGranularity, W("PerfMapStubGranularity"), 0, "Report stubs with varying amounts of granularity (low bit being zero indicates attempt to group all stubs of a type together) (second lowest bit being non-zero records stubs at individual allocation sites, which is more expensive, but also more accurate).") #endif RETAIL_CONFIG_STRING_INFO(EXTERNAL_StartupDelayMS, W("StartupDelayMS"), "") diff --git a/src/coreclr/utilcode/loaderheap.cpp b/src/coreclr/utilcode/loaderheap.cpp index dd7564fec642db..9aaf54a9f88aa1 100644 --- a/src/coreclr/utilcode/loaderheap.cpp +++ b/src/coreclr/utilcode/loaderheap.cpp @@ -1068,6 +1068,9 @@ BOOL UnlockedLoaderHeap::CommitPages(void* pData, size_t dwSizeToCommitPart) return TRUE; } +#ifdef FEATURE_PERFMAP +bool PerfMapLowGranularityStubs(); +#endif // FEATURE_PERFMAP BOOL UnlockedLoaderHeap::UnlockedReservePages(size_t dwSizeToCommit) { CONTRACTL @@ -1109,8 +1112,13 @@ BOOL UnlockedLoaderHeap::UnlockedReservePages(size_t dwSizeToCommit) // Figure out how much to reserve dwSizeToReserve = max(dwSizeToCommit, m_dwReserveBlockSize); - // Round to VIRTUAL_ALLOC_RESERVE_GRANULARITY - dwSizeToReserve = ALIGN_UP(dwSizeToReserve, VIRTUAL_ALLOC_RESERVE_GRANULARITY); +#ifdef FEATURE_PERFMAP // Perfmap requires that the memory assigned to stub generated regions be allocated only via fully commited memory + if (!IsInterleaved() || !PerfMapLowGranularityStubs()) +#endif // FEATURE_PERFMAP + { + // Round to VIRTUAL_ALLOC_RESERVE_GRANULARITY + dwSizeToReserve = ALIGN_UP(dwSizeToReserve, VIRTUAL_ALLOC_RESERVE_GRANULARITY); + } _ASSERTE(dwSizeToCommit <= dwSizeToReserve); diff --git a/src/coreclr/vm/amd64/cgenamd64.cpp b/src/coreclr/vm/amd64/cgenamd64.cpp index b681e067680cec..1ba7aae2916bd7 100644 --- a/src/coreclr/vm/amd64/cgenamd64.cpp +++ b/src/coreclr/vm/amd64/cgenamd64.cpp @@ -25,6 +25,10 @@ #include "clrtocomcall.h" #endif // FEATURE_COMINTEROP +#ifdef FEATURE_PERFMAP +#include "perfmap.h" +#endif + void UpdateRegDisplayFromCalleeSavedRegisters(REGDISPLAY * pRD, CalleeSavedRegisters * pRegs) { LIMITED_METHOD_CONTRACT; @@ -684,7 +688,7 @@ DWORD GetOffsetAtEndOfFunction(ULONGLONG uImageBase, #define DYNAMIC_HELPER_ALIGNMENT sizeof(TADDR) -#define BEGIN_DYNAMIC_HELPER_EMIT(size) \ +#define BEGIN_DYNAMIC_HELPER_EMIT_WORKER(size) \ SIZE_T cb = size; \ SIZE_T cbAligned = ALIGN_UP(cb, DYNAMIC_HELPER_ALIGNMENT); \ BYTE * pStartRX = (BYTE *)(void*)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(cbAligned, DYNAMIC_HELPER_ALIGNMENT); \ @@ -693,6 +697,14 @@ DWORD GetOffsetAtEndOfFunction(ULONGLONG uImageBase, size_t rxOffset = pStartRX - pStart; \ BYTE * p = pStart; +#ifdef FEATURE_PERFMAP +#define BEGIN_DYNAMIC_HELPER_EMIT(size) \ + BEGIN_DYNAMIC_HELPER_EMIT_WORKER(size) \ + PerfMap::LogStubs(__FUNCTION__, "DynamicHelper", (PCODE)p, size, PerfMapStubType::Individual); +#else +#define BEGIN_DYNAMIC_HELPER_EMIT(size) BEGIN_DYNAMIC_HELPER_EMIT_WORKER(size) +#endif + #define END_DYNAMIC_HELPER_EMIT() \ _ASSERTE(pStart + cb == p); \ while (p < pStart + cbAligned) *p++ = X86_INSTR_INT3; \ diff --git a/src/coreclr/vm/arm/stubs.cpp b/src/coreclr/vm/arm/stubs.cpp index 7ed01427790c04..cb665654d0cac4 100644 --- a/src/coreclr/vm/arm/stubs.cpp +++ b/src/coreclr/vm/arm/stubs.cpp @@ -25,6 +25,10 @@ #include "ecall.h" #include "threadsuspend.h" +#ifdef FEATURE_PERFMAP +#include "perfmap.h" +#endif + // target write barriers EXTERN_C void JIT_WriteBarrier(Object **dst, Object *ref); EXTERN_C void JIT_WriteBarrier_End(); @@ -1676,7 +1680,7 @@ void MovRegImm(BYTE* p, int reg, TADDR imm) #define DYNAMIC_HELPER_ALIGNMENT sizeof(TADDR) -#define BEGIN_DYNAMIC_HELPER_EMIT(size) \ +#define BEGIN_DYNAMIC_HELPER_EMIT_WORKER(size) \ SIZE_T cb = size; \ SIZE_T cbAligned = ALIGN_UP(cb, DYNAMIC_HELPER_ALIGNMENT); \ BYTE * pStartRX = (BYTE *)(void*)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(cbAligned, DYNAMIC_HELPER_ALIGNMENT); \ @@ -1685,6 +1689,15 @@ void MovRegImm(BYTE* p, int reg, TADDR imm) size_t rxOffset = pStartRX - pStart; \ BYTE * p = pStart; +#ifdef FEATURE_PERFMAP +#define BEGIN_DYNAMIC_HELPER_EMIT(size) \ + BEGIN_DYNAMIC_HELPER_EMIT_WORKER(size) \ + PerfMap::LogStubs(__FUNCTION__, "DynamicHelper", (PCODE)p, size, PerfMapStubType::Individual); +#else +#define BEGIN_DYNAMIC_HELPER_EMIT(size) BEGIN_DYNAMIC_HELPER_EMIT_WORKER(size) +#endif + + #define END_DYNAMIC_HELPER_EMIT() \ _ASSERTE(pStart + cb == p); \ while (p < pStart + cbAligned) { *(WORD *)p = 0xdefe; p += 2; } \ diff --git a/src/coreclr/vm/arm64/stubs.cpp b/src/coreclr/vm/arm64/stubs.cpp index 4e6a79dfa3b83f..a6695fb0895b1b 100644 --- a/src/coreclr/vm/arm64/stubs.cpp +++ b/src/coreclr/vm/arm64/stubs.cpp @@ -14,6 +14,9 @@ #include "jitinterface.h" #include "ecall.h" +#ifdef FEATURE_PERFMAP +#include "perfmap.h" +#endif #ifndef DACCESS_COMPILE //----------------------------------------------------------------------- @@ -1447,7 +1450,7 @@ void StubLinkerCPU::EmitCallManagedMethod(MethodDesc *pMD, BOOL fTailCall) #define DYNAMIC_HELPER_ALIGNMENT sizeof(TADDR) -#define BEGIN_DYNAMIC_HELPER_EMIT(size) \ +#define BEGIN_DYNAMIC_HELPER_EMIT_WORKER(size) \ SIZE_T cb = size; \ SIZE_T cbAligned = ALIGN_UP(cb, DYNAMIC_HELPER_ALIGNMENT); \ BYTE * pStartRX = (BYTE *)(void*)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(cbAligned, DYNAMIC_HELPER_ALIGNMENT); \ @@ -1456,6 +1459,15 @@ void StubLinkerCPU::EmitCallManagedMethod(MethodDesc *pMD, BOOL fTailCall) size_t rxOffset = pStartRX - pStart; \ BYTE * p = pStart; +#ifdef FEATURE_PERFMAP +#define BEGIN_DYNAMIC_HELPER_EMIT(size) \ + BEGIN_DYNAMIC_HELPER_EMIT_WORKER(size) \ + PerfMap::LogStubs(__FUNCTION__, "DynamicHelper", (PCODE)p, size, PerfMapStubType::Individual); +#else +#define BEGIN_DYNAMIC_HELPER_EMIT(size) BEGIN_DYNAMIC_HELPER_EMIT_WORKER(size) +#endif + + #define END_DYNAMIC_HELPER_EMIT() \ _ASSERTE(pStart + cb == p); \ while (p < pStart + cbAligned) { *(DWORD*)p = 0xBADC0DF0; p += 4; }\ diff --git a/src/coreclr/vm/ceemain.cpp b/src/coreclr/vm/ceemain.cpp index 5ab20a218d8ce5..8d39015b31fea3 100644 --- a/src/coreclr/vm/ceemain.cpp +++ b/src/coreclr/vm/ceemain.cpp @@ -735,6 +735,7 @@ void EEStartupHelper() #ifdef FEATURE_PERFMAP PerfMap::Initialize(); + InitThreadManagerPerfMapData(); #endif #ifdef FEATURE_PGO diff --git a/src/coreclr/vm/codeman.cpp b/src/coreclr/vm/codeman.cpp index ae338fc7a8345f..c54771f3a573db 100644 --- a/src/coreclr/vm/codeman.cpp +++ b/src/coreclr/vm/codeman.cpp @@ -2156,6 +2156,7 @@ TaggedMemAllocPtr CodeFragmentHeap::RealAllocAlignedMem(size_t dwRequestedSize if (dwSize < SMALL_BLOCK_THRESHOLD) dwSize = 4 * SMALL_BLOCK_THRESHOLD; pMem = ExecutionManager::GetEEJitManager()->allocCodeFragmentBlock(dwSize, dwAlignment, m_pAllocator, m_kind); + ReportStubBlock(pMem, dwSize, m_kind); } SIZE_T dwExtra = (BYTE *)ALIGN_UP(pMem, dwAlignment) - (BYTE *)pMem; @@ -3290,6 +3291,8 @@ JumpStubBlockHeader * EEJitManager::allocJumpStubBlock(MethodDesc* pMD, DWORD n _ASSERTE(IS_ALIGNED(blockWriterHolder.GetRW(), CODE_SIZE_ALIGN)); } + ReportStubBlock((void*)mem, blockSize, STUB_CODE_BLOCK_JUMPSTUB); + blockWriterHolder.GetRW()->m_next = NULL; blockWriterHolder.GetRW()->m_used = 0; blockWriterHolder.GetRW()->m_allocated = numJumps; @@ -5689,7 +5692,7 @@ PCODE ExecutionManager::getNextJumpStub(MethodDesc* pMD, PCODE target, emitBackToBackJump(jumpStub, jumpStubRW, (void*) target); #ifdef FEATURE_PERFMAP - PerfMap::LogStubs(__FUNCTION__, "emitBackToBackJump", (PCODE)jumpStub, BACK_TO_BACK_JUMP_ALLOCATE_SIZE); + PerfMap::LogStubs(__FUNCTION__, "emitBackToBackJump", (PCODE)jumpStub, BACK_TO_BACK_JUMP_ALLOCATE_SIZE, PerfMapStubType::IndividualWithinBlock); #endif // We always add the new jumpstub to the jumpStubCache diff --git a/src/coreclr/vm/codeman.h b/src/coreclr/vm/codeman.h index f3398988f125c2..986ad82abd3dba 100644 --- a/src/coreclr/vm/codeman.h +++ b/src/coreclr/vm/codeman.h @@ -88,6 +88,7 @@ class EECodeInfo; #define ROUND_DOWN_TO_PAGE(x) ( (size_t) (x) & ~((size_t)GetOsPageSize()-1)) #define ROUND_UP_TO_PAGE(x) (((size_t) (x) + (GetOsPageSize()-1)) & ~((size_t)GetOsPageSize()-1)) + enum StubCodeBlockKind : int { STUB_CODE_BLOCK_UNKNOWN = 0, @@ -112,6 +113,44 @@ enum StubCodeBlockKind : int STUB_CODE_BLOCK_METHOD_CALL_THUNK = 0x13, }; +inline const char *GetStubCodeBlockKindString(StubCodeBlockKind kind) +{ + switch (kind) + { + case STUB_CODE_BLOCK_JUMPSTUB: + return "JumpStub"; + case STUB_CODE_BLOCK_STUBLINK: + return "StubLinkStub"; + case STUB_CODE_BLOCK_MANAGED: + return "Managed"; + case STUB_CODE_BLOCK_METHOD_CALL_THUNK: + return "MethodCallThunk"; + case STUB_CODE_BLOCK_DYNAMICHELPER: + return "MethodCallThunk"; + case STUB_CODE_BLOCK_FIXUPPRECODE: + return "MethodCallThunk"; +#ifdef FEATURE_VIRTUAL_STUB_DISPATCH + case STUB_CODE_BLOCK_VSD_DISPATCH_STUB: + return "VSD_DispatchStub"; + case STUB_CODE_BLOCK_VSD_RESOLVE_STUB: + return "VSD_ResolveStub"; + case STUB_CODE_BLOCK_VSD_LOOKUP_STUB: + return "VSD_LookupStub"; + case STUB_CODE_BLOCK_VSD_VTABLE_STUB: + return "VSD_VTableStub"; +#endif // FEATURE_VIRTUAL_STUB_DISPATCH + default: + return "Unknown"; + } +} + +void ReportStubBlock(void* start, size_t size, StubCodeBlockKind kind); +#ifndef FEATURE_PERFMAP +inline void ReportStubBlock(void* start, size_t size, StubCodeBlockKind kind) +{ +} +#endif + //----------------------------------------------------------------------------- // Method header which exists just before the code. // Every IJitManager could have its own format for the header. diff --git a/src/coreclr/vm/comdelegate.cpp b/src/coreclr/vm/comdelegate.cpp index e9b0fc09ec055f..cdc89f491641b3 100644 --- a/src/coreclr/vm/comdelegate.cpp +++ b/src/coreclr/vm/comdelegate.cpp @@ -913,7 +913,7 @@ static PCODE SetupShuffleThunk(MethodTable * pDelMT, MethodDesc *pTargetMeth) pShuffleThunkCache = ((AssemblyLoaderAllocator*)pLoaderAllocator)->GetShuffleThunkCache(); } - pShuffleThunk = pShuffleThunkCache->Canonicalize((const BYTE *)&rShuffleEntryArray[0]); + pShuffleThunk = pShuffleThunkCache->Canonicalize((const BYTE *)&rShuffleEntryArray[0], "DelegateShuffleThunk"); } else { diff --git a/src/coreclr/vm/dllimportcallback.cpp b/src/coreclr/vm/dllimportcallback.cpp index f9e3ea038d99a8..49648a9b5e8a40 100644 --- a/src/coreclr/vm/dllimportcallback.cpp +++ b/src/coreclr/vm/dllimportcallback.cpp @@ -20,6 +20,9 @@ #include "stubgen.h" #include "appdomain.inl" +#ifdef FEATURE_PERFMAP +#include "perfmap.h" +#endif struct UM2MThunk_Args { @@ -249,6 +252,9 @@ UMEntryThunk* UMEntryThunk::CreateUMEntryThunk() UMEntryThunkData *pData = (UMEntryThunkData *)pamTracker->Track(pLoaderAllocator->GetLowFrequencyHeap()->AllocMem(S_SIZE_T(sizeof(UMEntryThunkData)))); p = (UMEntryThunk*)pamTracker->Track(pLoaderAllocator->GetNewStubPrecodeHeap()->AllocAlignedMem(size, 1)); +#ifdef FEATURE_PERFMAP + PerfMap::LogStubs(__FUNCTION__, "UMEntryThunk", (PCODE)p, size, PerfMapStubType::IndividualWithinBlock); +#endif pData->m_pUMEntryThunk = p; p->Init(p, dac_cast(pData), NULL, dac_cast(PRECODE_UMENTRY_THUNK)); pamTracker->SuppressRelease(); diff --git a/src/coreclr/vm/i386/cgenx86.cpp b/src/coreclr/vm/i386/cgenx86.cpp index 27384caffcf751..91a274afa48b78 100644 --- a/src/coreclr/vm/i386/cgenx86.cpp +++ b/src/coreclr/vm/i386/cgenx86.cpp @@ -39,6 +39,10 @@ #include "stublink.inl" +#ifdef FEATURE_PERFMAP +#include "perfmap.h" +#endif + // NOTE on Frame Size C_ASSERT usage in this file // if the frame size changes then the stubs have to be revisited for correctness // kindly revist the logic and then update the constants so that the C_ASSERT will again fire @@ -940,7 +944,7 @@ void ResumeAtJit(PCONTEXT pContext, LPVOID oldESP) #define DYNAMIC_HELPER_ALIGNMENT sizeof(TADDR) -#define BEGIN_DYNAMIC_HELPER_EMIT(size) \ +#define BEGIN_DYNAMIC_HELPER_EMIT_WORKER(size) \ SIZE_T cb = size; \ SIZE_T cbAligned = ALIGN_UP(cb, DYNAMIC_HELPER_ALIGNMENT); \ BYTE * pStartRX = (BYTE *)(void*)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(cbAligned, DYNAMIC_HELPER_ALIGNMENT); \ @@ -949,6 +953,14 @@ void ResumeAtJit(PCONTEXT pContext, LPVOID oldESP) size_t rxOffset = pStartRX - pStart; \ BYTE * p = pStart; +#ifdef FEATURE_PERFMAP +#define BEGIN_DYNAMIC_HELPER_EMIT(size) \ + BEGIN_DYNAMIC_HELPER_EMIT_WORKER(size) \ + PerfMap::LogStubs(__FUNCTION__, "DynamicHelper", (PCODE)p, size, PerfMapStubType::Individual); +#else +#define BEGIN_DYNAMIC_HELPER_EMIT(size) BEGIN_DYNAMIC_HELPER_EMIT_WORKER(size) +#endif + #define END_DYNAMIC_HELPER_EMIT() \ _ASSERTE(pStart + cb == p); \ while (p < pStart + cbAligned) *p++ = X86_INSTR_INT3; \ diff --git a/src/coreclr/vm/i386/jitinterfacex86.cpp b/src/coreclr/vm/i386/jitinterfacex86.cpp index ba5273606fedcd..63d603e722513d 100644 --- a/src/coreclr/vm/i386/jitinterfacex86.cpp +++ b/src/coreclr/vm/i386/jitinterfacex86.cpp @@ -366,7 +366,7 @@ void *JIT_TrialAlloc::GenAllocSFast(Flags flags) // Jump to the framed helper sl.X86EmitNearJump(sl.NewExternalCodeLabel((LPVOID)JIT_New)); - Stub *pStub = sl.Link(SystemDomain::GetGlobalLoaderAllocator()->GetExecutableHeap()); + Stub *pStub = sl.Link(SystemDomain::GetGlobalLoaderAllocator()->GetExecutableHeap(), NEWSTUB_FL_NONE, "AllocSFast"); return (void *)pStub->GetEntryPoint(); } @@ -498,7 +498,7 @@ void *JIT_TrialAlloc::GenBox(Flags flags) // Jump to the slow version of JIT_Box sl.X86EmitNearJump(sl.NewExternalCodeLabel((LPVOID) JIT_Box)); - Stub *pStub = sl.Link(SystemDomain::GetGlobalLoaderAllocator()->GetExecutableHeap()); + Stub *pStub = sl.Link(SystemDomain::GetGlobalLoaderAllocator()->GetExecutableHeap(), NEWSTUB_FL_NONE, "Box"); return (void *)pStub->GetEntryPoint(); } @@ -656,7 +656,7 @@ void *JIT_TrialAlloc::GenAllocArray(Flags flags) _ASSERTE(target->e.m_pExternalAddress); sl.X86EmitNearJump(target); - Stub *pStub = sl.Link(SystemDomain::GetGlobalLoaderAllocator()->GetExecutableHeap()); + Stub *pStub = sl.Link(SystemDomain::GetGlobalLoaderAllocator()->GetExecutableHeap(), NEWSTUB_FL_NONE, "AllocArray"); return (void *)pStub->GetEntryPoint(); } @@ -744,7 +744,7 @@ void *JIT_TrialAlloc::GenAllocString(Flags flags) CodeLabel * target = sl.NewExternalCodeLabel((LPVOID)FramedAllocateString); sl.X86EmitNearJump(target); - Stub *pStub = sl.Link(SystemDomain::GetGlobalLoaderAllocator()->GetExecutableHeap()); + Stub *pStub = sl.Link(SystemDomain::GetGlobalLoaderAllocator()->GetExecutableHeap(), NEWSTUB_FL_NONE, "AllocString"); return (void *)pStub->GetEntryPoint(); } diff --git a/src/coreclr/vm/loaderallocator.hpp b/src/coreclr/vm/loaderallocator.hpp index 82f0546ee1e80b..71d8f95b6675d8 100644 --- a/src/coreclr/vm/loaderallocator.hpp +++ b/src/coreclr/vm/loaderallocator.hpp @@ -80,6 +80,7 @@ class CodeRangeMapRangeList : public RangeList #ifndef DACCESS_COMPILE void AddRangeWorkerHelper(TADDR start, TADDR end, void* id) { + ReportStubBlock((void*)start, (size_t)(end - start), _rangeListType); SimpleWriteLockHolder lh(&_RangeListRWLock); _ASSERTE(id == _id || _id == NULL); diff --git a/src/coreclr/vm/loongarch64/stubs.cpp b/src/coreclr/vm/loongarch64/stubs.cpp index b126073279136c..920a2d892aa0b2 100644 --- a/src/coreclr/vm/loongarch64/stubs.cpp +++ b/src/coreclr/vm/loongarch64/stubs.cpp @@ -14,7 +14,9 @@ #include "jitinterface.h" #include "ecall.h" - +#ifdef FEATURE_PERFMAP +#include "perfmap.h" +#endif #ifndef DACCESS_COMPILE //----------------------------------------------------------------------- @@ -1314,7 +1316,7 @@ void StubLinkerCPU::EmitCallManagedMethod(MethodDesc *pMD, BOOL fTailCall) #define DYNAMIC_HELPER_ALIGNMENT sizeof(TADDR) -#define BEGIN_DYNAMIC_HELPER_EMIT(size) \ +#define BEGIN_DYNAMIC_HELPER_EMIT_WORKER(size) \ SIZE_T cb = size; \ SIZE_T cbAligned = ALIGN_UP(cb, DYNAMIC_HELPER_ALIGNMENT); \ BYTE * pStartRX = (BYTE *)(void*)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(cbAligned, DYNAMIC_HELPER_ALIGNMENT); \ @@ -1323,6 +1325,14 @@ void StubLinkerCPU::EmitCallManagedMethod(MethodDesc *pMD, BOOL fTailCall) size_t rxOffset = pStartRX - pStart; \ BYTE * p = pStart; +#ifdef FEATURE_PERFMAP +#define BEGIN_DYNAMIC_HELPER_EMIT(size) \ + BEGIN_DYNAMIC_HELPER_EMIT_WORKER(size) \ + PerfMap::LogStubs(__FUNCTION__, "DynamicHelper", (PCODE)p, size, PerfMapStubType::Individual); +#else +#define BEGIN_DYNAMIC_HELPER_EMIT(size) BEGIN_DYNAMIC_HELPER_EMIT_WORKER(size) +#endif + #define END_DYNAMIC_HELPER_EMIT() \ _ASSERTE(pStart + cb == p); \ while (p < pStart + cbAligned) { *(DWORD*)p = 0xffffff0f/*badcode*/; p += 4; }\ diff --git a/src/coreclr/vm/perfmap.cpp b/src/coreclr/vm/perfmap.cpp index e3892bd1018f6c..dc9a274f0defa7 100644 --- a/src/coreclr/vm/perfmap.cpp +++ b/src/coreclr/vm/perfmap.cpp @@ -29,9 +29,17 @@ Volatile PerfMap::s_enabled = false; PerfMap * PerfMap::s_Current = nullptr; bool PerfMap::s_ShowOptimizationTiers = false; +bool PerfMap::s_GroupStubsOfSameType = false; +bool PerfMap::s_IndividualAllocationStubReporting = false; + unsigned PerfMap::s_StubsMapped = 0; CrstStatic PerfMap::s_csPerfMap; +bool PerfMapLowGranularityStubs() +{ + return PerfMap::LowGranularityStubs(); +} + // Initialize the map for the process - called from EEStartupHelper. void PerfMap::Initialize() { @@ -57,6 +65,18 @@ const char * PerfMap::InternalConstructPath() return TEMP_DIRECTORY_PATH; } +void PerfMap::InitializeConfiguration() +{ + if (CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_PerfMapShowOptimizationTiers) != 0) + { + s_ShowOptimizationTiers = true; + } + + DWORD granularity = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_PerfMapStubGranularity); + s_GroupStubsOfSameType = (granularity & 1) != 1; + s_IndividualAllocationStubReporting = (granularity & 2) != 0; +} + void PerfMap::Enable(PerfMapType type, bool sendExisting) { LIMITED_METHOD_CONTRACT; @@ -81,10 +101,7 @@ void PerfMap::Enable(PerfMapType type, bool sendExisting) PAL_IgnoreProfileSignal(signalNum); } - if (CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_PerfMapShowOptimizationTiers) != 0) - { - s_ShowOptimizationTiers = true; - } + InitializeConfiguration(); int currentPid = GetCurrentProcessId(); s_Current->OpenFileForPid(currentPid, basePath); @@ -95,10 +112,7 @@ void PerfMap::Enable(PerfMapType type, bool sendExisting) { PAL_PerfJitDump_Start(basePath); - if (CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_PerfMapShowOptimizationTiers) != 0) - { - s_ShowOptimizationTiers = true; - } + InitializeConfiguration(); s_enabled = true; } @@ -379,7 +393,7 @@ void PerfMap::LogPreCompiledMethod(MethodDesc * pMethod, PCODE pCode) } // Log a set of stub to the map. -void PerfMap::LogStubs(const char* stubType, const char* stubOwner, PCODE pCode, size_t codeSize) +void PerfMap::LogStubs(const char* stubType, const char* stubOwner, PCODE pCode, size_t codeSize, PerfMapStubType stubAllocationType) { LIMITED_METHOD_CONTRACT; @@ -388,6 +402,14 @@ void PerfMap::LogStubs(const char* stubType, const char* stubOwner, PCODE pCode, return; } + if (stubAllocationType != PerfMapStubType::Individual) + { + if ((stubAllocationType == PerfMapStubType::IndividualWithinBlock) != s_IndividualAllocationStubReporting) + { + return; + } + } + // Logging failures should not cause any exceptions to flow upstream. EX_TRY { @@ -402,7 +424,14 @@ void PerfMap::LogStubs(const char* stubType, const char* stubOwner, PCODE pCode, SString name; // Build the map file line. - name.Printf("stub<%d> %s<%s>", ++(s_StubsMapped), stubType, stubOwner); + if (s_GroupStubsOfSameType) + { + name.Printf("stub %s<%s>", stubType, stubOwner); + } + else + { + name.Printf("stub<%d> %s<%s>", ++(s_StubsMapped), stubType, stubOwner); + } SString line; line.Printf(FMT_CODE_ADDR " %x %s\n", pCode, codeSize, name.GetUTF8()); @@ -434,4 +463,12 @@ void PerfMap::GetNativeImageSignature(PEAssembly * pPEAssembly, CHAR * pszSig, u pPEAssembly->GetMVID(&mvid); minipal_guid_as_string(mvid, pszSig, nSigSize); } + +void ReportStubBlock(void* start, size_t size, StubCodeBlockKind kind) +{ + WRAPPER_NO_CONTRACT; + + PerfMap::LogStubs(__FUNCTION__, GetStubCodeBlockKindString(kind), (PCODE)start, size, PerfMapStubType::Block); +} + #endif // FEATURE_PERFMAP && !DACCESS_COMPILE diff --git a/src/coreclr/vm/perfmap.h b/src/coreclr/vm/perfmap.h index f6eb8cfc73831b..6079d1fbc2e15d 100644 --- a/src/coreclr/vm/perfmap.h +++ b/src/coreclr/vm/perfmap.h @@ -11,6 +11,14 @@ #include "volatile.h" // Generates a perfmap file. + +enum class PerfMapStubType +{ + Block, + IndividualWithinBlock, + Individual +}; + class PerfMap { private: @@ -22,6 +30,10 @@ class PerfMap // Indicates whether optimization tiers should be shown for methods in perf maps static bool s_ShowOptimizationTiers; + // Indicate current stub granularity rules + static bool s_GroupStubsOfSameType; + static bool s_IndividualAllocationStubReporting; + // Set to true if an error is encountered when writing to the file. static unsigned s_StubsMapped; @@ -45,6 +57,8 @@ class PerfMap // Default to /tmp or use DOTNET_PerfMapJitDumpPath if set static const char* InternalConstructPath(); + static void InitializeConfiguration(); + protected: // Open the perf map file for write. void OpenFile(SString& path); @@ -85,9 +99,11 @@ class PerfMap static void LogPreCompiledMethod(MethodDesc * pMethod, PCODE pCode); // Log a set of stub to the map. - static void LogStubs(const char* stubType, const char* stubOwner, PCODE pCode, size_t codeSize); + static void LogStubs(const char* stubType, const char* stubOwner, PCODE pCode, size_t codeSize, PerfMapStubType stubAllocationType); // Close the map and flush any remaining data. static void Disable(); + + static bool LowGranularityStubs() { return !s_IndividualAllocationStubReporting; } }; #endif // PERFPID_H diff --git a/src/coreclr/vm/precode.cpp b/src/coreclr/vm/precode.cpp index f462883881a86f..ef120e400c71b6 100644 --- a/src/coreclr/vm/precode.cpp +++ b/src/coreclr/vm/precode.cpp @@ -225,6 +225,9 @@ InterpreterPrecode* Precode::AllocateInterpreterPrecode(PCODE byteCode, SIZE_T size = sizeof(InterpreterPrecode); InterpreterPrecode* pPrecode = (InterpreterPrecode*)pamTracker->Track(pLoaderAllocator->GetNewStubPrecodeHeap()->AllocAlignedMem(size, 1)); pPrecode->Init(pPrecode, byteCode); +#ifdef FEATURE_PERFMAP + PerfMap::LogStubs(__FUNCTION__, "UMEntryThunk", (PCODE)pPrecode, size, PerfMapStubType::IndividualWithinBlock); +#endif return pPrecode; } #endif // FEATURE_INTERPRETER @@ -247,6 +250,9 @@ Precode* Precode::Allocate(PrecodeType t, MethodDesc* pMD, { pPrecode = (Precode*)pamTracker->Track(pLoaderAllocator->GetFixupPrecodeHeap()->AllocAlignedMem(sizeof(FixupPrecode), 1)); pPrecode->Init(pPrecode, t, pMD, pLoaderAllocator); +#ifdef FEATURE_PERFMAP + PerfMap::LogStubs(__FUNCTION__, "FixupPrecode", (PCODE)pPrecode, sizeof(FixupPrecode), PerfMapStubType::IndividualWithinBlock); +#endif } #ifdef HAS_THISPTR_RETBUF_PRECODE else if (t == PRECODE_THISPTR_RETBUF) @@ -255,13 +261,19 @@ Precode* Precode::Allocate(PrecodeType t, MethodDesc* pMD, ThisPtrRetBufPrecodeData *pData = (ThisPtrRetBufPrecodeData*)pamTracker->Track(pLoaderAllocator->GetLowFrequencyHeap()->AllocMem(S_SIZE_T(sizeof(ThisPtrRetBufPrecodeData)))); pThisPtrRetBufPrecode->Init(pData, pMD, pLoaderAllocator); pPrecode = (Precode*)pThisPtrRetBufPrecode; - } +#ifdef FEATURE_PERFMAP + PerfMap::LogStubs(__FUNCTION__, "ThisPtrRetBuf", (PCODE)pPrecode, sizeof(ThisPtrRetBufPrecodeData), PerfMapStubType::IndividualWithinBlock); +#endif + } #endif // HAS_THISPTR_RETBUF_PRECODE else { _ASSERTE(t == PRECODE_STUB || t == PRECODE_NDIRECT_IMPORT); pPrecode = (Precode*)pamTracker->Track(pLoaderAllocator->GetNewStubPrecodeHeap()->AllocAlignedMem(sizeof(StubPrecode), 1)); pPrecode->Init(pPrecode, t, pMD, pLoaderAllocator); +#ifdef FEATURE_PERFMAP + PerfMap::LogStubs(__FUNCTION__, t == PRECODE_STUB ? "StubPrecode" : "PInvokeImportPrecode", (PCODE)pPrecode, sizeof(StubPrecode), PerfMapStubType::IndividualWithinBlock); +#endif } return pPrecode; diff --git a/src/coreclr/vm/prestub.cpp b/src/coreclr/vm/prestub.cpp index 6d6cb67a3c5be0..dc9dbeeace5d88 100644 --- a/src/coreclr/vm/prestub.cpp +++ b/src/coreclr/vm/prestub.cpp @@ -1653,7 +1653,7 @@ Stub * MakeUnboxingStubWorker(MethodDesc *pMD) sl.EmitComputedInstantiatingMethodStub(pUnboxedMD, &portableShuffle[0], NULL); - pstub = sl.Link(pMD->GetLoaderAllocator()->GetStubHeap(), NEWSTUB_FL_INSTANTIATING_METHOD); + pstub = sl.Link(pMD->GetLoaderAllocator()->GetStubHeap(), NEWSTUB_FL_INSTANTIATING_METHOD, "UnboxingStub"); } else #endif @@ -1674,7 +1674,7 @@ Stub * MakeUnboxingStubWorker(MethodDesc *pMD) { CPUSTUBLINKER sl; sl.EmitUnboxMethodStub(pUnboxedMD); - pstub = sl.Link(pMD->GetLoaderAllocator()->GetStubHeap()); + pstub = sl.Link(pMD->GetLoaderAllocator()->GetStubHeap(), NEWSTUB_FL_NONE, "UnboxingStub"); } #endif // !FEATURE_PORTABLE_SHUFFLE_THUNKS } @@ -1726,7 +1726,7 @@ Stub * MakeInstantiatingStubWorker(MethodDesc *pMD) _ASSERTE(pSharedMD != NULL && pSharedMD != pMD); sl.EmitComputedInstantiatingMethodStub(pSharedMD, &portableShuffle[0], extraArg); - pstub = sl.Link(pMD->GetLoaderAllocator()->GetStubHeap(), NEWSTUB_FL_INSTANTIATING_METHOD); + pstub = sl.Link(pMD->GetLoaderAllocator()->GetStubHeap(), NEWSTUB_FL_INSTANTIATING_METHOD, "InstantiatingStub"); } else #endif @@ -1738,7 +1738,7 @@ Stub * MakeInstantiatingStubWorker(MethodDesc *pMD) _ASSERTE(pSharedMD != NULL && pSharedMD != pMD); sl.EmitInstantiatingMethodStub(pSharedMD, extraArg); - pstub = sl.Link(pMD->GetLoaderAllocator()->GetStubHeap()); + pstub = sl.Link(pMD->GetLoaderAllocator()->GetStubHeap(), NEWSTUB_FL_NONE, "InstantiatingStub"); #endif } diff --git a/src/coreclr/vm/readytoruninfo.cpp b/src/coreclr/vm/readytoruninfo.cpp index 487676d3ba2c40..d6bc540651e0c1 100644 --- a/src/coreclr/vm/readytoruninfo.cpp +++ b/src/coreclr/vm/readytoruninfo.cpp @@ -17,6 +17,10 @@ #include "wellknownattributes.h" #include "nativeimage.h" +#ifdef FEATURE_PERFMAP +#include "perfmap.h" +#endif + #ifndef DACCESS_COMPILE extern "C" PCODE g_pMethodWithSlotAndModule; extern "C" PCODE g_pClassWithSlotAndModule; @@ -1995,6 +1999,11 @@ PCODE CreateDynamicHelperPrecode(LoaderAllocator *pAllocator, AllocMemTracker *p size_t size = sizeof(StubPrecode); StubPrecode *pPrecode = (StubPrecode *)pamTracker->Track(pAllocator->GetDynamicHelpersStubHeap()->AllocAlignedMem(size, 1)); pPrecode->Init(pPrecode, DynamicHelperArg, pAllocator, PRECODE_DYNAMIC_HELPERS, DynamicHelper); + +#ifdef FEATURE_PERFMAP + PerfMap::LogStubs(__FUNCTION__, "DynamicHelper", (PCODE)pPrecode, size, PerfMapStubType::IndividualWithinBlock); +#endif + return ((Precode*)pPrecode)->GetEntryPoint(); } diff --git a/src/coreclr/vm/riscv64/stubs.cpp b/src/coreclr/vm/riscv64/stubs.cpp index 20e7c20142f14f..5a2928efac970b 100644 --- a/src/coreclr/vm/riscv64/stubs.cpp +++ b/src/coreclr/vm/riscv64/stubs.cpp @@ -14,6 +14,9 @@ #include "jitinterface.h" #include "ecall.h" +#ifdef FEATURE_PERFMAP +#include "perfmap.h" +#endif #ifndef DACCESS_COMPILE //----------------------------------------------------------------------- @@ -1285,7 +1288,7 @@ void StubLinkerCPU::EmitCallManagedMethod(MethodDesc *pMD, BOOL fTailCall) // #define DYNAMIC_HELPER_ALIGNMENT sizeof(TADDR) -#define BEGIN_DYNAMIC_HELPER_EMIT(size) \ +#define BEGIN_DYNAMIC_HELPER_EMIT_WORKER(size) \ SIZE_T cb = size; \ SIZE_T cbAligned = ALIGN_UP(cb, DYNAMIC_HELPER_ALIGNMENT); \ BYTE * pStartRX = (BYTE *)(void*)pAllocator->GetDynamicHelpersHeap()->AllocAlignedMem(cbAligned, DYNAMIC_HELPER_ALIGNMENT); \ @@ -1294,6 +1297,14 @@ void StubLinkerCPU::EmitCallManagedMethod(MethodDesc *pMD, BOOL fTailCall) size_t rxOffset = pStartRX - pStart; \ BYTE * p = pStart; +#ifdef FEATURE_PERFMAP +#define BEGIN_DYNAMIC_HELPER_EMIT(size) \ + BEGIN_DYNAMIC_HELPER_EMIT_WORKER(size) \ + PerfMap::LogStubs(__FUNCTION__, "DynamicHelper", (PCODE)p, size, PerfMapStubType::Individual); +#else +#define BEGIN_DYNAMIC_HELPER_EMIT(size) BEGIN_DYNAMIC_HELPER_EMIT_WORKER(size) +#endif + #define END_DYNAMIC_HELPER_EMIT() \ _ASSERTE(pStart + cb == p); \ while (p < pStart + cbAligned) { *(DWORD*)p = 0xffffff0f/*badcode*/; p += 4; }\ diff --git a/src/coreclr/vm/stubcache.cpp b/src/coreclr/vm/stubcache.cpp index 44e093a9c1a431..705c518a3e23cb 100644 --- a/src/coreclr/vm/stubcache.cpp +++ b/src/coreclr/vm/stubcache.cpp @@ -75,7 +75,7 @@ StubCacheBase::~StubCacheBase() // The caller is responsible for DecRef'ing the returned stub in // order to avoid leaks. //--------------------------------------------------------- -Stub *StubCacheBase::Canonicalize(const BYTE * pRawStub) +Stub *StubCacheBase::Canonicalize(const BYTE * pRawStub, const char *stubType) { CONTRACT (Stub*) { @@ -115,7 +115,7 @@ Stub *StubCacheBase::Canonicalize(const BYTE * pRawStub) CodeLabel *plabel = psl->EmitNewCodeLabel(); psl->EmitBytes(pRawStub, Length(pRawStub)); StubHolder pstub; - pstub = psl->Link(m_heap, linkFlags); + pstub = psl->Link(m_heap, linkFlags, stubType); UINT32 offset = psl->GetLabelOffset(plabel); if (offset > 0xffff) diff --git a/src/coreclr/vm/stubcache.h b/src/coreclr/vm/stubcache.h index d35110c76b018a..0eeebdfb6c0b89 100644 --- a/src/coreclr/vm/stubcache.h +++ b/src/coreclr/vm/stubcache.h @@ -57,7 +57,7 @@ class StubCacheBase : private CClosedHashBase // // Throws on out of memory or other fatal error. //--------------------------------------------------------- - Stub *Canonicalize(const BYTE *pRawStub); + Stub *Canonicalize(const BYTE *pRawStub, const char *stubType); protected: //--------------------------------------------------------- diff --git a/src/coreclr/vm/stublink.cpp b/src/coreclr/vm/stublink.cpp index 9b47d00e2e9962..7d62f1206f17c0 100644 --- a/src/coreclr/vm/stublink.cpp +++ b/src/coreclr/vm/stublink.cpp @@ -16,6 +16,10 @@ #include "rtlfunctions.h" +#ifdef FEATURE_PERFMAP +#include "perfmap.h" +#endif + #define S_BYTEPTR(x) S_SIZE_T((SIZE_T)(x)) #ifndef DACCESS_COMPILE @@ -558,7 +562,7 @@ static BOOL LabelCanReach(LabelRef *pLabelRef) // // Throws exception on failure. //--------------------------------------------------------------- -Stub *StubLinker::Link(LoaderHeap *pHeap, DWORD flags) +Stub *StubLinker::Link(LoaderHeap *pHeap, DWORD flags, const char *stubType) { STANDARD_VM_CONTRACT; @@ -575,6 +579,10 @@ Stub *StubLinker::Link(LoaderHeap *pHeap, DWORD flags) EmitStub(pStub, globalsize, size, pHeap); +#ifdef FEATURE_PERFMAP + PerfMap::LogStubs(__FUNCTION__, stubType, pStub->GetEntryPoint(), pStub->GetNumCodeBytes(), PerfMapStubType::Individual); +#endif + return pStub.Extract(); } diff --git a/src/coreclr/vm/stublink.h b/src/coreclr/vm/stublink.h index 2fcbad8e700c38..cb83cda5c3e9fb 100644 --- a/src/coreclr/vm/stublink.h +++ b/src/coreclr/vm/stublink.h @@ -181,7 +181,7 @@ class StubLinker // // Throws exception on failure. //--------------------------------------------------------------- - Stub *Link(LoaderHeap *heap, DWORD flags = 0); + Stub *Link(LoaderHeap *heap, DWORD flags, const char *stubType); private: CodeElement *m_pCodeElements; // stored in *reverse* order diff --git a/src/coreclr/vm/threads.cpp b/src/coreclr/vm/threads.cpp index a21064d019b663..96f2a4e9945af8 100644 --- a/src/coreclr/vm/threads.cpp +++ b/src/coreclr/vm/threads.cpp @@ -48,6 +48,10 @@ #include #endif +#ifdef FEATURE_PERFMAP +#include "perfmap.h" +#endif + static const PortableTailCallFrame g_sentinelTailCallFrame = { NULL, NULL }; TailCallTls::TailCallTls() @@ -1037,6 +1041,22 @@ static void SetIlsIndex(DWORD tlsIndex) #pragma optimize("", on) #endif +void InitThreadManagerPerfMapData() +{ + CONTRACTL { + THROWS; + GC_TRIGGERS; + } + CONTRACTL_END; +#ifdef FEATURE_PERFMAP + if (IsWriteBarrierCopyEnabled()) + { + size_t writeBarrierSize = (BYTE*)JIT_PatchedCodeLast - (BYTE*)JIT_PatchedCodeStart; + PerfMap::LogStubs(__FUNCTION__, "JIT_CopiedWriteBarriers", (PCODE)s_barrierCopy, writeBarrierSize, PerfMapStubType::Individual); + } +#endif +} + //--------------------------------------------------------------------------- // One-time initialization. Called during Dll initialization. So // be careful what you do in here! @@ -1069,6 +1089,9 @@ void InitThreadManager() ExecutableWriterHolder barrierWriterHolder(s_barrierCopy, writeBarrierSize); memcpy(barrierWriterHolder.GetRW(), (BYTE*)JIT_PatchedCodeStart, writeBarrierSize); } +#ifdef FEATURE_PERFMAP + // We would log the to the perfmap here, but its not yet initialized +#endif // Store the JIT_WriteBarrier copy location to a global variable so that helpers // can jump to it. diff --git a/src/coreclr/vm/threads.h b/src/coreclr/vm/threads.h index 42d7f7ec29954e..e263d473e1ab3e 100644 --- a/src/coreclr/vm/threads.h +++ b/src/coreclr/vm/threads.h @@ -349,7 +349,7 @@ DWORD GetRuntimeId(); // One-time initialization. Called during Dll initialization. //--------------------------------------------------------------------------- void InitThreadManager(); - +void InitThreadManagerPerfMapData(); // When we want to take control of a thread at a safe point, the thread will // eventually come back to us in one of the following trip functions: diff --git a/src/coreclr/vm/virtualcallstub.cpp b/src/coreclr/vm/virtualcallstub.cpp index 93355855e2520c..f204003556e465 100644 --- a/src/coreclr/vm/virtualcallstub.cpp +++ b/src/coreclr/vm/virtualcallstub.cpp @@ -1204,7 +1204,7 @@ VTableCallHolder* VirtualCallStubManager::GenerateVTableCallStub(DWORD slot) DBG_ADDR(slot), DBG_ADDR(pHolder->stub()))); #ifdef FEATURE_PERFMAP - PerfMap::LogStubs(__FUNCTION__, "GenerateVTableCallStub", (PCODE)pHolder->stub(), pHolder->stub()->size()); + PerfMap::LogStubs(__FUNCTION__, "GenerateVTableCallStub", (PCODE)pHolder->stub(), pHolder->stub()->size(), PerfMapStubType::IndividualWithinBlock); #endif RETURN(pHolder); @@ -2870,7 +2870,7 @@ DispatchHolder *VirtualCallStubManager::GenerateDispatchStub(PCODE ad DBG_ADDR(dispatchToken), DBG_ADDR(pMTExpected), DBG_ADDR(holder->stub()))); #ifdef FEATURE_PERFMAP - PerfMap::LogStubs(__FUNCTION__, "GenerateDispatchStub", (PCODE)holder->stub(), holder->stub()->size()); + PerfMap::LogStubs(__FUNCTION__, "GenerateDispatchStub", (PCODE)holder->stub(), holder->stub()->size(), PerfMapStubType::IndividualWithinBlock); #endif RETURN (holder); @@ -2931,7 +2931,7 @@ DispatchHolder *VirtualCallStubManager::GenerateDispatchStubLong(PCODE DBG_ADDR(dispatchToken), DBG_ADDR(pMTExpected), DBG_ADDR(holder->stub()))); #ifdef FEATURE_PERFMAP - PerfMap::LogStubs(__FUNCTION__, "GenerateDispatchStub", (PCODE)holder->stub(), holder->stub()->size()); + PerfMap::LogStubs(__FUNCTION__, "GenerateDispatchStub", (PCODE)holder->stub(), holder->stub()->size(), PerfMapStubType::IndividualWithinBlock); #endif RETURN (holder); @@ -3029,7 +3029,7 @@ ResolveHolder *VirtualCallStubManager::GenerateResolveStub(PCODE addr DBG_ADDR(dispatchToken), DBG_ADDR(holder->stub()))); #ifdef FEATURE_PERFMAP - PerfMap::LogStubs(__FUNCTION__, "GenerateResolveStub", (PCODE)holder->stub(), holder->stub()->size()); + PerfMap::LogStubs(__FUNCTION__, "GenerateResolveStub", (PCODE)holder->stub(), holder->stub()->size(), PerfMapStubType::IndividualWithinBlock); #endif RETURN (holder); @@ -3062,7 +3062,7 @@ LookupHolder *VirtualCallStubManager::GenerateLookupStub(PCODE addrOfResolver, s DBG_ADDR(dispatchToken), DBG_ADDR(holder->stub()))); #ifdef FEATURE_PERFMAP - PerfMap::LogStubs(__FUNCTION__, "GenerateLookupStub", (PCODE)holder->stub(), holder->stub()->size()); + PerfMap::LogStubs(__FUNCTION__, "GenerateLookupStub", (PCODE)holder->stub(), holder->stub()->size(), PerfMapStubType::IndividualWithinBlock); #endif RETURN (holder);