Use the portable timer implementation in CoreCLR

src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj

@@ -20,6 +20,7 @@
     <ILLinkDirectory>$(MSBuildThisFileDirectory)src\ILLink\</ILLinkDirectory>
 
     <FeaturePortableThreadPool>true</FeaturePortableThreadPool>
+    <FeaturePortableTimer>true</FeaturePortableTimer>
   </PropertyGroup>
 
   <ItemGroup>
@@ -236,7 +237,6 @@
     <Compile Include="$(BclSourcesRoot)\System\Threading\Thread.CoreCLR.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Threading\ProcessorIdCache.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Threading\ThreadPool.CoreCLR.cs" />
-    <Compile Include="$(BclSourcesRoot)\System\Threading\Timer.CoreCLR.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Threading\WaitHandle.CoreCLR.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Type.CoreCLR.cs" />
     <Compile Include="$(BclSourcesRoot)\System\TypedReference.CoreCLR.cs" />

src/coreclr/debug/daccess/request.cpp

@@ -348,20 +348,9 @@ ClrDataAccess::GetThreadpoolData(struct DacpThreadpoolData *threadpoolData)
     threadpoolData->MaxLimitTotalCPThreads = ThreadpoolMgr::MaxLimitTotalCPThreads;
     threadpoolData->CurrentLimitTotalCPThreads = (LONG)(counts.NumActive); //legacy: currently has no meaning
     threadpoolData->MinLimitTotalCPThreads = ThreadpoolMgr::MinLimitTotalCPThreads;
-
-    TADDR pEntry = DacGetTargetAddrForHostAddr(&ThreadpoolMgr::TimerQueue,true);
-    ThreadpoolMgr::LIST_ENTRY entry;
-    DacReadAll(pEntry,&entry,sizeof(ThreadpoolMgr::LIST_ENTRY),true);
-    TADDR node = (TADDR) entry.Flink;
     threadpoolData->NumTimers = 0;
-    while (node && node != pEntry)
-    {
-        threadpoolData->NumTimers++;
-        DacReadAll(node,&entry,sizeof(ThreadpoolMgr::LIST_ENTRY),true);
-        node = (TADDR) entry.Flink;
-    }
+    threadpoolData->AsyncTimerCallbackCompletionFPtr = NULL;
 
-    threadpoolData->AsyncTimerCallbackCompletionFPtr = (CLRDATA_ADDRESS) GFN_TADDR(ThreadpoolMgr__AsyncTimerCallbackCompletion);
     SOSDacLeave();
     return hr;
 }

src/coreclr/inc/dacvars.h

@@ -110,7 +110,6 @@ DEFINE_DACVAR(ThreadpoolMgr::ThreadCounter, ThreadpoolMgr__CPThreadCounter, Thre
 DEFINE_DACVAR(LONG, ThreadpoolMgr__MaxFreeCPThreads, ThreadpoolMgr::MaxFreeCPThreads)
 DEFINE_DACVAR(LONG, ThreadpoolMgr__MaxLimitTotalCPThreads, ThreadpoolMgr::MaxLimitTotalCPThreads)
 DEFINE_DACVAR(LONG, ThreadpoolMgr__MinLimitTotalCPThreads, ThreadpoolMgr::MinLimitTotalCPThreads)
-DEFINE_DACVAR(LIST_ENTRY, ThreadpoolMgr__TimerQueue, ThreadpoolMgr::TimerQueue)
 DEFINE_DACVAR_NO_DUMP(SIZE_T, dac__HillClimbingLog, ::HillClimbingLog)
 DEFINE_DACVAR(int, dac__HillClimbingLogFirstIndex, ::HillClimbingLogFirstIndex)
 DEFINE_DACVAR(int, dac__HillClimbingLogSize, ::HillClimbingLogSize)

src/coreclr/inc/gfunc_list.h

@@ -10,7 +10,6 @@
 #define DEFINE_DACGFN_STATIC(class, func)
 #endif
 
-DEFINE_DACGFN_STATIC(ThreadpoolMgr, AsyncTimerCallbackCompletion)
 DEFINE_DACGFN(DACNotifyCompilationFinished)
 DEFINE_DACGFN(ThePreStub)
 

src/coreclr/inc/utilcode.h

@@ -3898,16 +3898,6 @@ inline BOOL IsGateSpecialThread ()
     return !!(t_ThreadType & ThreadType_Gate);
 }
 
-// check if current thread is a Timer thread
-inline BOOL IsTimerSpecialThread ()
-{
-    STATIC_CONTRACT_NOTHROW;
-    STATIC_CONTRACT_GC_NOTRIGGER;
-    STATIC_CONTRACT_MODE_ANY;
-
-    return !!(t_ThreadType & ThreadType_Timer);
-}
-
 // check if current thread is a debugger helper thread
 inline BOOL IsDbgHelperSpecialThread ()
 {

src/coreclr/vm/comthreadpool.cpp

@@ -852,144 +852,3 @@ FCIMPL1(FC_BOOL_RET, ThreadPoolNative::CorPostQueuedCompletionStatus, LPOVERLAPP
     FC_RETURN_BOOL(res);
 }
 FCIMPLEND
-
-
-/********************************************************************************************************************/
-
-
-/******************************************************************************************/
-/*                                                                                        */
-/*                              Timer Functions                                           */
-/*                                                                                        */
-/******************************************************************************************/
-
-void AppDomainTimerCallback_Worker(LPVOID ptr)
-{
-    CONTRACTL
-    {
-        GC_TRIGGERS;
-        THROWS;
-        MODE_COOPERATIVE;
-    }
-    CONTRACTL_END;
-
-#ifdef _DEBUG
-    MethodDesc *pMeth = CoreLibBinder::GetMethod(METHOD__TIMER_QUEUE__APPDOMAIN_TIMER_CALLBACK);
-    LogCall(pMeth,"AppDomainTimerCallback");
-#endif
-
-    ThreadpoolMgr::TimerInfoContext* pTimerInfoContext = (ThreadpoolMgr::TimerInfoContext*)ptr;
-    ARG_SLOT args[] = { PtrToArgSlot(pTimerInfoContext->TimerId) };
-    MethodDescCallSite(METHOD__TIMER_QUEUE__APPDOMAIN_TIMER_CALLBACK).Call(args);
-}
-
-VOID WINAPI AppDomainTimerCallback(PVOID callbackState, BOOLEAN timerOrWaitFired)
-{
-    Thread* pThread = GetThreadNULLOk();
-    if (pThread == NULL)
-    {
-        // TODO: how do we notify user of OOM here?
-        ClrFlsSetThreadType(ThreadType_Threadpool_Worker);
-        pThread = SetupThreadNoThrow();
-        if (pThread == NULL) {
-            return;
-        }
-    }
-
-    CONTRACTL
-    {
-        THROWS;
-        MODE_ANY;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    GCX_COOP();
-
-    ThreadpoolMgr::TimerInfoContext* pTimerInfoContext = (ThreadpoolMgr::TimerInfoContext*)callbackState;
-    ManagedThreadBase::ThreadPool(AppDomainTimerCallback_Worker, pTimerInfoContext);
-}
-
-extern "C" HANDLE QCALLTYPE AppDomainTimer_Create(INT32 dueTime, INT32 timerId)
-{
-    QCALL_CONTRACT;
-
-    HANDLE hTimer = NULL;
-    BEGIN_QCALL;
-
-    _ASSERTE(dueTime >= 0);
-    _ASSERTE(timerId >= 0);
-
-    AppDomain* pAppDomain = GetThread()->GetDomain();
-
-    ThreadpoolMgr::TimerInfoContext* timerContext = new ThreadpoolMgr::TimerInfoContext();
-    timerContext->TimerId = timerId;
-    NewHolder<ThreadpoolMgr::TimerInfoContext> timerContextHolder(timerContext);
-
-    BOOL res = ThreadpoolMgr::CreateTimerQueueTimer(
-        &hTimer,
-        (WAITORTIMERCALLBACK)AppDomainTimerCallback,
-        (PVOID)timerContext,
-        (ULONG)dueTime,
-        (ULONG)-1 /* this timer doesn't repeat */,
-        0 /* no flags */);
-
-    if (!res)
-    {
-        if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
-            COMPlusThrow(kNotSupportedException);
-        else
-            COMPlusThrowWin32();
-    }
-    else
-    {
-        timerContextHolder.SuppressRelease();
-    }
-
-    END_QCALL;
-    return hTimer;
-}
-
-extern "C" BOOL QCALLTYPE AppDomainTimer_Delete(HANDLE hTimer)
-{
-    QCALL_CONTRACT;
-
-    BOOL res = FALSE;
-    BEGIN_QCALL;
-
-    _ASSERTE(hTimer != NULL && hTimer != INVALID_HANDLE_VALUE);
-    res = ThreadpoolMgr::DeleteTimerQueueTimer(hTimer, NULL);
-
-    if (!res)
-    {
-        DWORD errorCode = ::GetLastError();
-        if (errorCode != ERROR_IO_PENDING)
-            COMPlusThrowWin32(HRESULT_FROM_WIN32(errorCode));
-    }
-
-    END_QCALL;
-    return res;
-}
-
-
-extern "C" BOOL QCALLTYPE AppDomainTimer_Change(HANDLE hTimer, INT32 dueTime)
-{
-    QCALL_CONTRACT;
-
-    BOOL res = FALSE;
-    BEGIN_QCALL;
-
-    _ASSERTE(hTimer != NULL && hTimer != INVALID_HANDLE_VALUE);
-    _ASSERTE(dueTime >= 0);
-
-    res = ThreadpoolMgr::ChangeTimerQueueTimer(
-        hTimer,
-        (ULONG)dueTime,
-        (ULONG)-1 /* this timer doesn't repeat */);
-
-    if (!res)
-        COMPlusThrowWin32();
-
-    END_QCALL;
-    return res;
-}

src/coreclr/vm/comthreadpool.h

@@ -60,9 +60,6 @@ class ThreadPoolNative
 extern "C" INT64 QCALLTYPE ThreadPool_GetCompletedWorkItemCount();
 extern "C" BOOL QCALLTYPE ThreadPool_RequestWorkerThread();
 extern "C" BOOL QCALLTYPE ThreadPool_PerformGateActivities(INT32 cpuUtilization);
-extern "C" HANDLE QCALLTYPE AppDomainTimer_Create(INT32 dueTime, INT32 timerId);
-extern "C" BOOL QCALLTYPE AppDomainTimer_Change(HANDLE hTimer, INT32 dueTime);
-extern "C" BOOL QCALLTYPE AppDomainTimer_Delete(HANDLE hTimer);
 
 VOID QueueUserWorkItemManagedCallback(PVOID pArg);
 void WINAPI BindIoCompletionCallbackStub(DWORD ErrorCode,

src/coreclr/vm/corelib.h

@@ -906,9 +906,6 @@ DEFINE_METHOD(TPWAITORTIMER_HELPER,             PERFORM_WAITORTIMER_CALLBACK,
 DEFINE_CLASS(TP_WAIT_CALLBACK,         Threading,              _ThreadPoolWaitCallback)
 DEFINE_METHOD(TP_WAIT_CALLBACK,        PERFORM_WAIT_CALLBACK,               PerformWaitCallback,                   SM_RetBool)
 
-DEFINE_CLASS(TIMER_QUEUE,           Threading,                TimerQueue)
-DEFINE_METHOD(TIMER_QUEUE,          APPDOMAIN_TIMER_CALLBACK, AppDomainTimerCallback,   SM_Int_RetVoid)
-
 DEFINE_CLASS(THREAD_POOL,           Threading,                          ThreadPool)
 DEFINE_METHOD(THREAD_POOL,          ENSURE_GATE_THREAD_RUNNING,         EnsureGateThreadRunning,        SM_RetVoid)
 DEFINE_METHOD(THREAD_POOL,          UNSAFE_QUEUE_UNMANAGED_WORK_ITEM,   UnsafeQueueUnmanagedWorkItem,   SM_IntPtr_IntPtr_RetVoid)

src/coreclr/vm/qcallentrypoints.cpp

@@ -212,9 +212,6 @@ static const Entry s_QCall[] =
     DllImportEntry(ThreadPool_GetCompletedWorkItemCount)
     DllImportEntry(ThreadPool_RequestWorkerThread)
     DllImportEntry(ThreadPool_PerformGateActivities)
-    DllImportEntry(AppDomainTimer_Create)
-    DllImportEntry(AppDomainTimer_Change)
-    DllImportEntry(AppDomainTimer_Delete)
 #ifdef TARGET_UNIX
     DllImportEntry(WaitHandle_CorWaitOnePrioritizedNative)
 #endif

src/coreclr/vm/threadpoolrequest.cpp

@@ -385,8 +385,7 @@ void UnManagedPerAppDomainTPCount::QueueUnmanagedWorkRequest(LPTHREAD_START_ROUT
     _ASSERTE(pWorkRequest != NULL);
     PREFIX_ASSUME(pWorkRequest != NULL);
 
-    if (ETW_EVENT_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_DOTNET_Context, ThreadPoolEnqueue) &&
-        !ThreadpoolMgr::AreEtwQueueEventsSpeciallyHandled(function))
+    if (ETW_EVENT_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_DOTNET_Context, ThreadPoolEnqueue))
         FireEtwThreadPoolEnqueue(pWorkRequest, GetClrInstanceId());
 
     m_lock.Init(LOCK_TYPE_DEFAULT);
@@ -493,8 +492,7 @@ void UnManagedPerAppDomainTPCount::DispatchWorkItem(bool* foundWork, bool* wasNo
         wrFunction = pWorkRequest->Function;
         wrContext  = pWorkRequest->Context;
 
-        if (ETW_EVENT_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_DOTNET_Context, ThreadPoolDequeue) &&
-            !ThreadpoolMgr::AreEtwQueueEventsSpeciallyHandled(wrFunction))
+        if (ETW_EVENT_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_DOTNET_Context, ThreadPoolDequeue))
             FireEtwThreadPoolDequeue(pWorkRequest, GetClrInstanceId());
 
         ThreadpoolMgr::FreeWorkRequest(pWorkRequest);

src/coreclr/vm/threads.cpp

@@ -703,7 +703,7 @@ Thread* SetupThread()
                 pThread->SetThreadState(Thread::TS_CompletionPortThread);
                 pThread->SetBackground(TRUE);
             }
-            else if (IsTimerSpecialThread() || IsWaitSpecialThread())
+            else if (IsWaitSpecialThread())
             {
                 pThread->SetThreadState(Thread::TS_TPWorkerThread);
                 pThread->SetBackground(TRUE);
@@ -794,7 +794,7 @@ Thread* SetupThread()
     {
         pThread->SetThreadState(Thread::TS_CompletionPortThread);
     }
-    else if (IsTimerSpecialThread() || IsWaitSpecialThread())
+    else if (IsWaitSpecialThread())
     {
         pThread->SetThreadState(Thread::TS_TPWorkerThread);
     }
@@ -7183,7 +7183,6 @@ BOOL Thread::HaveExtraWorkForFinalizer()
     LIMITED_METHOD_CONTRACT;
 
     return RequireSyncBlockCleanup()
-        || ThreadpoolMgr::HaveTimerInfosToFlush()
         || Thread::CleanupNeededForFinalizedThread()
         || (m_DetachCount > 0)
         || SystemDomain::System()->RequireAppDomainCleanup()
@@ -7231,9 +7230,6 @@ void Thread::DoExtraWorkForFinalizer()
         Thread::CleanupDetachedThreads();
     }
 
-    // If there were any TimerInfos waiting to be released, they'll get flushed now
-    ThreadpoolMgr::FlushQueueOfTimerInfos();
-
     if (YieldProcessorNormalization::IsMeasurementScheduled())
     {
         GCX_PREEMP();
@@ -7585,7 +7581,7 @@ void ManagedThreadBase::KickOff(ADCallBackFcnType pTarget, LPVOID args)
     ManagedThreadBase_FullTransition(pTarget, args, ManagedThread);
 }
 
-// The IOCompletion, QueueUserWorkItem, AddTimer, RegisterWaitForSingleObject cases in the ThreadPool
+// The IOCompletion, QueueUserWorkItem, RegisterWaitForSingleObject cases in the ThreadPool
 void ManagedThreadBase::ThreadPool(ADCallBackFcnType pTarget, LPVOID args)
 {
     WRAPPER_NO_CONTRACT;