diff options
Diffstat (limited to 'src/vm/win32threadpool.cpp')
| -rw-r--r-- | src/vm/win32threadpool.cpp | 538 |
1 files changed, 70 insertions, 468 deletions
diff --git a/src/vm/win32threadpool.cpp b/src/vm/win32threadpool.cpp index e8a05c383f..bc84762b06 100644 --- a/src/vm/win32threadpool.cpp +++ b/src/vm/win32threadpool.cpp @@ -448,21 +448,6 @@ BOOL ThreadpoolMgr::Initialize() CPThreadCounter.counts.AsLongLong = counts.AsLongLong; #ifndef FEATURE_PAL -#ifdef FEATURE_INCLUDE_ALL_INTERFACES - if (CLRIoCompletionHosted()) - { - HANDLE hPort; - HRESULT hr; - BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread()); - hr = CorHost2::GetHostIoCompletionManager()->CreateIoCompletionPort(&hPort); - END_SO_TOLERANT_CODE_CALLING_HOST; - if (FAILED(hr)) - goto end; - - GlobalCompletionPort = hPort; - } - else -#endif // FEATURE_INCLUDE_ALL_INTERFACES { GlobalCompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, @@ -568,7 +553,7 @@ BOOL ThreadpoolMgr::SetMaxThreadsHelper(DWORD MaxWorkerThreads, /************************************************************************/ BOOL ThreadpoolMgr::SetMaxThreads(DWORD MaxWorkerThreads, - DWORD MaxIOCompletionThreads) + DWORD MaxIOCompletionThreads) { CONTRACTL { @@ -578,96 +563,16 @@ BOOL ThreadpoolMgr::SetMaxThreads(DWORD MaxWorkerThreads, } CONTRACTL_END; -#ifdef FEATURE_INCLUDE_ALL_INTERFACES - IHostThreadpoolManager *threadpoolProvider = CorHost2::GetHostThreadpoolManager(); - if (threadpoolProvider) { - HRESULT hr; - BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread()); - hr = threadpoolProvider->SetMaxThreads(MaxWorkerThreads); - END_SO_TOLERANT_CODE_CALLING_HOST; - if (FAILED(hr)) - { - SetLastHRError(hr); - return FALSE; - } - } - - IHostIoCompletionManager *ioCompletionProvider = CorHost2::GetHostIoCompletionManager(); - if (ioCompletionProvider) { - HRESULT hr; - BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread()); - hr = ioCompletionProvider->SetMaxThreads(MaxIOCompletionThreads); - END_SO_TOLERANT_CODE_CALLING_HOST; - if (FAILED(hr)) - { - SetLastHRError(hr); - return FALSE; - } - } - - if (threadpoolProvider && ioCompletionProvider) { - return TRUE; - } -#endif // FEATURE_INCLUDE_ALL_INTERFACES - - if (IsInitialized()) - { - return SetMaxThreadsHelper(MaxWorkerThreads, MaxIOCompletionThreads); - } - - if (InterlockedCompareExchange(&Initialization, 1, 0) == 0) - { - Initialize(); - - BOOL helper_result = FALSE; - helper_result = SetMaxThreadsHelper(MaxWorkerThreads, MaxIOCompletionThreads); - - Initialization = -1; - return helper_result; - } - else // someone else is initializing. Too late, return false - { - return FALSE; - } + EnsureInitialized(); + return SetMaxThreadsHelper(MaxWorkerThreads, MaxIOCompletionThreads); } BOOL ThreadpoolMgr::GetMaxThreads(DWORD* MaxWorkerThreads, - DWORD* MaxIOCompletionThreads) + DWORD* MaxIOCompletionThreads) { LIMITED_METHOD_CONTRACT; -#ifdef FEATURE_INCLUDE_ALL_INTERFACES - HRESULT hr = S_OK; - - IHostThreadpoolManager *threadpoolProvider = CorHost2::GetHostThreadpoolManager(); - if (threadpoolProvider) { - BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread()); - hr = threadpoolProvider->GetMaxThreads(MaxWorkerThreads); - END_SO_TOLERANT_CODE_CALLING_HOST; - if (FAILED(hr)) - { - SetLastHRError(hr); - return FALSE; - } - } - - IHostIoCompletionManager *ioCompletionProvider = CorHost2::GetHostIoCompletionManager(); - if (ioCompletionProvider) { - BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread()); - hr = ioCompletionProvider->GetMaxThreads(MaxIOCompletionThreads); - END_SO_TOLERANT_CODE_CALLING_HOST; - if (FAILED(hr)) - { - SetLastHRError(hr); - return FALSE; - } - } - - if (threadpoolProvider && ioCompletionProvider) { - return TRUE; - } -#endif // FEATURE_INCLUDE_ALL_INTERFACES if (!MaxWorkerThreads || !MaxIOCompletionThreads) { @@ -675,44 +580,15 @@ BOOL ThreadpoolMgr::GetMaxThreads(DWORD* MaxWorkerThreads, return FALSE; } - if (IsInitialized()) - { - *MaxWorkerThreads = (DWORD)MaxLimitTotalWorkerThreads; - *MaxIOCompletionThreads = MaxLimitTotalCPThreads; - } - else - { - BEGIN_SO_INTOLERANT_CODE_NOTHROW(GetThread(), *MaxWorkerThreads = 1024); - - //ThreadPool_CPUGroup - CPUGroupInfo::EnsureInitialized(); - if (CPUGroupInfo::CanEnableGCCPUGroups() && CPUGroupInfo::CanEnableThreadUseAllCpuGroups()) - NumberOfProcessors = CPUGroupInfo::GetNumActiveProcessors(); - else - NumberOfProcessors = GetCurrentProcessCpuCount(); - DWORD min = GetForceMinWorkerThreadsValue(); - if (min == 0) - min = NumberOfProcessors; - - DWORD forceMax = GetForceMaxWorkerThreadsValue(); - if (forceMax > 0) - { - *MaxWorkerThreads = forceMax; - } - else - { - *MaxWorkerThreads = GetDefaultMaxLimitWorkerThreads(min); - } - - END_SO_INTOLERANT_CODE; + EnsureInitialized(); - *MaxIOCompletionThreads = MaxLimitTotalCPThreads; - } + *MaxWorkerThreads = (DWORD)MaxLimitTotalWorkerThreads; + *MaxIOCompletionThreads = MaxLimitTotalCPThreads; return TRUE; } BOOL ThreadpoolMgr::SetMinThreads(DWORD MinWorkerThreads, - DWORD MinIOCompletionThreads) + DWORD MinIOCompletionThreads) { CONTRACTL { @@ -722,139 +598,64 @@ BOOL ThreadpoolMgr::SetMinThreads(DWORD MinWorkerThreads, } CONTRACTL_END; -#ifdef FEATURE_INCLUDE_ALL_INTERFACES - HRESULT hr = S_OK; - - IHostThreadpoolManager *threadpoolProvider = CorHost2::GetHostThreadpoolManager(); - if (threadpoolProvider) { - BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread()); - hr = threadpoolProvider->SetMinThreads(MinWorkerThreads); - END_SO_TOLERANT_CODE_CALLING_HOST; - if (FAILED(hr)) - { - SetLastHRError(hr); - return FALSE; - } - } + EnsureInitialized(); - IHostIoCompletionManager *ioCompletionProvider = CorHost2::GetHostIoCompletionManager(); - if (ioCompletionProvider) { - BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread()); - hr = ioCompletionProvider->SetMinThreads(MinIOCompletionThreads); - END_SO_TOLERANT_CODE_CALLING_HOST; - if (FAILED(hr)) - { - SetLastHRError(hr); - return FALSE; - } - } - if (threadpoolProvider && ioCompletionProvider) { - return TRUE; - } -#endif // FEATURE_INCLUDE_ALL_INTERFACES + // doesn't need to be WorkerCS, but using it to avoid race condition between setting min and max, and didn't want to create a new CS. + CrstHolder csh(&WorkerCriticalSection); - if (!IsInitialized()) - { - if (InterlockedCompareExchange(&Initialization, 1, 0) == 0) - { - Initialize(); - Initialization = -1; - } - } + BOOL init_result = FALSE; - if (IsInitialized()) + if (MinWorkerThreads >= 0 && MinIOCompletionThreads >= 0 && + MinWorkerThreads <= (DWORD) MaxLimitTotalWorkerThreads && + MinIOCompletionThreads <= (DWORD) MaxLimitTotalCPThreads) { - // doesn't need to be WorkerCS, but using it to avoid race condition between setting min and max, and didn't want to create a new CS. - CrstHolder csh(&WorkerCriticalSection); - - BOOL init_result = false; + BEGIN_SO_INTOLERANT_CODE(GetThread()); - if (MinWorkerThreads >= 0 && MinIOCompletionThreads >= 0 && - MinWorkerThreads <= (DWORD) MaxLimitTotalWorkerThreads && - MinIOCompletionThreads <= (DWORD) MaxLimitTotalCPThreads) + if (GetForceMinWorkerThreadsValue() == 0) { - BEGIN_SO_INTOLERANT_CODE(GetThread()); + MinLimitTotalWorkerThreads = min(MinWorkerThreads, (DWORD)ThreadCounter::MaxPossibleCount); - if (GetForceMinWorkerThreadsValue() == 0) + ThreadCounter::Counts counts = WorkerCounter.GetCleanCounts(); + while (counts.MaxWorking < MinLimitTotalWorkerThreads) { - MinLimitTotalWorkerThreads = min(MinWorkerThreads, (DWORD)ThreadCounter::MaxPossibleCount); + ThreadCounter::Counts newCounts = counts; + newCounts.MaxWorking = MinLimitTotalWorkerThreads; - ThreadCounter::Counts counts = WorkerCounter.GetCleanCounts(); - while (counts.MaxWorking < MinLimitTotalWorkerThreads) + ThreadCounter::Counts oldCounts = WorkerCounter.CompareExchangeCounts(newCounts, counts); + if (oldCounts == counts) { - ThreadCounter::Counts newCounts = counts; - newCounts.MaxWorking = MinLimitTotalWorkerThreads; - - ThreadCounter::Counts oldCounts = WorkerCounter.CompareExchangeCounts(newCounts, counts); - if (oldCounts == counts) - { - counts = newCounts; + counts = newCounts; - // if we increased the limit, and there are pending workitems, we need - // to dispatch a thread to process the work. - if (newCounts.MaxWorking > oldCounts.MaxWorking && - PerAppDomainTPCountList::AreRequestsPendingInAnyAppDomains()) - { - MaybeAddWorkingWorker(); - } - } - else + // if we increased the limit, and there are pending workitems, we need + // to dispatch a thread to process the work. + if (newCounts.MaxWorking > oldCounts.MaxWorking && + PerAppDomainTPCountList::AreRequestsPendingInAnyAppDomains()) { - counts = oldCounts; + MaybeAddWorkingWorker(); } } + else + { + counts = oldCounts; + } } + } - END_SO_INTOLERANT_CODE; - - MinLimitTotalCPThreads = min(MinIOCompletionThreads, (DWORD)ThreadCounter::MaxPossibleCount); + END_SO_INTOLERANT_CODE; - init_result = TRUE; - } + MinLimitTotalCPThreads = min(MinIOCompletionThreads, (DWORD)ThreadCounter::MaxPossibleCount); - return init_result; + init_result = TRUE; } - // someone else is initializing. Too late, return false - return FALSE; + return init_result; } BOOL ThreadpoolMgr::GetMinThreads(DWORD* MinWorkerThreads, - DWORD* MinIOCompletionThreads) + DWORD* MinIOCompletionThreads) { LIMITED_METHOD_CONTRACT; -#ifdef FEATURE_INCLUDE_ALL_INTERFACES - HRESULT hr = S_OK; - - IHostThreadpoolManager *threadpoolProvider = CorHost2::GetHostThreadpoolManager(); - if (threadpoolProvider) { - BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread()); - hr = threadpoolProvider->GetMinThreads(MinWorkerThreads); - END_SO_TOLERANT_CODE_CALLING_HOST; - if (FAILED(hr)) - { - SetLastHRError(hr); - return FALSE; - } - } - - IHostIoCompletionManager *ioCompletionProvider = CorHost2::GetHostIoCompletionManager(); - if (ioCompletionProvider) { - BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread()); - hr = ioCompletionProvider->GetMinThreads(MinIOCompletionThreads); - END_SO_TOLERANT_CODE_CALLING_HOST; - if (FAILED(hr)) - { - SetLastHRError(hr); - return FALSE; - } - } - - if (threadpoolProvider && ioCompletionProvider) { - return TRUE; - } -#endif // FEATURE_INCLUDE_ALL_INTERFACES if (!MinWorkerThreads || !MinIOCompletionThreads) { @@ -862,25 +663,10 @@ BOOL ThreadpoolMgr::GetMinThreads(DWORD* MinWorkerThreads, return FALSE; } - if (IsInitialized()) - { - *MinWorkerThreads = (DWORD)MinLimitTotalWorkerThreads; - *MinIOCompletionThreads = MinLimitTotalCPThreads; - } - else - { - CPUGroupInfo::EnsureInitialized(); - if (CPUGroupInfo::CanEnableGCCPUGroups() && CPUGroupInfo::CanEnableThreadUseAllCpuGroups()) - NumberOfProcessors = CPUGroupInfo::GetNumActiveProcessors(); - else - NumberOfProcessors = GetCurrentProcessCpuCount(); - DWORD forceMin; - BEGIN_SO_INTOLERANT_CODE_NOTHROW(GetThread(), forceMin=0); - forceMin = GetForceMinWorkerThreadsValue(); - END_SO_INTOLERANT_CODE; - *MinWorkerThreads = forceMin > 0 ? forceMin : NumberOfProcessors; - *MinIOCompletionThreads = NumberOfProcessors; - } + EnsureInitialized(); + + *MinWorkerThreads = (DWORD)MinLimitTotalWorkerThreads; + *MinIOCompletionThreads = MinLimitTotalCPThreads; return TRUE; } @@ -889,63 +675,26 @@ BOOL ThreadpoolMgr::GetAvailableThreads(DWORD* AvailableWorkerThreads, { LIMITED_METHOD_CONTRACT; - if (IsInitialized()) + if (!AvailableWorkerThreads || !AvailableIOCompletionThreads) { -#ifdef FEATURE_INCLUDE_ALL_INTERFACES - HRESULT hr = S_OK; - - IHostThreadpoolManager *threadpoolProvider = CorHost2::GetHostThreadpoolManager(); - if (threadpoolProvider) { - BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread()); - hr = threadpoolProvider->GetAvailableThreads(AvailableWorkerThreads); - END_SO_TOLERANT_CODE_CALLING_HOST; - if (FAILED(hr)) - { - SetLastHRError(hr); - return FALSE; - } - } - - IHostIoCompletionManager *ioCompletionProvider = CorHost2::GetHostIoCompletionManager(); - if (ioCompletionProvider) { - BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread()); - hr = ioCompletionProvider->GetAvailableThreads(AvailableIOCompletionThreads); - END_SO_TOLERANT_CODE_CALLING_HOST; - if (FAILED(hr)) - { - SetLastHRError(hr); - return FALSE; - } - } - - if (threadpoolProvider && ioCompletionProvider) { - return TRUE; - } -#endif // FEATURE_INCLUDE_ALL_INTERFACES + SetLastHRError(ERROR_INVALID_DATA); + return FALSE; + } - if (!AvailableWorkerThreads || !AvailableIOCompletionThreads) - { - SetLastHRError(ERROR_INVALID_DATA); - return FALSE; - } + EnsureInitialized(); - ThreadCounter::Counts counts = WorkerCounter.GetCleanCounts(); + ThreadCounter::Counts counts = WorkerCounter.GetCleanCounts(); - if (MaxLimitTotalWorkerThreads < counts.NumActive) - *AvailableWorkerThreads = 0; - else - *AvailableWorkerThreads = MaxLimitTotalWorkerThreads - counts.NumWorking; + if (MaxLimitTotalWorkerThreads < counts.NumActive) + *AvailableWorkerThreads = 0; + else + *AvailableWorkerThreads = MaxLimitTotalWorkerThreads - counts.NumWorking; - counts = CPThreadCounter.GetCleanCounts(); - if (MaxLimitTotalCPThreads < counts.NumActive) - *AvailableIOCompletionThreads = counts.NumActive - counts.NumWorking; - else - *AvailableIOCompletionThreads = MaxLimitTotalCPThreads - counts.NumWorking; - } + counts = CPThreadCounter.GetCleanCounts(); + if (MaxLimitTotalCPThreads < counts.NumActive) + *AvailableIOCompletionThreads = counts.NumActive - counts.NumWorking; else - { - GetMaxThreads(AvailableWorkerThreads,AvailableIOCompletionThreads); - } + *AvailableIOCompletionThreads = MaxLimitTotalCPThreads - counts.NumWorking; return TRUE; } @@ -1078,33 +827,6 @@ BOOL ThreadpoolMgr::QueueUserWorkItem(LPTHREAD_START_ROUTINE Function, EnsureInitialized(); -#ifdef FEATURE_INCLUDE_ALL_INTERFACES - HRESULT hr = S_OK; - - IHostThreadpoolManager *provider = CorHost2::GetHostThreadpoolManager(); - if (provider) { - BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread()); - - if(UnmanagedTPRequest) - { - hr = provider->QueueUserWorkItem(Function, Context, Flags); - } - else - { - hr = provider->QueueUserWorkItem(ExecuteHostRequest, Context, Flags); - } - END_SO_TOLERANT_CODE_CALLING_HOST; - if (FAILED(hr)) - { - SetLastHRError(hr); - return FALSE; - } - else - { - return TRUE; - } - } -#endif // FEATURE_INCLUDE_ALL_INTERFACES if (Flags == CALL_OR_QUEUE) { @@ -1141,8 +863,6 @@ BOOL ThreadpoolMgr::QueueUserWorkItem(LPTHREAD_START_ROUTINE Function, bool ThreadpoolMgr::ShouldWorkerKeepRunning() { WRAPPER_NO_CONTRACT; - if (CLRThreadpoolHosted()) - return true; // // Maybe this thread should retire now. Let's see. @@ -1197,7 +917,6 @@ void ThreadpoolMgr::AdjustMaxWorkersActive() } CONTRACTL_END; - _ASSERTE(!CLRThreadpoolHosted()); _ASSERTE(ThreadAdjustmentLock.IsHeld()); DWORD currentTicks = GetTickCount(); @@ -1283,8 +1002,6 @@ void ThreadpoolMgr::MaybeAddWorkingWorker() } CONTRACTL_END; - _ASSERTE(!CLRThreadpoolHosted()); - // counts volatile read paired with CompareExchangeCounts loop set ThreadCounter::Counts counts = WorkerCounter.DangerousGetDirtyCounts(); ThreadCounter::Counts newCounts; @@ -1380,27 +1097,6 @@ BOOL ThreadpoolMgr::PostQueuedCompletionStatus(LPOVERLAPPED lpOverlapped, #ifndef FEATURE_PAL EnsureInitialized(); - // if hosted then we need to queue to worker thread, since hosting API doesn't include this method - if (CLRIoCompletionHosted()) - { - PostRequestHolder postRequest = MakePostRequest(Function, lpOverlapped); - if (postRequest) - { - // Will execute in the Default AppDomain - if (FALSE == QueueUserWorkItem(QUWIPostCompletion, postRequest, QUEUE_ONLY)) - { - return FALSE; - } - else - { - postRequest.SuppressRelease(); - return TRUE; - } - } - else - return FALSE; - } - _ASSERTE(GlobalCompletionPort != NULL); if (!InitCompletionPortThreadpool) @@ -1663,44 +1359,12 @@ BOOL ThreadpoolMgr::DrainCompletionPortQueue() } -DWORD __stdcall ThreadpoolMgr::QUWIPostCompletion(PVOID pArgs) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_ANY; - SO_INTOLERANT; - } - CONTRACTL_END; - - PostRequest* postRequest = (PostRequest*) pArgs; - - EX_TRY - { - (postRequest->Function)(postRequest->errorCode, postRequest->numBytesTransferred, postRequest->lpOverlapped); - } - EX_CATCH - { - RecycleMemory( postRequest, MEMTYPE_PostRequest ); - if (!SwallowUnhandledExceptions()) - EX_RETHROW; - } - EX_END_CATCH(SwallowAllExceptions); - return ERROR_SUCCESS; - -} - - // This is either made by a worker thread or a CP thread // indicated by threadTypeStatus void ThreadpoolMgr::EnsureGateThreadRunning() { LIMITED_METHOD_CONTRACT; - // The gate thread is only needed if the CLR is providing part of the ThreadPool implementation. - _ASSERTE(!CLRThreadpoolHosted() || !CLRIoCompletionHosted()); - while (true) { switch (GateThreadStatus) @@ -1750,9 +1414,6 @@ bool ThreadpoolMgr::ShouldGateThreadKeepRunning() { LIMITED_METHOD_CONTRACT; - // The gate thread is only needed if the CLR is providing part of the ThreadPool implementation. - _ASSERTE(!CLRThreadpoolHosted() || !CLRIoCompletionHosted()); - _ASSERTE(GateThreadStatus == GATE_THREAD_STATUS_WAITING_FOR_REQUEST || GateThreadStatus == GATE_THREAD_STATUS_REQUESTED); @@ -1780,8 +1441,7 @@ bool ThreadpoolMgr::ShouldGateThreadKeepRunning() // Are there any work requests in any worker queue? If so, we need a gate thread. // This imples that whenever a work queue goes from empty to non-empty, we need to call EnsureGateThreadRunning(). // - bool needGateThreadForWorkerThreads = - !CLRThreadpoolHosted() && + bool needGateThreadForWorkerThreads = PerAppDomainTPCountList::AreRequestsPendingInAnyAppDomains(); // @@ -1884,18 +1544,6 @@ void ThreadpoolMgr::ExecuteWorkRequest(bool* foundWork, bool* wasNotRecalled) return; } - if(IsThreadPoolHosted()) - { - //Only managed callBacks go this route under hosts. - //Also, since if we came here, atleast one managed requests was - //created, and that means atleast one app domain exists. - - if (index == -1) - { - index = 1; - } - } - if (index == -1) { pAdCount = PerAppDomainTPCountList::GetUnmanagedTPCount(); @@ -2050,9 +1698,6 @@ LPVOID ThreadpoolMgr::GetRecycledMemory(enum MemType memType) case MEMTYPE_WorkRequest: result = new WorkRequest; break; - case MEMTYPE_PostRequest: - result = new PostRequest; - break; default: _ASSERTE(!"Unknown Memtype"); result = NULL; @@ -2097,9 +1742,6 @@ void ThreadpoolMgr::RecycleMemory(LPVOID mem, enum MemType memType) case MEMTYPE_WorkRequest: delete (WorkRequest*) mem; break; - case MEMTYPE_PostRequest: - delete (PostRequest*) mem; - break; default: _ASSERTE(!"Unknown Memtype"); @@ -2110,7 +1752,7 @@ void ThreadpoolMgr::RecycleMemory(LPVOID mem, enum MemType memType) // This is to avoid the 64KB/1MB aliasing problem present on Pentium 4 processors, // which can significantly impact performance with HyperThreading enabled -DWORD __stdcall ThreadpoolMgr::intermediateThreadProc(PVOID arg) +DWORD WINAPI ThreadpoolMgr::intermediateThreadProc(PVOID arg) { WRAPPER_NO_CONTRACT; STATIC_CONTRACT_SO_INTOLERANT; @@ -2178,10 +1820,9 @@ Thread* ThreadpoolMgr::CreateUnimpersonatedThread(LPTHREAD_START_ROUTINE lpStart } else { #ifndef FEATURE_PAL - ThreadAffinityHolder affinityHolder(FALSE); HandleHolder token; BOOL bReverted = FALSE; - bOK = RevertIfImpersonated(&bReverted, &token, &affinityHolder); + bOK = RevertIfImpersonated(&bReverted, &token); if (bOK != TRUE) return NULL; #endif // !FEATURE_PAL @@ -2250,7 +1891,7 @@ BOOL ThreadpoolMgr::CreateWorkerThread() } -DWORD __stdcall ThreadpoolMgr::WorkerThreadStart(LPVOID lpArgs) +DWORD WINAPI ThreadpoolMgr::WorkerThreadStart(LPVOID lpArgs) { ClrFlsSetThreadType (ThreadType_Threadpool_Worker); @@ -2263,8 +1904,6 @@ DWORD __stdcall ThreadpoolMgr::WorkerThreadStart(LPVOID lpArgs) } CONTRACTL_END; - _ASSERTE(!CLRThreadpoolHosted()); - Thread *pThread = NULL; DWORD dwSwitchCount = 0; BOOL fThreadInit = FALSE; @@ -2949,7 +2588,7 @@ DWORD ThreadpoolMgr::MinimumRemainingWait(LIST_ENTRY* waitInfo, unsigned int num #pragma warning(disable:22008) // "Prefast integer overflow check on (0 + lval) is bogus. Tried local disable without luck, doing whole method." #endif -DWORD __stdcall ThreadpoolMgr::WaitThreadStart(LPVOID lpArgs) +DWORD WINAPI ThreadpoolMgr::WaitThreadStart(LPVOID lpArgs) { CONTRACTL { @@ -3216,7 +2855,7 @@ void ThreadpoolMgr::ProcessWaitCompletion(WaitInfo* waitInfo, } -DWORD __stdcall ThreadpoolMgr::AsyncCallbackCompletion(PVOID pArgs) +DWORD WINAPI ThreadpoolMgr::AsyncCallbackCompletion(PVOID pArgs) { CONTRACTL { @@ -3529,9 +3168,6 @@ BOOL ThreadpoolMgr::CreateGateThread() { LIMITED_METHOD_CONTRACT; - // The gate thread is only needed if the CLR is providing part of the ThreadPool implementation. - _ASSERTE(!CLRThreadpoolHosted() || !CLRIoCompletionHosted()); - HANDLE threadHandle = Thread::CreateUtilityThread(Thread::StackSize_Small, GateThreadStart, NULL); if (threadHandle) @@ -3567,23 +3203,6 @@ BOOL ThreadpoolMgr::BindIoCompletionCallback(HANDLE FileHandle, EnsureInitialized(); -#ifdef FEATURE_INCLUDE_ALL_INTERFACES - IHostIoCompletionManager *provider = CorHost2::GetHostIoCompletionManager(); - if (provider) { - BEGIN_SO_TOLERANT_CODE_CALLING_HOST(GetThread()); - errCode = provider->Bind(GlobalCompletionPort, FileHandle); - END_SO_TOLERANT_CODE_CALLING_HOST; - if (FAILED(errCode)) - { - SetLastHRError(errCode); - return FALSE; - } - else - { - return TRUE; - } - } -#endif // FEATURE_INCLUDE_ALL_INTERFACES _ASSERTE(GlobalCompletionPort != NULL); @@ -3649,7 +3268,7 @@ BOOL ThreadpoolMgr::CreateCompletionPortThread(LPVOID lpArgs) return FALSE; } -DWORD __stdcall ThreadpoolMgr::CompletionPortThreadStart(LPVOID lpArgs) +DWORD WINAPI ThreadpoolMgr::CompletionPortThreadStart(LPVOID lpArgs) { ClrFlsSetThreadType (ThreadType_Threadpool_IOCompletion); @@ -3662,8 +3281,6 @@ DWORD __stdcall ThreadpoolMgr::CompletionPortThreadStart(LPVOID lpArgs) } CONTRACTL_END; - _ASSERTE (!CLRIoCompletionHosted()); - DWORD numBytes=0; size_t key=0; @@ -3808,8 +3425,6 @@ Top: { _ASSERTE (context == NULL || context->lpOverlapped == NULL); - LeaveRuntimeHolder holder((size_t)GetQueuedCompletionStatus); - BOOL status = GetQueuedCompletionStatus( GlobalCompletionPort, &numBytes, @@ -4109,15 +3724,8 @@ LPOVERLAPPED ThreadpoolMgr::CompletionPortDispatchWorkWithinAppDomain( OVERLAPPEDDATAREF overlapped=NULL; BOOL ManagedCallback=FALSE; - if (CLRIoCompletionHosted()) - { - return NULL; - } - *pErrorCode = S_OK; - LeaveRuntimeHolder holder((size_t)GetQueuedCompletionStatus); - //Very Very Important! //Do not change the timeout for GetQueuedCompletionStatus to a non-zero value. @@ -4504,7 +4112,7 @@ public: }; -DWORD __stdcall ThreadpoolMgr::GateThreadStart(LPVOID lpArgs) +DWORD WINAPI ThreadpoolMgr::GateThreadStart(LPVOID lpArgs) { ClrFlsSetThreadType (ThreadType_Gate); @@ -4517,9 +4125,6 @@ DWORD __stdcall ThreadpoolMgr::GateThreadStart(LPVOID lpArgs) } CONTRACTL_END; - // The gate thread is only needed if the CLR is providing part of the ThreadPool implementation. - _ASSERTE(!CLRThreadpoolHosted() || !CLRIoCompletionHosted()); - _ASSERTE(GateThreadStatus == GATE_THREAD_STATUS_REQUESTED); GateThreadTimer timer; @@ -4654,8 +4259,6 @@ DWORD __stdcall ThreadpoolMgr::GateThreadStart(LPVOID lpArgs) // don't mess with CP thread pool settings if not initialized yet if (InitCompletionPortThreadpool) { - _ASSERTE (!CLRIoCompletionHosted()); - ThreadCounter::Counts oldCounts, newCounts; oldCounts = CPThreadCounter.GetCleanCounts(); @@ -4746,8 +4349,7 @@ DWORD __stdcall ThreadpoolMgr::GateThreadStart(LPVOID lpArgs) } #endif // !FEATURE_PAL - if (!CLRThreadpoolHosted() && - (0 == CLRConfig::GetConfigValue(CLRConfig::INTERNAL_ThreadPool_DisableStarvationDetection))) + if (0 == CLRConfig::GetConfigValue(CLRConfig::INTERNAL_ThreadPool_DisableStarvationDetection)) { if (PerAppDomainTPCountList::AreRequestsPendingInAnyAppDomains() && SufficientDelaySinceLastDequeue()) { @@ -4961,7 +4563,7 @@ BOOL ThreadpoolMgr::CreateTimerQueueTimer(PHANDLE phNewTimer, #pragma warning (disable : 4715) #endif #endif -DWORD __stdcall ThreadpoolMgr::TimerThreadStart(LPVOID p) +DWORD WINAPI ThreadpoolMgr::TimerThreadStart(LPVOID p) { ClrFlsSetThreadType (ThreadType_Timer); @@ -5188,7 +4790,7 @@ DWORD ThreadpoolMgr::FireTimers() return nextFiringInterval; } -DWORD __stdcall ThreadpoolMgr::AsyncTimerCallbackCompletion(PVOID pArgs) +DWORD WINAPI ThreadpoolMgr::AsyncTimerCallbackCompletion(PVOID pArgs) { CONTRACTL { @@ -5244,7 +4846,7 @@ void ThreadpoolMgr::DeactivateTimer(TimerInfo* timerInfo) timerInfo->state = timerInfo->state & ~TIMER_ACTIVE; } -DWORD __stdcall ThreadpoolMgr::AsyncDeleteTimer(PVOID pArgs) +DWORD WINAPI ThreadpoolMgr::AsyncDeleteTimer(PVOID pArgs) { CONTRACTL { |