// Licensed to the .NET Foundation under one or more agreements.

// The .NET Foundation licenses this file to you under the MIT license.

// This file contains the virtual call stub manager and caches

#include "common.h"

#include "array.h"

#include "CachedInterfaceDispatchPal.h"

#include "CachedInterfaceDispatch.h"

#include "comdelegate.h"

#include <dn-stdio.h>

#ifdef FEATURE_PERFMAP

#include "perfmap.h"

#endif

#ifndef DACCESS_COMPILE

//@TODO: make these conditional on whether logs are being produced

//instrumentation counters

UINT32 g_site_counter = 0; //# of call sites

UINT32 g_site_write = 0; //# of call site backpatch writes

UINT32 g_site_write_poly = 0; //# of call site backpatch writes to point to resolve stubs

UINT32 g_site_write_mono = 0; //# of call site backpatch writes to point to dispatch stubs

UINT32 g_stub_lookup_counter = 0; //# of lookup stubs

UINT32 g_stub_mono_counter = 0; //# of dispatch stubs

UINT32 g_stub_poly_counter = 0; //# of resolve stubs

UINT32 g_stub_vtable_counter = 0; //# of vtable call stubs

UINT32 g_stub_space = 0; //# of bytes of stubs

UINT32 g_reclaim_counter = 0; //# of times a ReclaimAll was performed

UINT32 g_worker_call = 0; //# of calls into ResolveWorker

UINT32 g_worker_call_no_patch = 0;

UINT32 g_worker_collide_to_mono = 0; //# of times we converted a poly stub to a mono stub instead of writing the cache entry

UINT32 g_external_call = 0; //# of calls into GetTarget(token, pMT)

UINT32 g_external_call_no_patch = 0;

UINT32 g_insert_cache_external = 0; //# of times Insert was called for IK_EXTERNAL

UINT32 g_insert_cache_shared = 0; //# of times Insert was called for IK_SHARED

UINT32 g_insert_cache_dispatch = 0; //# of times Insert was called for IK_DISPATCH

UINT32 g_insert_cache_resolve = 0; //# of times Insert was called for IK_RESOLVE

UINT32 g_insert_cache_hit = 0; //# of times Insert found an empty cache entry

UINT32 g_insert_cache_miss = 0; //# of times Insert already had a matching cache entry

UINT32 g_insert_cache_collide = 0; //# of times Insert found a used cache entry

UINT32 g_insert_cache_write = 0; //# of times Insert wrote a cache entry

UINT32 g_cache_entry_counter = 0; //# of cache structs

UINT32 g_cache_entry_space = 0; //# of bytes used by cache lookup structs

UINT32 g_call_lookup_counter = 0; //# of times lookup stubs entered

UINT32 g_mono_call_counter = 0; //# of time dispatch stubs entered

UINT32 g_mono_miss_counter = 0; //# of times expected MT did not match actual MT (dispatch stubs)

UINT32 g_poly_call_counter = 0; //# of times resolve stubs entered

UINT32 g_poly_miss_counter = 0; //# of times cache missed (resolve stub)

EXTERN_C UINT32 g_chained_lookup_call_counter;

EXTERN_C UINT32 g_chained_lookup_miss_counter;

UINT32 g_chained_lookup_call_counter = 0; //# of hits in a chained lookup

UINT32 g_chained_lookup_miss_counter = 0; //# of misses in a chained lookup

UINT32 g_chained_lookup_external_call_counter = 0; //# of hits in an external chained lookup

UINT32 g_chained_lookup_external_miss_counter = 0; //# of misses in an external chained lookup

UINT32 g_chained_entry_promoted = 0; //# of times a cache entry is promoted to the start of the chain

UINT32 g_bucket_space = 0; //# of bytes in caches and tables, not including the stubs themselves

UINT32 g_bucket_space_dead = 0; //# of bytes of abandoned buckets not yet recycled

#endif // !DACCESS_COMPILE

// This is the number of times a successful chain lookup will occur before the

// entry is promoted to the front of the chain. This is declared as extern because

// the default value (CALL_STUB_CACHE_INITIAL_SUCCESS_COUNT) is defined in the header.

EXTERN_C size_t g_dispatch_cache_chain_success_counter;

#define DECLARE_DATA

#include "virtualcallstub.h"

#undef DECLARE_DATA

#include "profilepriv.h"

#include "contractimpl.h"

#include "dynamicinterfacecastable.h"

SPTR_IMPL_INIT(VirtualCallStubManagerManager, VirtualCallStubManagerManager, g_pManager, NULL);

#ifdef FEATURE_CACHED_INTERFACE_DISPATCH

struct CachedIndirectionCellBlockListNode

{

CachedIndirectionCellBlockListNode *m_pNext;

TADDR m_pFiller; // Used to ensure that the Indirection Cells are double pointer aligned

InterfaceDispatchCell m_rgIndCells[0];

};

#endif // FEATURE_CACHED_INTERFACE_DISPATCH

#ifndef DACCESS_COMPILE

BYTE* GenerateDispatchStubCellEntryMethodDesc(LoaderAllocator *pLoaderAllocator, TypeHandle ownerType, MethodDesc *pMD, LCGMethodResolver *pResolver)

{

return GenerateDispatchStubCellEntrySlot(pLoaderAllocator, ownerType, pMD->GetSlot(), pResolver);

}

BYTE* GenerateDispatchStubCellEntrySlot(LoaderAllocator *pLoaderAllocator, TypeHandle ownerType, int methodSlot, LCGMethodResolver *pResolver)

{

VirtualCallStubManager * pMgr = pLoaderAllocator->GetVirtualCallStubManager();

DispatchToken token = VirtualCallStubManager::GetTokenFromOwnerAndSlot(ownerType, methodSlot);

PCODE addr;

INTERFACE_DISPATCH_CACHED_OR_VSD(

addr = (PCODE)RhpInitialInterfaceDispatch // Always use the initial dispatch stub for cached interface dispatch

,

addr = pMgr->GetCallStub(token)) // Acquire a stub which is token specific in the VSD case

BYTE* indcell = pMgr->GenerateStubIndirection(addr, token, pResolver != NULL);

if (pResolver != NULL)

{

pResolver->AddToUsedIndCellList(indcell);

}

return indcell;

}

#ifdef STUB_LOGGING

UINT32 STUB_MISS_COUNT_VALUE = 100;

UINT32 STUB_COLLIDE_WRITE_PCT = 100;

UINT32 STUB_COLLIDE_MONO_PCT = 0;

#endif // STUB_LOGGING

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

FastTable::NumCallStubs_t FastTable::NumCallStubs;

FastTable* BucketTable::dead = NULL; //linked list of the abandoned buckets

DispatchCache *g_resolveCache = NULL; //cache of dispatch stubs for in line lookup by resolve stubs.

size_t g_dispatch_cache_chain_success_counter = CALL_STUB_CACHE_INITIAL_SUCCESS_COUNT;

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

#ifdef STUB_LOGGING

UINT32 g_resetCacheCounter;

UINT32 g_resetCacheIncr;

UINT32 g_dumpLogCounter;

UINT32 g_dumpLogIncr;

#endif // STUB_LOGGING

//@TODO: use the existing logging mechanisms. for now we write to a file.

FILE* g_hStubLogFile;

void VirtualCallStubManager::StartupLogging()

{

CONTRACTL

{

NOTHROW;

GC_TRIGGERS;

FORBID_FAULT;

}

CONTRACTL_END

GCX_PREEMP();

EX_TRY

{

FAULT_NOT_FATAL(); // We handle filecreation problems locally

SString str;

str.Printf("StubLog_%d.log", GetCurrentProcessId());

if (fopen_lp(&g_hStubLogFile, str.GetUnicode(), W("wb")) != 0)

g_hStubLogFile = NULL;

}

EX_CATCH

{

}

EX_END_CATCH

}

#define OUTPUT_FORMAT_INT "\t%-30s %d\r\n"

#define OUTPUT_FORMAT_SIZE "\t%-30s %zu\r\n"

#define OUTPUT_FORMAT_PCT "\t%-30s %#5.2f%%\r\n"

#define OUTPUT_FORMAT_INT_PCT "\t%-30s %5d (%#5.2f%%)\r\n"

void VirtualCallStubManager::LoggingDump()

{

CONTRACTL

{

NOTHROW;

GC_TRIGGERS;

FORBID_FAULT;

}

CONTRACTL_END

VirtualCallStubManagerIterator it =

VirtualCallStubManagerManager::GlobalManager()->IterateVirtualCallStubManagers();

while (it.Next())

{

it.Current()->LogStats();

}

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

g_resolveCache->LogStats();

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

if(g_hStubLogFile)

{

#ifdef STUB_LOGGING

fprintf(g_hStubLogFile, "\r\nstub tuning parameters\r\n");

fprintf(g_hStubLogFile, "\t%-30s %3d (0x%02x)\r\n", "STUB_MISS_COUNT_VALUE",

STUB_MISS_COUNT_VALUE, STUB_MISS_COUNT_VALUE);

fprintf(g_hStubLogFile, "\t%-30s %3d%% (0x%02x)\r\n", "STUB_COLLIDE_WRITE_PCT",

STUB_COLLIDE_WRITE_PCT, STUB_COLLIDE_WRITE_PCT);

fprintf(g_hStubLogFile, "\t%-30s %3d%% (0x%02x)\r\n", "STUB_COLLIDE_MONO_PCT",

STUB_COLLIDE_MONO_PCT, STUB_COLLIDE_MONO_PCT);

fprintf(g_hStubLogFile, "\t%-30s %3d%% (0x%02x)\r\n", "DumpLogCounter",

g_dumpLogCounter, g_dumpLogCounter);

fprintf(g_hStubLogFile, "\t%-30s %3d%% (0x%02x)\r\n", "DumpLogIncr",

g_dumpLogCounter, g_dumpLogIncr);

fprintf(g_hStubLogFile, "\t%-30s %3d%% (0x%02x)\r\n", "ResetCacheCounter",

g_resetCacheCounter, g_resetCacheCounter);

fprintf(g_hStubLogFile, "\t%-30s %3d%% (0x%02x)\r\n", "ResetCacheIncr",

g_resetCacheCounter, g_resetCacheIncr);

#endif // STUB_LOGGING

fprintf(g_hStubLogFile, "\r\nsite data\r\n");

//output counters

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "site_counter", g_site_counter);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "site_write", g_site_write);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "site_write_mono", g_site_write_mono);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "site_write_poly", g_site_write_poly);

fprintf(g_hStubLogFile, "\r\n%-30s %d\r\n", "reclaim_counter", g_reclaim_counter);

fprintf(g_hStubLogFile, "\r\nstub data\r\n");

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "stub_lookup_counter", g_stub_lookup_counter);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "stub_mono_counter", g_stub_mono_counter);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "stub_poly_counter", g_stub_poly_counter);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "stub_vtable_counter", g_stub_vtable_counter);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "stub_space", g_stub_space);

#ifdef STUB_LOGGING

fprintf(g_hStubLogFile, "\r\nlookup stub data\r\n");

UINT32 total_calls = g_mono_call_counter + g_poly_call_counter;

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "lookup_call_counter", g_call_lookup_counter);

fprintf(g_hStubLogFile, "\r\n%-30s %d\r\n", "total stub dispatch calls", total_calls);

fprintf(g_hStubLogFile, "\r\n%-30s %#5.2f%%\r\n", "mono stub data",

100.0 * double(g_mono_call_counter)/double(total_calls));

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "mono_call_counter", g_mono_call_counter);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "mono_miss_counter", g_mono_miss_counter);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_PCT, "miss percent",

100.0 * double(g_mono_miss_counter)/double(g_mono_call_counter));

fprintf(g_hStubLogFile, "\r\n%-30s %#5.2f%%\r\n", "poly stub data",

100.0 * double(g_poly_call_counter)/double(total_calls));

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "poly_call_counter", g_poly_call_counter);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "poly_miss_counter", g_poly_miss_counter);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_PCT, "miss percent",

100.0 * double(g_poly_miss_counter)/double(g_poly_call_counter));

#endif // STUB_LOGGING

#ifdef CHAIN_LOOKUP

fprintf(g_hStubLogFile, "\r\nchain lookup data\r\n");

#ifdef STUB_LOGGING

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "chained_lookup_call_counter", g_chained_lookup_call_counter);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "chained_lookup_miss_counter", g_chained_lookup_miss_counter);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_PCT, "miss percent",

100.0 * double(g_chained_lookup_miss_counter)/double(g_chained_lookup_call_counter));

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "chained_lookup_external_call_counter", g_chained_lookup_external_call_counter);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "chained_lookup_external_miss_counter", g_chained_lookup_external_miss_counter);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_PCT, "miss percent",

100.0 * double(g_chained_lookup_external_miss_counter)/double(g_chained_lookup_external_call_counter));

#endif // STUB_LOGGING

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "chained_entry_promoted", g_chained_entry_promoted);

#endif // CHAIN_LOOKUP

#ifdef STUB_LOGGING

fprintf(g_hStubLogFile, "\r\n%-30s %#5.2f%%\r\n", "worker (slow resolver) data",

100.0 * double(g_worker_call)/double(total_calls));

#else // !STUB_LOGGING

fprintf(g_hStubLogFile, "\r\nworker (slow resolver) data\r\n");

#endif // !STUB_LOGGING

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "worker_call", g_worker_call);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "worker_call_no_patch", g_worker_call_no_patch);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "external_call", g_external_call);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "external_call_no_patch", g_external_call_no_patch);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "worker_collide_to_mono", g_worker_collide_to_mono);

UINT32 total_inserts = g_insert_cache_external

+ g_insert_cache_shared

+ g_insert_cache_dispatch

+ g_insert_cache_resolve;

fprintf(g_hStubLogFile, "\r\n%-30s %d\r\n", "insert cache data", total_inserts);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT_PCT, "insert_cache_external", g_insert_cache_external,

100.0 * double(g_insert_cache_external)/double(total_inserts));

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT_PCT, "insert_cache_shared", g_insert_cache_shared,

100.0 * double(g_insert_cache_shared)/double(total_inserts));

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT_PCT, "insert_cache_dispatch", g_insert_cache_dispatch,

100.0 * double(g_insert_cache_dispatch)/double(total_inserts));

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT_PCT, "insert_cache_resolve", g_insert_cache_resolve,

100.0 * double(g_insert_cache_resolve)/double(total_inserts));

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT_PCT, "insert_cache_hit", g_insert_cache_hit,

100.0 * double(g_insert_cache_hit)/double(total_inserts));

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT_PCT, "insert_cache_miss", g_insert_cache_miss,

100.0 * double(g_insert_cache_miss)/double(total_inserts));

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT_PCT, "insert_cache_collide", g_insert_cache_collide,

100.0 * double(g_insert_cache_collide)/double(total_inserts));

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT_PCT, "insert_cache_write", g_insert_cache_write,

100.0 * double(g_insert_cache_write)/double(total_inserts));

fprintf(g_hStubLogFile, "\r\ncache data\r\n");

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

size_t total, used;

g_resolveCache->GetLoadFactor(&total, &used);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_SIZE, "cache_entry_used", used);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "cache_entry_counter", g_cache_entry_counter);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "cache_entry_space", g_cache_entry_space);

fprintf(g_hStubLogFile, "\r\nstub hash table data\r\n");

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "bucket_space", g_bucket_space);

fprintf(g_hStubLogFile, OUTPUT_FORMAT_INT, "bucket_space_dead", g_bucket_space_dead);

fprintf(g_hStubLogFile, "\r\ncache_load:\t%zu used, %zu total, utilization %#5.2f%%\r\n",

used, total, 100.0 * double(used) / double(total));

#ifdef STUB_LOGGING

fprintf(g_hStubLogFile, "\r\ncache entry write counts\r\n");

DispatchCache::CacheEntryData *rgCacheData = g_resolveCache->cacheData;

for (UINT16 i = 0; i < CALL_STUB_CACHE_SIZE; i++)

{

fprintf(g_hStubLogFile, " %4d", rgCacheData[i]);

if (i % 16 == 15)

{

fprintf(g_hStubLogFile, "\r\n");

}

}

fprintf(g_hStubLogFile, "\r\n");

#endif // STUB_LOGGING

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

#if 0

for (unsigned i = 0; i < ContractImplMap::max_delta_count; i++)

{

if (ContractImplMap::deltasDescs[i] != 0)

{

fprintf(g_hStubLogFile, "deltasDescs[%d]\t%d\r\n", i, ContractImplMap::deltasDescs[i]);

}

}

for (unsigned i = 0; i < ContractImplMap::max_delta_count; i++)

{

if (ContractImplMap::deltasSlots[i] != 0)

{

fprintf(g_hStubLogFile, "deltasSlots[%d]\t%d\r\n", i, ContractImplMap::deltasSlots[i]);

}

}

fprintf(g_hStubLogFile, "cout of maps:\t%d\r\n", ContractImplMap::countMaps);

fprintf(g_hStubLogFile, "count of interfaces:\t%d\r\n", ContractImplMap::countInterfaces);

fprintf(g_hStubLogFile, "count of deltas:\t%d\r\n", ContractImplMap::countDelta);

fprintf(g_hStubLogFile, "total delta for descs:\t%d\r\n", ContractImplMap::totalDeltaDescs);

fprintf(g_hStubLogFile, "total delta for slots:\t%d\r\n", ContractImplMap::totalDeltaSlots);

#endif // 0

}

}

void VirtualCallStubManager::FinishLogging()

{

LoggingDump();

if(g_hStubLogFile)

{

fclose(g_hStubLogFile);

}

g_hStubLogFile = NULL;

}

void VirtualCallStubManager::ResetCache()

{

CONTRACTL

{

NOTHROW;

GC_TRIGGERS;

FORBID_FAULT;

}

CONTRACTL_END

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

g_resolveCache->LogStats();

g_insert_cache_external = 0;

g_insert_cache_shared = 0;

g_insert_cache_dispatch = 0;

g_insert_cache_resolve = 0;

g_insert_cache_hit = 0;

g_insert_cache_miss = 0;

g_insert_cache_collide = 0;

g_insert_cache_write = 0;

// Go through each cache entry and if the cache element there is in

// the cache entry heap of the manager being deleted, then we just

// set the cache entry to empty.

DispatchCache::Iterator it(g_resolveCache);

while (it.IsValid())

{

it.UnlinkEntry();

}

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

}

void VirtualCallStubManager::Init(LoaderAllocator *pLoaderAllocator)

{

CONTRACTL {

THROWS;

GC_TRIGGERS;

INJECT_FAULT(COMPlusThrowOM(););

} CONTRACTL_END;

m_loaderAllocator = pLoaderAllocator;

//

// Init critical sections

//

m_indCellLock.Init(CrstVSDIndirectionCellLock, CRST_UNSAFE_ANYMODE);

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

//

// Now allocate all BucketTables

//

NewHolder<BucketTable> resolvers_holder(new BucketTable(CALL_STUB_MIN_BUCKETS));

NewHolder<BucketTable> dispatchers_holder(new BucketTable(CALL_STUB_MIN_BUCKETS*2));

NewHolder<BucketTable> lookups_holder(new BucketTable(CALL_STUB_MIN_BUCKETS));

NewHolder<BucketTable> vtableCallers_holder(new BucketTable(CALL_STUB_MIN_BUCKETS));

NewHolder<BucketTable> cache_entries_holder(new BucketTable(CALL_STUB_MIN_BUCKETS));

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

//

// Now allocate our LoaderHeaps

//

//

// First do some calculation to determine how many pages that we

// will need to commit and reserve for each out our loader heaps

//

DWORD indcell_heap_reserve_size;

DWORD indcell_heap_commit_size;

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

DWORD cache_entry_heap_reserve_size;

DWORD cache_entry_heap_commit_size;

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

//

// Setup an expected number of items to commit and reserve

//

// The commit number is not that important as we always commit at least one page worth of items

// The reserve number should be high enough to cover a typical lare application,

// in order to minimize the fragmentation of our rangelists

//

indcell_heap_commit_size = 16; indcell_heap_reserve_size = 2000;

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

cache_entry_heap_commit_size = 16; cache_entry_heap_reserve_size = 800;

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

//

// Convert the number of items into a size in bytes to commit and reserve

//

indcell_heap_reserve_size *= sizeof(void *);

indcell_heap_commit_size *= sizeof(void *);

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

cache_entry_heap_reserve_size *= sizeof(ResolveCacheElem);

cache_entry_heap_commit_size *= sizeof(ResolveCacheElem);

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

//

// Align up all of the commit and reserve sizes

//

indcell_heap_reserve_size = (DWORD) ALIGN_UP(indcell_heap_reserve_size, GetOsPageSize());

indcell_heap_commit_size = (DWORD) ALIGN_UP(indcell_heap_commit_size, GetOsPageSize());

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

cache_entry_heap_reserve_size = (DWORD) ALIGN_UP(cache_entry_heap_reserve_size, GetOsPageSize());

cache_entry_heap_commit_size = (DWORD) ALIGN_UP(cache_entry_heap_commit_size, GetOsPageSize());

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

BYTE * initReservedMem = NULL;

if (!m_loaderAllocator->IsCollectible())

{

DWORD dwTotalReserveMemSizeCalc = indcell_heap_reserve_size

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

+ cache_entry_heap_reserve_size

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

;

DWORD dwTotalReserveMemSize = (DWORD) ALIGN_UP(dwTotalReserveMemSizeCalc, VIRTUAL_ALLOC_RESERVE_GRANULARITY);

// If there's wasted reserved memory, we hand this out to the heaps to avoid waste.

{

DWORD dwWastedReserveMemSize = dwTotalReserveMemSize - dwTotalReserveMemSizeCalc;

if (dwWastedReserveMemSize != 0)

{

DWORD cWastedPages = dwWastedReserveMemSize / GetOsPageSize();

// Split the wasted pages over the 2 LoaderHeaps that we allocate as part of a VirtualCallStubManager

DWORD cPagesPerHeap = cWastedPages / 2;

DWORD cPagesRemainder = cWastedPages % 2; // We'll throw this at the cache entry heap

indcell_heap_reserve_size += cPagesPerHeap * GetOsPageSize();

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

cache_entry_heap_reserve_size += (cPagesPerHeap + cPagesRemainder) * GetOsPageSize();

#else

indcell_heap_reserve_size += (cPagesPerHeap + cPagesRemainder) * GetOsPageSize();

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

}

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

CONSISTENCY_CHECK((indcell_heap_reserve_size +

cache_entry_heap_reserve_size)==

dwTotalReserveMemSize);

#else

CONSISTENCY_CHECK(indcell_heap_reserve_size == dwTotalReserveMemSize);

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

}

initReservedMem = (BYTE*)ExecutableAllocator::Instance()->Reserve(dwTotalReserveMemSize);

m_initialReservedMemForHeaps = (BYTE *) initReservedMem;

if (initReservedMem == NULL)

COMPlusThrowOM();

}

else

{

indcell_heap_reserve_size = GetOsPageSize();

indcell_heap_commit_size = GetOsPageSize();

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

cache_entry_heap_reserve_size = GetOsPageSize();

cache_entry_heap_commit_size = GetOsPageSize();

#else

// If we don't support VSD, use a slightly bigger heap size to avoid wasting memory

indcell_heap_reserve_size = 2 * GetOsPageSize();

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

#ifdef _DEBUG

DWORD dwTotalReserveMemSizeCalc = indcell_heap_reserve_size

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

+ cache_entry_heap_reserve_size

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

;

#endif

DWORD dwActualVSDSize = 0;

initReservedMem = pLoaderAllocator->GetVSDHeapInitialBlock(&dwActualVSDSize);

_ASSERTE(dwActualVSDSize == dwTotalReserveMemSizeCalc);

m_initialReservedMemForHeaps = (BYTE *) initReservedMem;

if (initReservedMem == NULL)

COMPlusThrowOM();

}

// Hot memory, Writable, No-Execute, infrequent writes

RangeList* pIndCellRangeList = NULL;

#ifdef FEATURE_CACHED_INTERFACE_DISPATCH

if (UseCachedInterfaceDispatch())

{

pIndCellRangeList = &indcell_rangeList;

}

#endif

NewHolder<LoaderHeap> indcell_heap_holder(

new LoaderHeap(indcell_heap_reserve_size, indcell_heap_commit_size,

initReservedMem, indcell_heap_reserve_size,

pIndCellRangeList, LoaderHeapImplementationKind::Data));

initReservedMem += indcell_heap_reserve_size;

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

// Hot memory, Writable, No-Execute, infrequent writes

NewHolder<LoaderHeap> cache_entry_heap_holder(

new LoaderHeap(cache_entry_heap_reserve_size, cache_entry_heap_commit_size,

initReservedMem, cache_entry_heap_reserve_size,

&cache_entry_rangeList, LoaderHeapImplementationKind::Data));

initReservedMem += cache_entry_heap_reserve_size;

// Warm memory, Writable, Execute, write exactly once

NewHolder<CodeFragmentHeap> lookup_heap_holder(

new CodeFragmentHeap(pLoaderAllocator, STUB_CODE_BLOCK_VSD_LOOKUP_STUB));

// Hot memory, Writable, Execute, write exactly once

NewHolder<CodeFragmentHeap> dispatch_heap_holder(

new CodeFragmentHeap(pLoaderAllocator, STUB_CODE_BLOCK_VSD_DISPATCH_STUB));

// Hot memory, Writable, Execute, write exactly once

NewHolder<CodeFragmentHeap> resolve_heap_holder(

new CodeFragmentHeap(pLoaderAllocator, STUB_CODE_BLOCK_VSD_RESOLVE_STUB));

// Hot memory, Writable, Execute, write exactly once

NewHolder<CodeFragmentHeap> vtable_heap_holder(

new CodeFragmentHeap(pLoaderAllocator, STUB_CODE_BLOCK_VSD_VTABLE_STUB));

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

// Allocate the initial counter block

NewHolder<counter_block> m_counters_holder(new counter_block);

//

// On success of every allocation, assign the objects and suppress the release

//

indcell_heap = indcell_heap_holder; indcell_heap_holder.SuppressRelease();

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

lookup_heap = lookup_heap_holder; lookup_heap_holder.SuppressRelease();

dispatch_heap = dispatch_heap_holder; dispatch_heap_holder.SuppressRelease();

resolve_heap = resolve_heap_holder; resolve_heap_holder.SuppressRelease();

vtable_heap = vtable_heap_holder; vtable_heap_holder.SuppressRelease();

cache_entry_heap = cache_entry_heap_holder; cache_entry_heap_holder.SuppressRelease();

resolvers = resolvers_holder; resolvers_holder.SuppressRelease();

dispatchers = dispatchers_holder; dispatchers_holder.SuppressRelease();

lookups = lookups_holder; lookups_holder.SuppressRelease();

vtableCallers = vtableCallers_holder; vtableCallers_holder.SuppressRelease();

cache_entries = cache_entries_holder; cache_entries_holder.SuppressRelease();

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

m_counters = m_counters_holder; m_counters_holder.SuppressRelease();

// Create the initial failure counter block

m_counters->next = NULL;

m_counters->used = 0;

m_cur_counter_block = m_counters;

m_cur_counter_block_for_reclaim = m_counters;

m_cur_counter_block_for_reclaim_index = 0;

// Keep track of all of our managers

VirtualCallStubManagerManager::GlobalManager()->AddStubManager(this);

}

void VirtualCallStubManager::Uninit()

{

WRAPPER_NO_CONTRACT;

// Keep track of all our managers

VirtualCallStubManagerManager::GlobalManager()->RemoveStubManager(this);

}

VirtualCallStubManager::~VirtualCallStubManager()

{

CONTRACTL {

NOTHROW;

GC_NOTRIGGER;

FORBID_FAULT;

} CONTRACTL_END;

LogStats();

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

// Go through each cache entry and if the cache element there is in

// the cache entry heap of the manager being deleted, then we just

// set the cache entry to empty.

DispatchCache::Iterator it(g_resolveCache);

while (it.IsValid())

{

// Using UnlinkEntry performs an implicit call to Next (see comment for UnlinkEntry).

// Thus, we need to avoid calling Next when we delete an entry so

// that we don't accidentally skip entries.

while (it.IsValid() && cache_entry_rangeList.IsInRange((TADDR)it.Entry()))

{

it.UnlinkEntry();

}

it.Next();

}

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

#ifdef FEATURE_CACHED_INTERFACE_DISPATCH

if (m_loaderAllocator->IsCollectible() && UseCachedInterfaceDispatch())

{

CachedIndirectionCellBlockListNode * pBlockNode = m_indirectionBlocks;

while (pBlockNode != NULL)

{

for (UINT32 i = 0; i < INDCELLS_PER_BLOCK; i++)

{

InterfaceDispatchCacheHeader* cache = pBlockNode->m_rgIndCells[i].GetCache();

if (cache != NULL)

{

InterfaceDispatch_DiscardCacheHeader(cache);

}

}

pBlockNode = pBlockNode->m_pNext;

}

}

#endif

if (indcell_heap) { delete indcell_heap; indcell_heap = NULL;}

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

if (lookup_heap) { delete lookup_heap; lookup_heap = NULL;}

if (dispatch_heap) { delete dispatch_heap; dispatch_heap = NULL;}

if (resolve_heap) { delete resolve_heap; resolve_heap = NULL;}

if (vtable_heap) { delete vtable_heap; vtable_heap = NULL;}

if (cache_entry_heap) { delete cache_entry_heap; cache_entry_heap = NULL;}

if (resolvers) { delete resolvers; resolvers = NULL;}

if (dispatchers) { delete dispatchers; dispatchers = NULL;}

if (lookups) { delete lookups; lookups = NULL;}

if (vtableCallers) { delete vtableCallers; vtableCallers = NULL;}

if (cache_entries) { delete cache_entries; cache_entries = NULL;}

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

// Now get rid of the memory taken by the counter_blocks

while (m_counters != NULL)

{

counter_block *del = m_counters;

m_counters = m_counters->next;

delete del;

}

// This was the block reserved by Init for the heaps.

// For the collectible case, the VSD logic does not allocate the memory.

if (m_initialReservedMemForHeaps && !m_loaderAllocator->IsCollectible())

ClrVirtualFree (m_initialReservedMemForHeaps, 0, MEM_RELEASE);

// Free critical section

m_indCellLock.Destroy();

}

// Initialize static structures, and start up logging if necessary

void VirtualCallStubManager::InitStatic()

{

STANDARD_VM_CONTRACT;

#ifdef FEATURE_CACHED_INTERFACE_DISPATCH

InterfaceDispatch_Initialize();

#endif

#ifdef STUB_LOGGING

// Note if you change these values using environment variables then you must use hex values :-(

STUB_MISS_COUNT_VALUE = (INT32) CLRConfig::GetConfigValue(CLRConfig::INTERNAL_VirtualCallStubMissCount);

STUB_COLLIDE_WRITE_PCT = (INT32) CLRConfig::GetConfigValue(CLRConfig::INTERNAL_VirtualCallStubCollideWritePct);

STUB_COLLIDE_MONO_PCT = (INT32) CLRConfig::GetConfigValue(CLRConfig::INTERNAL_VirtualCallStubCollideMonoPct);

g_dumpLogCounter = (INT32) CLRConfig::GetConfigValue(CLRConfig::INTERNAL_VirtualCallStubDumpLogCounter);

g_dumpLogIncr = (INT32) CLRConfig::GetConfigValue(CLRConfig::INTERNAL_VirtualCallStubDumpLogIncr);

g_resetCacheCounter = (INT32) CLRConfig::GetConfigValue(CLRConfig::INTERNAL_VirtualCallStubResetCacheCounter);

g_resetCacheIncr = (INT32) CLRConfig::GetConfigValue(CLRConfig::INTERNAL_VirtualCallStubResetCacheIncr);

#endif // STUB_LOGGING

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

#ifndef STUB_DISPATCH_PORTABLE

DispatchHolder::InitializeStatic();

ResolveHolder::InitializeStatic();

#endif // !STUB_DISPATCH_PORTABLE

LookupHolder::InitializeStatic();

g_resolveCache = new DispatchCache();

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

if(CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_VirtualCallStubLogging))

StartupLogging();

VirtualCallStubManagerManager::InitStatic();

}

void VirtualCallStubManager::LogFinalStats()

{

CONTRACTL

{

NOTHROW;

GC_TRIGGERS;

FORBID_FAULT;

}

CONTRACTL_END

if (g_hStubLogFile != NULL)

{

VirtualCallStubManagerIterator it =

VirtualCallStubManagerManager::GlobalManager()->IterateVirtualCallStubManagers();

while (it.Next())

{

it.Current()->LogStats();

}

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

g_resolveCache->LogStats();

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

FinishLogging();

}

}

/* reclaim/rearrange any structures that can only be done during a gc sync point

i.e. need to be serialized and non-concurrant. */

void VirtualCallStubManager::ReclaimAll()

{

STATIC_CONTRACT_NOTHROW;

STATIC_CONTRACT_GC_NOTRIGGER;

STATIC_CONTRACT_FORBID_FAULT;

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

/* @todo: if/when app domain unloading is supported,

and when we have app domain specific stub heaps, we can complete the unloading

of an app domain stub heap at this point, and make any patches to existing stubs that are

not being unload so that they nolonger refer to any of the unloaded app domains code or types

*/

//reclaim space of abandoned buckets

BucketTable::Reclaim();

VirtualCallStubManagerIterator it =

VirtualCallStubManagerManager::GlobalManager()->IterateVirtualCallStubManagers();

while (it.Next())

{

it.Current()->Reclaim();

}

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

#ifdef FEATURE_CACHED_INTERFACE_DISPATCH

InterfaceDispatch_ReclaimUnusedInterfaceDispatchCaches();

#endif // FEATURE_CACHED_INTERFACE_DISPATCH

g_reclaim_counter++;

}

const UINT32 VirtualCallStubManager::counter_block::MAX_COUNTER_ENTRIES;

/* reclaim/rearrange any structures that can only be done during a gc sync point

i.e. need to be serialized and non-concurrant. */

void VirtualCallStubManager::Reclaim()

{

LIMITED_METHOD_CONTRACT;

UINT32 limit = min(counter_block::MAX_COUNTER_ENTRIES,

m_cur_counter_block_for_reclaim->used);

limit = min(m_cur_counter_block_for_reclaim_index + 16, limit);

for (UINT32 i = m_cur_counter_block_for_reclaim_index; i < limit; i++)

{

m_cur_counter_block_for_reclaim->block[i] += (STUB_MISS_COUNT_VALUE/10)+1;

}

// Increment the index by the number we processed

m_cur_counter_block_for_reclaim_index = limit;

// If we ran to the end of the block, go to the next

if (m_cur_counter_block_for_reclaim_index == m_cur_counter_block->used)

{

m_cur_counter_block_for_reclaim = m_cur_counter_block_for_reclaim->next;

m_cur_counter_block_for_reclaim_index = 0;

// If this was the last block in the chain, go back to the beginning

if (m_cur_counter_block_for_reclaim == NULL)

m_cur_counter_block_for_reclaim = m_counters;

}

}

#endif // !DACCESS_COMPILE

//----------------------------------------------------------------------------

/* static */

#ifdef FEATURE_VIRTUAL_STUB_DISPATCH

VirtualCallStubManager *VirtualCallStubManager::FindStubManager(PCODE stubAddress, StubCodeBlockKind* wbStubKind)

{

CONTRACTL {

NOTHROW;

GC_NOTRIGGER;

FORBID_FAULT;

SUPPORTS_DAC;

} CONTRACTL_END

StubCodeBlockKind unusedStubKind;

if (wbStubKind == NULL)

{

wbStubKind = &unusedStubKind;

}

*wbStubKind = STUB_CODE_BLOCK_UNKNOWN;

RangeSection * pRS = ExecutionManager::FindCodeRange(stubAddress, ExecutionManager::ScanReaderLock);

if (pRS == NULL)

return NULL;

StubCodeBlockKind kind = pRS->_pjit->GetStubCodeBlockKind(pRS, stubAddress);

switch (kind)

{

case STUB_CODE_BLOCK_VSD_DISPATCH_STUB:

case STUB_CODE_BLOCK_VSD_RESOLVE_STUB:

case STUB_CODE_BLOCK_VSD_LOOKUP_STUB:

case STUB_CODE_BLOCK_VSD_VTABLE_STUB:

// This is a VSD stub, using the RangeSection identify which LoaderAllocator this is from

_ASSERTE(pRS->_flags & RangeSection::RANGE_SECTION_CODEHEAP);

*wbStubKind = kind;

return pRS->_pHeapList->pLoaderAllocator->GetVirtualCallStubManager();

default:

return NULL;

}

}

#endif // FEATURE_VIRTUAL_STUB_DISPATCH

/* for use by debugger.

*/

BOOL VirtualCallStubManager::CheckIsStub_Internal(PCODE stubStartAddress)

{

STATIC_CONTRACT_NOTHROW;

STATIC_CONTRACT_GC_NOTRIGGER;

STATIC_CONTRACT_FORBID_FAULT;

SUPPORTS_DAC;

// Forwarded to from RangeSectionStubManager

return FALSE;

}

/* for use by debugger.

*/

extern "C" void STDCALL StubDispatchFixupPatchLabel();

BOOL VirtualCallStubManager::DoTraceStub(PCODE stubStartAddress, TraceDestination *trace)

{

LIMITED_METHOD_CONTRACT;

LOG((LF_CORDB, LL_EVERYTHING, "VirtualCallStubManager::DoTraceStub called\n"));

// @workaround: Well, we really need the context to figure out where we're going, so

// we'll do a TRACE_MGR_PUSH so that TraceManager gets called and we can use

// the provided context to figure out where we're going.

trace->InitForManagerPush(stubStartAddress, this);

return TRUE;

}

//----------------------------------------------------------------------------

BOOL VirtualCallStubManager::TraceManager(Thread *thread,

TraceDestination *trace,

T_CONTEXT *pContext,

BYTE **pRetAddr)

{

CONTRACTL

{

THROWS;

GC_TRIGGERS;

INJECT_FAULT(COMPlusThrowOM(););

}

CONTRACTL_END

TADDR pStub = GetIP(pContext);

// The return address should be on the top of the stack

*pRetAddr = (BYTE *)StubManagerHelpers::GetReturnAddress(pContext);

// Get the token from the stub

DispatchToken token(GetTokenFromStub(pStub, pContext));

// Get the this object from ECX

Object *pObj = StubManagerHelpers::GetThisPtr(pContext);

// Call common trace code.

return (TraceResolver(pObj, token, trace));

}

#ifndef DACCESS_COMPILE

DispatchToken VirtualCallStubManager::GetTokenFromOwnerAndSlot(TypeHandle ownerType, uint32_t slot)

{

CONTRACTL

{

THROWS;

GC_TRIGGERS;

MODE_ANY;

INJECT_FAULT(COMPlusThrowOM(););

}

CONTRACTL_END

MethodTable * pMT = ownerType.GetMethodTable();

pMT->GetRestoredSlot(slot);

DispatchToken token;

if (pMT->IsInterface())

token = pMT->GetLoaderAllocator()->GetDispatchToken(pMT->GetTypeID(), slot);

else