Remove prioritized waits from the PAL and remove WAIT_ABANDONED usage

Author: jkoritzinsky

src/coreclr/pal/src/include/pal/corunix.hpp

@@ -571,8 +571,7 @@ namespace CorUnix
         RegisterWaitingThread(
             WaitType eWaitType,
             DWORD dwIndex,
-            bool fAltertable,
-            bool fPrioritize
+            bool fAltertable
             ) = 0;
 
         //

src/coreclr/pal/src/include/pal/synchobjects.hpp

@@ -37,8 +37,7 @@ namespace CorUnix
         CONST HANDLE *lpHandles,
         BOOL bWaitAll,
         DWORD dwMilliseconds,
-        BOOL bAlertable,
-        BOOL bPrioritize = FALSE);
+        BOOL bAlertable);
 
     DWORD InternalSignalObjectAndWait(
         CPalThread *thread,

src/coreclr/pal/src/synchmgr/synchcontrollers.cpp

@@ -247,8 +247,7 @@ namespace CorUnix
     PAL_ERROR CSynchWaitController::RegisterWaitingThread(
         WaitType wtWaitType,
         DWORD dwIndex,
-        bool fAlertable,
-        bool fPrioritize)
+        bool fAlertable)
     {
         VALIDATEOBJECT(m_psdSynchData);
 
@@ -366,7 +365,7 @@ namespace CorUnix
         }
 
         // Add new node to queue
-        m_psdSynchData->WaiterEnqueue(pwtlnNewNode, fPrioritize);
+        m_psdSynchData->WaiterEnqueue(pwtlnNewNode);
 
         // Succeeded: update object count
         ptwiWaitInfo->lObjCount++;
@@ -1113,60 +1112,32 @@ namespace CorUnix
     Note: this method must be called while holding the local process
           synchronization lock.
     --*/
-    void CSynchData::WaiterEnqueue(WaitingThreadsListNode * pwtlnNewNode, bool fPrioritize)
+    void CSynchData::WaiterEnqueue(WaitingThreadsListNode * pwtlnNewNode)
     {
         VALIDATEOBJECT(this);
         VALIDATEOBJECT(pwtlnNewNode);
 
-        if (!fPrioritize)
-        {
-            // Enqueue normally to the end of the queue
-            WaitingThreadsListNode * pwtlnCurrLast = m_ptrWTLTail.ptr;
+        // Enqueue normally to the end of the queue
+        WaitingThreadsListNode * pwtlnCurrLast = m_ptrWTLTail.ptr;
 
-            pwtlnNewNode->ptrNext.ptr = NULL;
-            if (NULL == pwtlnCurrLast)
-            {
-                _ASSERT_MSG(NULL == m_ptrWTLHead.ptr,
-                            "Corrupted waiting list on local CSynchData @ %p\n",
-                            this);
-
-                pwtlnNewNode->ptrPrev.ptr = NULL;
-                m_ptrWTLHead.ptr = pwtlnNewNode;
-                m_ptrWTLTail.ptr = pwtlnNewNode;
-            }
-            else
-            {
-                VALIDATEOBJECT(pwtlnCurrLast);
+        pwtlnNewNode->ptrNext.ptr = NULL;
+        if (NULL == pwtlnCurrLast)
+        {
+            _ASSERT_MSG(NULL == m_ptrWTLHead.ptr,
+                        "Corrupted waiting list on local CSynchData @ %p\n",
+                        this);
 
-                pwtlnNewNode->ptrPrev.ptr = pwtlnCurrLast;
-                pwtlnCurrLast->ptrNext.ptr = pwtlnNewNode;
-                m_ptrWTLTail.ptr = pwtlnNewNode;
-            }
+            pwtlnNewNode->ptrPrev.ptr = NULL;
+            m_ptrWTLHead.ptr = pwtlnNewNode;
+            m_ptrWTLTail.ptr = pwtlnNewNode;
         }
         else
         {
-            // The wait is prioritized, enqueue to the beginning of the queue
-            WaitingThreadsListNode * pwtlnCurrFirst = m_ptrWTLHead.ptr;
+            VALIDATEOBJECT(pwtlnCurrLast);
 
-            pwtlnNewNode->ptrPrev.ptr = NULL;
-            if (NULL == pwtlnCurrFirst)
-            {
-                _ASSERT_MSG(NULL == m_ptrWTLTail.ptr,
-                            "Corrupted waiting list on local CSynchData @ %p\n",
-                            this);
-
-                pwtlnNewNode->ptrNext.ptr = NULL;
-                m_ptrWTLHead.ptr = pwtlnNewNode;
-                m_ptrWTLTail.ptr = pwtlnNewNode;
-            }
-            else
-            {
-                VALIDATEOBJECT(pwtlnCurrFirst);
-
-                pwtlnNewNode->ptrNext.ptr = pwtlnCurrFirst;
-                pwtlnCurrFirst->ptrPrev.ptr = pwtlnNewNode;
-                m_ptrWTLHead.ptr = pwtlnNewNode;
-            }
+            pwtlnNewNode->ptrPrev.ptr = pwtlnCurrLast;
+            pwtlnCurrLast->ptrNext.ptr = pwtlnNewNode;
+            m_ptrWTLTail.ptr = pwtlnNewNode;
         }
 
         m_ulcWaitingThreads += 1;

src/coreclr/pal/src/synchmgr/synchmanager.hpp

@@ -179,7 +179,7 @@ namespace CorUnix
             CPalThread * pthrCurrent,
             CPalThread * pthrTarget);
 
-        void WaiterEnqueue(WaitingThreadsListNode * pwtlnNewNode, bool fPrioritize);
+        void WaiterEnqueue(WaitingThreadsListNode * pwtlnNewNode);
 
         // Object Type accessor methods
         CObjectType * GetObjectType(void)
@@ -366,8 +366,7 @@ namespace CorUnix
         virtual PAL_ERROR RegisterWaitingThread(
             WaitType wtWaitType,
             DWORD dwIndex,
-            bool fAlertable,
-            bool fPrioritize);
+            bool fAlertable);
 
         virtual void ReleaseController(void);
 

src/coreclr/pal/src/synchmgr/wait.cpp

@@ -321,8 +321,7 @@ DWORD CorUnix::InternalWaitForMultipleObjectsEx(
     CONST HANDLE *lpHandles,
     BOOL bWaitAll,
     DWORD dwMilliseconds,
-    BOOL bAlertable,
-    BOOL bPrioritize)
+    BOOL bAlertable)
 {
     DWORD dwRet = WAIT_FAILED;
     PAL_ERROR palErr = NO_ERROR;
@@ -516,8 +515,7 @@ DWORD CorUnix::InternalWaitForMultipleObjectsEx(
             palErr = ppISyncWaitCtrlrs[i]->RegisterWaitingThread(
                                                         wtWaitType,
                                                         i,
-                                                        (TRUE == bAlertable),
-                                                        bPrioritize != FALSE);
+                                                        (TRUE == bAlertable));
             if (NO_ERROR != palErr)
             {
                 ERROR("RegisterWaitingThread() failed for %d-th object "

src/coreclr/vm/finalizerthread.cpp

@@ -249,8 +249,6 @@ void FinalizerThread::WaitForFinalizerEvent (CLREvent *event)
     {
     case (WAIT_OBJECT_0):
         return;
-    case (WAIT_ABANDONED):
-        return;
     case (WAIT_TIMEOUT):
         break;
     }
@@ -312,8 +310,6 @@ void FinalizerThread::WaitForFinalizerEvent (CLREvent *event)
             {
             case (WAIT_OBJECT_0):
                 return;
-            case (WAIT_ABANDONED):
-                return;
             case (WAIT_TIMEOUT):
                 break;
             }

src/coreclr/vm/threads.cpp

@@ -3361,7 +3361,6 @@ DWORD Thread::DoAppropriateWaitWorker(int countHandles, HANDLE *handles, BOOL wa
         goto retry;
     }
     _ASSERTE((ret >= WAIT_OBJECT_0  && ret < (WAIT_OBJECT_0  + (DWORD)countHandles)) ||
-             (ret >= WAIT_ABANDONED && ret < (WAIT_ABANDONED + (DWORD)countHandles)) ||
              (ret == WAIT_TIMEOUT) || (ret == WAIT_FAILED));
     // countHandles is used as an unsigned -- it should never be negative.
     _ASSERTE(countHandles >= 0);
@@ -3460,11 +3459,13 @@ DWORD Thread::DoAppropriateWaitWorker(int countHandles, HANDLE *handles, BOOL wa
                 DWORD subRet = WaitForSingleObject (handles[i], 0);
                 if ((subRet == WAIT_OBJECT_0) || (subRet == WAIT_FAILED))
                     break;
+#ifdef HOST_WINDOWS
                 if (subRet == WAIT_ABANDONED)
                 {
                     ret = (ret - WAIT_OBJECT_0) + WAIT_ABANDONED;
                     break;
                 }
+#endif // HOST_WINDOWS
                 // If we get alerted it just masks the real state of the current
                 // handle, so retry the wait.
                 if (subRet == WAIT_IO_COMPLETION)
@@ -3622,11 +3623,18 @@ DWORD Thread::DoSignalAndWaitWorker(HANDLE* pHandles, DWORD millis,BOOL alertabl
 WaitCompleted:
 
     //Check that the return state is valid
+#ifdef HOST_WINDOWS
     _ASSERTE(WAIT_OBJECT_0 == ret  ||
          WAIT_ABANDONED == ret ||
          WAIT_TIMEOUT == ret ||
          WAIT_FAILED == ret  ||
          ERROR_TOO_MANY_POSTS == ret);
+#else
+    _ASSERTE(WAIT_OBJECT_0 == ret  ||
+         WAIT_TIMEOUT == ret ||
+         WAIT_FAILED == ret  ||
+         ERROR_TOO_MANY_POSTS == ret);
+#endif // HOST_WINDOWS
 
     //Wrong to time out if the wait was infinite
     _ASSERTE((WAIT_TIMEOUT != ret) || (INFINITE != millis));