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

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

//*****************************************************************************

// util.cpp

//

//

// This contains a bunch of C++ utility classes.

//

//*****************************************************************************

#include "stdafx.h" // Precompiled header key.

#include "utilcode.h"

#include "metadata.h"

#include "ex.h"

#include "pedecoder.h"

#include "loaderheap.h"

#include "sigparser.h"

#include "cor.h"

#include "corinfo.h"

#include "volatile.h"

#include "mdfileformat.h"

#include <configuration.h>

#ifndef DACCESS_COMPILE

UINT32 g_nClrInstanceId = 0;

#if defined(TARGET_WINDOWS) && defined(TARGET_ARM64)

// Flag to check if atomics feature is available on

// the machine

bool g_arm64_atomics_present = false;

#endif

#endif //!DACCESS_COMPILE

// Validate that the name used to load the JIT/GC is just a simple file name

// and does not contain something that could be used in a non-qualified path.

// For example, using the string "..\..\..\myjit.dll" we might attempt to

// load a JIT from the root of the drive.

//

// The minimal set of characters that we must check for and exclude are:

// On all platforms:

// '/' - (forward slash)

// On Windows:

// '\\' - (backslash)

// ':' - (colon)

//

// Returns false if we find any of these characters in 'pwzModuleName'

// Returns true if we reach the null terminator without encountering

// any of these characters.

//

bool ValidateModuleName(LPCWSTR pwzModuleName)

{

LPCWSTR pCurChar = pwzModuleName;

wchar_t curChar;

do {

curChar = *pCurChar;

if (curChar == '/'

#ifdef TARGET_WINDOWS

|| (curChar == '\\') || (curChar == ':')

#endif

)

{

// Return false if we find any of these character in 'pwzJitName'

return false;

}

pCurChar++;

} while (curChar != 0);

// Return true; we have reached the null terminator

//

return true;

}

//*****************************************************************************

// Convert a string of hex digits into a hex value of the specified # of bytes.

//*****************************************************************************

HRESULT GetHex( // Return status.

LPCSTR szStr, // String to convert.

int size, // # of bytes in pResult.

void *pResult) // Buffer for result.

{

CONTRACTL

{

NOTHROW;

}

CONTRACTL_END;

int count = size * 2; // # of bytes to take from string.

unsigned int Result = 0; // Result value.

char ch;

_ASSERTE(size == 1 || size == 2 || size == 4);

while (count-- && (ch = *szStr++) != '\0')

{

switch (ch)

{

case '0': case '1': case '2': case '3': case '4':

case '5': case '6': case '7': case '8': case '9':

Result = 16 * Result + (ch - '0');

break;

case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':

Result = 16 * Result + 10 + (ch - 'A');

break;

case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':

Result = 16 * Result + 10 + (ch - 'a');

break;

default:

return (E_FAIL);

}

}

// Set the output.

switch (size)

{

case 1:

*((BYTE *) pResult) = (BYTE) Result;

break;

case 2:

*((WORD *) pResult) = (WORD) Result;

break;

case 4:

*((DWORD *) pResult) = Result;

break;

default:

_ASSERTE(0);

break;

}

return (S_OK);

}

//*****************************************************************************

// Convert a pointer to a string into a GUID.

//*****************************************************************************

BOOL LPCSTRToGuid(

LPCSTR szGuid, // [IN] String to convert.

GUID* pGuid) // [OUT] Buffer for converted GUID.

{

CONTRACTL

{

NOTHROW;

}

CONTRACTL_END;

int i;

// Verify the surrounding syntax.

if (strlen(szGuid) != 38 || szGuid[0] != '{' || szGuid[9] != '-' ||

szGuid[14] != '-' || szGuid[19] != '-' || szGuid[24] != '-' || szGuid[37] != '}')

{

return FALSE;

}

// Parse the first 3 fields.

if (FAILED(GetHex(szGuid + 1, 4, &pGuid->Data1)))

return FALSE;

if (FAILED(GetHex(szGuid + 10, 2, &pGuid->Data2)))

return FALSE;

if (FAILED(GetHex(szGuid + 15, 2, &pGuid->Data3)))

return FALSE;

// Get the last two fields (which are byte arrays).

for (i = 0; i < 2; ++i)

{

if (FAILED(GetHex(szGuid + 20 + (i * 2), 1, &pGuid->Data4[i])))

{

return FALSE;

}

}

for (i=0; i < 6; ++i)

{

if (FAILED(GetHex(szGuid + 25 + (i * 2), 1, &pGuid->Data4[i+2])))

{

return FALSE;

}

}

return TRUE;

}

//

//

// Global utility functions.

//

//

typedef HRESULT __stdcall DLLGETCLASSOBJECT(REFCLSID rclsid,

REFIID riid,

void **ppv);

EXTERN_C const IID _IID_IClassFactory =

{0x00000001, 0x0000, 0x0000, {0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}};

namespace

{

HRESULT FakeCoCallDllGetClassObject(

REFCLSID rclsid,

LPCWSTR wszDllPath,

REFIID riid,

void **ppv,

HMODULE *phmodDll)

{

CONTRACTL

{

THROWS;

}

CONTRACTL_END;

_ASSERTE(ppv != nullptr);

HRESULT hr = S_OK;

// Initialize [out] HMODULE (if it was requested)

if (phmodDll != nullptr)

*phmodDll = nullptr;

bool fIsDllPathPrefix = (wszDllPath != nullptr) && (u16_strlen(wszDllPath) > 0) && (wszDllPath[u16_strlen(wszDllPath) - 1] == W('\\'));

// - An empty string will be treated as NULL.

// - A string ending will a backslash will be treated as a prefix for where to look for the DLL

// if the InProcServer32 value is just a DLL name and not a full path.

StackSString ssDllName;

if ((wszDllPath == nullptr) || (wszDllPath[0] == W('\0')) || fIsDllPathPrefix)

{

#ifdef HOST_WINDOWS

IfFailRet(Clr::Util::Com::FindInprocServer32UsingCLSID(rclsid, ssDllName));

EX_TRY

{

if (fIsDllPathPrefix)

{

SString::Iterator i = ssDllName.Begin();

if (!ssDllName.Find(i, W('\\')))

{ // If the InprocServer32 is just a DLL name (not a fully qualified path), then

// prefix wszFilePath with wszDllPath.

ssDllName.Insert(i, wszDllPath);

}

}

}

EX_CATCH_HRESULT(hr);

IfFailRet(hr);

wszDllPath = ssDllName.GetUnicode();

#else // HOST_WINDOWS

return E_FAIL;

#endif // HOST_WINDOWS

}

_ASSERTE(wszDllPath != nullptr);

// We've got the name of the DLL to load, so load it.

HModuleHolder hDll = WszLoadLibrary(wszDllPath, nullptr, GetLoadWithAlteredSearchPathFlag());

if (hDll == nullptr)

return HRESULT_FROM_GetLastError();

// We've loaded the DLL, so find the DllGetClassObject function.

DLLGETCLASSOBJECT *dllGetClassObject = (DLLGETCLASSOBJECT*)GetProcAddress(hDll, "DllGetClassObject");

if (dllGetClassObject == nullptr)

return HRESULT_FROM_GetLastError();

// Call the function to get a class object for the rclsid and riid passed in.

IfFailRet(dllGetClassObject(rclsid, riid, ppv));

hDll.SuppressRelease();

if (phmodDll != nullptr)

*phmodDll = hDll.GetValue();

return hr;

}

}

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

// FakeCoCreateInstanceEx

//

// Description:

// A private function to do the equivalent of a CoCreateInstance in cases where we

// can't make the real call. Use this when, for instance, you need to create a symbol

// reader in the Runtime but we're not CoInitialized. Obviously, this is only good

// for COM objects for which CoCreateInstance is just a glorified find-and-load-me

// operation.

//

// Arguments:

// * rclsid - [in] CLSID of object to instantiate

// * wszDllPath [in] - Path to profiler DLL. If wszDllPath is NULL, FakeCoCreateInstanceEx

// will look up the registry to find the path of the COM dll associated with rclsid.

// If the path ends in a backslash, FakeCoCreateInstanceEx will treat this as a prefix

// if the InprocServer32 found in the registry is a simple filename (not a full path).

// This allows the caller to specify the directory in which the InprocServer32 should

// be found.

// * riid - [in] IID of interface on object to return in ppv

// * ppv - [out] Pointer to implementation of requested interface

// * phmodDll - [out] HMODULE of DLL that was loaded to instantiate the COM object.

// The caller may eventually call FreeLibrary() on this if it can be determined

// that we no longer reference the generated COM object or dependencies. Else, the

// caller may ignore this and the DLL will stay loaded forever. If caller

// specifies phmodDll==NULL, then this parameter is ignored and the HMODULE is not

// returned.

//

// Return Value:

// HRESULT indicating success or failure.

//

// Notes:

// * (*phmodDll) on [out] may always be trusted, even if this function returns an

// error. Therefore, even if creation of the COM object failed, if (*phmodDll !=

// NULL), then the DLL was actually loaded. The caller may wish to call

// FreeLibrary on (*phmodDll) in such a case.

HRESULT FakeCoCreateInstanceEx(REFCLSID rclsid,

LPCWSTR wszDllPath,

REFIID riid,

void ** ppv,

HMODULE * phmodDll)

{

CONTRACTL

{

THROWS;

}

CONTRACTL_END;

HRESULT hr = S_OK;

// Call the function to get a class factory for the rclsid passed in.

HModuleHolder hDll;

ReleaseHolder<IClassFactory> classFactory;

IfFailRet(FakeCoCallDllGetClassObject(rclsid, wszDllPath, _IID_IClassFactory, (void**)&classFactory, &hDll));

// Ask the class factory to create an instance of the

// necessary object.

IfFailRet(classFactory->CreateInstance(NULL, riid, ppv));

hDll.SuppressRelease();

if (phmodDll != NULL)

{

*phmodDll = hDll.GetValue();

}

return hr;

}

//

// Allocate free memory with specific alignment.

//

LPVOID ClrVirtualAllocAligned(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect, SIZE_T alignment)

{

// Verify that the alignment is a power of 2

_ASSERTE(alignment != 0);

_ASSERTE((alignment & (alignment - 1)) == 0);

#ifdef HOST_WINDOWS

// The VirtualAlloc on Windows ensures 64kB alignment

_ASSERTE(alignment <= 0x10000);

return ClrVirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect);

#else // HOST_WINDOWS

if(alignment < GetOsPageSize()) alignment = GetOsPageSize();

// UNIXTODO: Add a specialized function to PAL so that we don't have to waste memory

dwSize += alignment;

SIZE_T addr = (SIZE_T)ClrVirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect);

return (LPVOID)((addr + (alignment - 1)) & ~(alignment - 1));

#endif // HOST_WINDOWS

}

#ifdef _DEBUG

static DWORD ShouldInjectFaultInRange()

{

static DWORD fInjectFaultInRange = 99;

if (fInjectFaultInRange == 99)

fInjectFaultInRange = (CLRConfig::GetConfigValue(CLRConfig::INTERNAL_InjectFault) & 0x40);

return fInjectFaultInRange;

}

#endif

// Reserves free memory within the range [pMinAddr..pMaxAddr] using

// ClrVirtualQuery to find free memory and ClrVirtualAlloc to reserve it.

//

// This method only supports the flAllocationType of MEM_RESERVE, and expects that the memory

// is being reserved for the purpose of eventually storing executable code.

//

// Callers also should set dwSize to a multiple of sysInfo.dwAllocationGranularity (64k).

// That way they can reserve a large region and commit smaller sized pages

// from that region until it fills up.

//

// This functions returns the reserved memory block upon success

//

// It returns NULL when it fails to find any memory that satisfies

// the range.

//

BYTE * ClrVirtualAllocWithinRange(const BYTE *pMinAddr,

const BYTE *pMaxAddr,

SIZE_T dwSize,

DWORD flAllocationType,

DWORD flProtect)

{

CONTRACTL

{

NOTHROW;

PRECONDITION(dwSize != 0);

#ifdef HOST_UNIX

PRECONDITION(flAllocationType == (MEM_RESERVE | MEM_RESERVE_EXECUTABLE));

#else

PRECONDITION(flAllocationType == MEM_RESERVE);

#endif

}

CONTRACTL_END;

BYTE *pResult = nullptr; // our return value;

static unsigned countOfCalls = 0; // We log the number of tims we call this method

countOfCalls++; // increment the call counter

if (dwSize == 0)

{

return nullptr;

}

//

// First lets normalize the pMinAddr and pMaxAddr values

//

// If pMinAddr is NULL then set it to BOT_MEMORY

if ((pMinAddr == 0) || (pMinAddr < (BYTE *) BOT_MEMORY))

{

pMinAddr = (BYTE *) BOT_MEMORY;

}

// If pMaxAddr is NULL then set it to TOP_MEMORY

if ((pMaxAddr == 0) || (pMaxAddr > (BYTE *) TOP_MEMORY))

{

pMaxAddr = (BYTE *) TOP_MEMORY;

}

// If pMaxAddr is not greater than pMinAddr we can not make an allocation

if (pMaxAddr <= pMinAddr)

{

return nullptr;

}

// If pMinAddr is BOT_MEMORY and pMaxAddr is TOP_MEMORY

// then we can call ClrVirtualAlloc instead

if ((pMinAddr == (BYTE *) BOT_MEMORY) && (pMaxAddr == (BYTE *) TOP_MEMORY))

{

return (BYTE*) ClrVirtualAlloc(nullptr, dwSize, flAllocationType, flProtect);

}

#ifdef HOST_UNIX

pResult = (BYTE *)PAL_VirtualReserveFromExecutableMemoryAllocatorWithinRange(pMinAddr, pMaxAddr, dwSize, TRUE /* fStoreAllocationInfo */);

if (pResult != nullptr)

{

return pResult;

}

#endif // HOST_UNIX

// We will do one scan from [pMinAddr .. pMaxAddr]

// First align the tryAddr up to next 64k base address.

// See docs for VirtualAllocEx and lpAddress and 64k alignment for reasons.

//

BYTE * tryAddr = (BYTE *)ALIGN_UP((BYTE *)pMinAddr, VIRTUAL_ALLOC_RESERVE_GRANULARITY);

bool virtualQueryFailed = false;

bool faultInjected = false;

unsigned virtualQueryCount = 0;

// Now scan memory and try to find a free block of the size requested.

while ((tryAddr + dwSize) <= (BYTE *) pMaxAddr)

{

MEMORY_BASIC_INFORMATION mbInfo;

// Use VirtualQuery to find out if this address is MEM_FREE

//

virtualQueryCount++;

if (!ClrVirtualQuery((LPCVOID)tryAddr, &mbInfo, sizeof(mbInfo)))

{

// Exit and return nullptr if the VirtualQuery call fails.

virtualQueryFailed = true;

break;

}

// Is there enough memory free from this start location?

// Note that for most versions of UNIX the mbInfo.RegionSize returned will always be 0

if ((mbInfo.State == MEM_FREE) &&

(mbInfo.RegionSize >= (SIZE_T) dwSize || mbInfo.RegionSize == 0))

{

// Try reserving the memory using VirtualAlloc now

pResult = (BYTE*)ClrVirtualAlloc(tryAddr, dwSize, flAllocationType, flProtect);

// Normally this will be successful

//

if (pResult != nullptr)

{

// return pResult

break;

}

#ifdef _DEBUG

if (ShouldInjectFaultInRange())

{

// return nullptr (failure)

faultInjected = true;

break;

}

#endif // _DEBUG

// On UNIX we can also fail if our request size 'dwSize' is larger than 64K and

// and our tryAddr is pointing at a small MEM_FREE region (smaller than 'dwSize')

// However we can't distinguish between this and the race case.

// We might fail in a race. So just move on to next region and continue trying

tryAddr = tryAddr + VIRTUAL_ALLOC_RESERVE_GRANULARITY;

}

else

{

// Try another section of memory

tryAddr = max(tryAddr + VIRTUAL_ALLOC_RESERVE_GRANULARITY,

(BYTE*) mbInfo.BaseAddress + mbInfo.RegionSize);

}

}

STRESS_LOG7(LF_JIT, LL_INFO100,

"ClrVirtualAllocWithinRange request #%u for %08x bytes in [ %p .. %p ], query count was %u - returned %s: %p\n",

countOfCalls, (DWORD)dwSize, pMinAddr, pMaxAddr,

virtualQueryCount, (pResult != nullptr) ? "success" : "failure", pResult);

// If we failed this call the process will typically be terminated

// so we log any additional reason for failing this call.

//

if (pResult == nullptr)

{

if ((tryAddr + dwSize) > (BYTE *)pMaxAddr)

{

// Our tryAddr reached pMaxAddr

STRESS_LOG0(LF_JIT, LL_INFO100, "Additional reason: Address space exhausted.\n");

}

if (virtualQueryFailed)

{

STRESS_LOG0(LF_JIT, LL_INFO100, "Additional reason: VirtualQuery operation failed.\n");

}

if (faultInjected)

{

STRESS_LOG0(LF_JIT, LL_INFO100, "Additional reason: fault injected.\n");

}

}

return pResult;

}

#ifdef HOST_WINDOWS

//******************************************************************************

// CPUGroupInfo

//******************************************************************************

/*static*/ BOOL CPUGroupInfo::GetLogicalProcessorInformationEx(LOGICAL_PROCESSOR_RELATIONSHIP relationship,

SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *slpiex, PDWORD count)

{

LIMITED_METHOD_CONTRACT;

return ::GetLogicalProcessorInformationEx(relationship, slpiex, count);

}

/*static*/ BOOL CPUGroupInfo::SetThreadGroupAffinity(HANDLE h,

const GROUP_AFFINITY *groupAffinity, GROUP_AFFINITY *previousGroupAffinity)

{

LIMITED_METHOD_CONTRACT;

return ::SetThreadGroupAffinity(h, groupAffinity, previousGroupAffinity);

}

/*static*/ BOOL CPUGroupInfo::GetThreadGroupAffinity(HANDLE h, GROUP_AFFINITY *groupAffinity)

{

LIMITED_METHOD_CONTRACT;

return ::GetThreadGroupAffinity(h, groupAffinity);

}

/*static*/ BOOL CPUGroupInfo::GetSystemTimes(FILETIME *idleTime, FILETIME *kernelTime, FILETIME *userTime)

{

LIMITED_METHOD_CONTRACT;

return ::GetSystemTimes(idleTime, kernelTime, userTime);

}

/*static*/ BOOL CPUGroupInfo::m_enableGCCPUGroups = FALSE;

/*static*/ BOOL CPUGroupInfo::m_threadUseAllCpuGroups = FALSE;

/*static*/ BOOL CPUGroupInfo::m_threadAssignCpuGroups = FALSE;

/*static*/ WORD CPUGroupInfo::m_nGroups = 0;

/*static*/ WORD CPUGroupInfo::m_nProcessors = 0;

/*static*/ WORD CPUGroupInfo::m_initialGroup = 0;

/*static*/ CPU_Group_Info *CPUGroupInfo::m_CPUGroupInfoArray = NULL;

/*static*/ LONG CPUGroupInfo::m_initialization = 0;

#if defined(TARGET_AMD64) || defined(TARGET_ARM64)

// Calculate greatest common divisor

DWORD GCD(DWORD u, DWORD v)

{

while (v != 0)

{

DWORD dwTemp = v;

v = u % v;

u = dwTemp;

}

return u;

}

// Calculate least common multiple

DWORD LCM(DWORD u, DWORD v)

{

return u / GCD(u, v) * v;

}

#endif

/*static*/ BOOL CPUGroupInfo::InitCPUGroupInfoArray()

{

CONTRACTL

{

NOTHROW;

GC_NOTRIGGER;

}

CONTRACTL_END;

#if defined(TARGET_AMD64) || defined(TARGET_ARM64)

BYTE *bBuffer = NULL;

SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *pSLPIEx = NULL;

SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *pRecord = NULL;

DWORD cbSLPIEx = 0;

DWORD byteOffset = 0;

DWORD dwNumElements = 0;

DWORD dwWeight = 1;

if (CPUGroupInfo::GetLogicalProcessorInformationEx(RelationGroup, pSLPIEx, &cbSLPIEx) ||

GetLastError() != ERROR_INSUFFICIENT_BUFFER)

return FALSE;

_ASSERTE(cbSLPIEx);

// Fail to allocate buffer

bBuffer = new (nothrow) BYTE[ cbSLPIEx ];

if (bBuffer == NULL)

return FALSE;

pSLPIEx = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *)bBuffer;

if (!::GetLogicalProcessorInformationEx(RelationGroup, pSLPIEx, &cbSLPIEx))

{

delete[] bBuffer;

return FALSE;

}

pRecord = pSLPIEx;

while (byteOffset < cbSLPIEx)

{

if (pRecord->Relationship == RelationGroup)

{

m_nGroups = pRecord->Group.ActiveGroupCount;

break;

}

byteOffset += pRecord->Size;

pRecord = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *)(bBuffer + byteOffset);

}

m_CPUGroupInfoArray = new (nothrow) CPU_Group_Info[m_nGroups];

if (m_CPUGroupInfoArray == NULL)

{

delete[] bBuffer;

return FALSE;

}

for (DWORD i = 0; i < m_nGroups; i++)

{

m_CPUGroupInfoArray[i].nr_active = (WORD)pRecord->Group.GroupInfo[i].ActiveProcessorCount;

m_CPUGroupInfoArray[i].active_mask = pRecord->Group.GroupInfo[i].ActiveProcessorMask;

m_CPUGroupInfoArray[i].begin = m_nProcessors;

m_nProcessors += m_CPUGroupInfoArray[i].nr_active;

dwWeight = LCM(dwWeight, (DWORD)m_CPUGroupInfoArray[i].nr_active);

}

// The number of threads per group that can be supported will depend on the number of CPU groups

// and the number of LPs within each processor group. For example, when the number of LPs in

// CPU groups is the same and is 64, the number of threads per group before weight overflow

// would be 2^32/2^6 = 2^26 (64M threads)

for (DWORD i = 0; i < m_nGroups; i++)

{

m_CPUGroupInfoArray[i].groupWeight = dwWeight / (DWORD)m_CPUGroupInfoArray[i].nr_active;

m_CPUGroupInfoArray[i].activeThreadWeight = 0;

}

delete[] bBuffer; // done with it; free it

return TRUE;

#else

return FALSE;

#endif

}

/*static*/ void CPUGroupInfo::InitCPUGroupInfo()

{

CONTRACTL

{

NOTHROW;

GC_NOTRIGGER;

}

CONTRACTL_END;

#if defined(TARGET_AMD64) || defined(TARGET_ARM64)

USHORT groupCount = 0;

// On Windows 11+ and Windows Server 2022+, a process is no longer restricted to a single processor group by default.

// If more than one processor group is available to the process (a non-affinitized process on Windows 11+),

// default to using multiple processor groups; otherwise, default to using a single processor group. This default

// behavior may be overridden by the configuration values below.

if (GetProcessGroupAffinity(GetCurrentProcess(), &groupCount, NULL) || GetLastError() != ERROR_INSUFFICIENT_BUFFER)

groupCount = 1;

BOOL enableGCCPUGroups = Configuration::GetKnobBooleanValue(W("System.GC.CpuGroup"), CLRConfig::EXTERNAL_GCCpuGroup, groupCount > 1);

if (!enableGCCPUGroups)

return;

if (!InitCPUGroupInfoArray())

return;

// Enable processor groups only if more than one group exists

if (m_nGroups > 1)

{

m_enableGCCPUGroups = TRUE;

m_threadUseAllCpuGroups = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_Thread_UseAllCpuGroups, groupCount > 1) != 0;

m_threadAssignCpuGroups = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_Thread_AssignCpuGroups) != 0;

// Save the processor group affinity of the initial thread

GROUP_AFFINITY groupAffinity;

CPUGroupInfo::GetThreadGroupAffinity(GetCurrentThread(), &groupAffinity);

m_initialGroup = groupAffinity.Group;

}

#endif

}

/*static*/ BOOL CPUGroupInfo::IsInitialized()

{

LIMITED_METHOD_CONTRACT;

return VolatileLoad(&m_initialization) == -1;

}

/*static*/ void CPUGroupInfo::EnsureInitialized()

{

CONTRACTL

{

NOTHROW;

GC_NOTRIGGER;

}

CONTRACTL_END;

// CPUGroupInfo needs to be initialized only once. This could happen in three cases

// 1. CLR initialization at beginning of EEStartup, or

// 2. Sometimes, when hosted by ASP.NET, the hosting process may initialize ThreadPool

// before initializing CLR, thus require CPUGroupInfo to be initialized to determine

// if CPU group support should/could be enabled.

// 3. Call into Threadpool functions before Threadpool _and_ CLR is initialized.

// Vast majority of time, CPUGroupInfo is initialized in case 1. or 2.

// The chance of contention will be extremely small, so the following code should be fine

//

if (IsInitialized())

return;

if (InterlockedCompareExchange(&m_initialization, 1, 0) == 0)

{

InitCPUGroupInfo();

VolatileStore(&m_initialization, -1L);

}

else

{

// Some other thread started initialization, just wait until complete

while (VolatileLoad(&m_initialization) != -1)

{

SwitchToThread();

}

}

}

/*static*/ WORD CPUGroupInfo::GetNumActiveProcessors()

{

LIMITED_METHOD_CONTRACT;

return (WORD)m_nProcessors;

}

/*static*/ void CPUGroupInfo::GetGroupForProcessor(WORD processor_number,

WORD* group_number, WORD* group_processor_number)

{

LIMITED_METHOD_CONTRACT;

#if defined(TARGET_AMD64) || defined(TARGET_ARM64)

WORD bTemp = 0;

WORD bDiff = processor_number - bTemp;

for (WORD i=0; i < m_nGroups; i++)

{

bTemp += m_CPUGroupInfoArray[i].nr_active;

if (bTemp > processor_number)

{

*group_number = i;

*group_processor_number = bDiff;

break;

}

bDiff = processor_number - bTemp;

}

#else

*group_number = 0;

*group_processor_number = 0;

#endif

}

/*static*/ DWORD CPUGroupInfo::CalculateCurrentProcessorNumber()

{

CONTRACTL

{

NOTHROW;

GC_NOTRIGGER;

}

CONTRACTL_END;

#if defined(TARGET_AMD64) || defined(TARGET_ARM64)

_ASSERTE(m_enableGCCPUGroups && m_threadUseAllCpuGroups);

PROCESSOR_NUMBER proc_no;

proc_no.Group=0;

proc_no.Number=0;

proc_no.Reserved=0;

::GetCurrentProcessorNumberEx(&proc_no);

DWORD fullNumber = 0;

for (WORD i = 0; i < proc_no.Group; i++)

fullNumber += (DWORD)m_CPUGroupInfoArray[i].nr_active;

fullNumber += (DWORD)(proc_no.Number);

return fullNumber;

#else

return 0;

#endif

}

// There can be different numbers of procs in groups. We take the max.

/*static*/ bool CPUGroupInfo::GetCPUGroupInfo(PUSHORT total_groups, DWORD* max_procs_per_group)

{

if (m_enableGCCPUGroups)

{

*total_groups = m_nGroups;

DWORD currentProcsInGroup = 0;

for (WORD i = 0; i < m_nGroups; i++)

{

currentProcsInGroup = max(currentProcsInGroup, (DWORD)m_CPUGroupInfoArray[i].nr_active);

}

*max_procs_per_group = currentProcsInGroup;

return true;

}

return false;

}

//Lock ThreadStore before calling this function, so that updates of weights/counts are consistent

/*static*/ void CPUGroupInfo::ChooseCPUGroupAffinity(GROUP_AFFINITY *gf)

{

CONTRACTL

{

NOTHROW;

GC_NOTRIGGER;

}

CONTRACTL_END;

#if defined(TARGET_AMD64) || defined(TARGET_ARM64)

WORD i, minGroup = 0;

DWORD minWeight = 0;

_ASSERTE(m_enableGCCPUGroups && m_threadUseAllCpuGroups && m_threadAssignCpuGroups);

for (i = 0; i < m_nGroups; i++)

{

minGroup = (m_initialGroup + i) % m_nGroups;

// the group is not filled up, use it

if (m_CPUGroupInfoArray[minGroup].activeThreadWeight / m_CPUGroupInfoArray[minGroup].groupWeight

< (DWORD)m_CPUGroupInfoArray[minGroup].nr_active)

goto found;

}

// all groups filled up, distribute proportionally

minGroup = m_initialGroup;

minWeight = m_CPUGroupInfoArray[m_initialGroup].activeThreadWeight;

for (i = 0; i < m_nGroups; i++)

{

if (m_CPUGroupInfoArray[i].activeThreadWeight < minWeight)

{

minGroup = i;

minWeight = m_CPUGroupInfoArray[i].activeThreadWeight;

}

}

found:

gf->Group = minGroup;

gf->Mask = m_CPUGroupInfoArray[minGroup].active_mask;

gf->Reserved[0] = 0;

gf->Reserved[1] = 0;

gf->Reserved[2] = 0;

m_CPUGroupInfoArray[minGroup].activeThreadWeight += m_CPUGroupInfoArray[minGroup].groupWeight;

#endif

}

//Lock ThreadStore before calling this function, so that updates of weights/counts are consistent

/*static*/ void CPUGroupInfo::ClearCPUGroupAffinity(GROUP_AFFINITY *gf)

{

LIMITED_METHOD_CONTRACT;

#if defined(TARGET_AMD64) || defined(TARGET_ARM64)

_ASSERTE(m_enableGCCPUGroups && m_threadUseAllCpuGroups && m_threadAssignCpuGroups);

WORD group = gf->Group;

m_CPUGroupInfoArray[group].activeThreadWeight -= m_CPUGroupInfoArray[group].groupWeight;

#endif

}

BOOL CPUGroupInfo::GetCPUGroupRange(WORD group_number, WORD* group_begin, WORD* group_size)

{

if (group_number >= m_nGroups)

{

return FALSE;

}

*group_begin = m_CPUGroupInfoArray[group_number].begin;

*group_size = m_CPUGroupInfoArray[group_number].nr_active;

return TRUE;

}

/*static*/ BOOL CPUGroupInfo::CanEnableGCCPUGroups()

{

LIMITED_METHOD_CONTRACT;

return m_enableGCCPUGroups;

}

/*static*/ BOOL CPUGroupInfo::CanEnableThreadUseAllCpuGroups()

{

LIMITED_METHOD_CONTRACT;

_ASSERTE(m_enableGCCPUGroups || !m_threadUseAllCpuGroups);

return m_threadUseAllCpuGroups;

}

/*static*/ BOOL CPUGroupInfo::CanAssignCpuGroupsToThreads()

{

LIMITED_METHOD_CONTRACT;

_ASSERTE(m_enableGCCPUGroups || !m_threadAssignCpuGroups);

return m_threadAssignCpuGroups;

}

#endif // HOST_WINDOWS

extern SYSTEM_INFO g_SystemInfo;

int GetTotalProcessorCount()

{

LIMITED_METHOD_CONTRACT;

#ifdef HOST_WINDOWS

if (CPUGroupInfo::CanEnableGCCPUGroups())

{

return CPUGroupInfo::GetNumActiveProcessors();

}

else

{

return g_SystemInfo.dwNumberOfProcessors;

}

#else // HOST_WINDOWS

return PAL_GetTotalCpuCount();

#endif // HOST_WINDOWS

}

// The cached number of CPUs available for the current process

static DWORD g_currentProcessCpuCount = 0;

//******************************************************************************

// Returns the number of processors that a process has been configured to run on

//******************************************************************************

int GetCurrentProcessCpuCount()

{

CONTRACTL

{

NOTHROW;

CANNOT_TAKE_LOCK;

}

CONTRACTL_END;

if (g_currentProcessCpuCount > 0)

return g_currentProcessCpuCount;

DWORD count;