Changeset 10580 for trunk/src

Timestamp:

Apr 14, 2004, 10:45:45 AM (21 years ago)

Author:

sandervl

Message:

backed out changes

File:

• trunk/src/odincrt/critsect.cpp (modified) (8 diffs)

trunk/src/odincrt/critsect.cpp

@@ -1 @@
-/* $Id: critsect.cpp,v 1.11 2004-03-16 17:24:53 sandervl Exp $ */
+/* $Id: critsect.cpp,v 1.12 2004-04-14 08:45:45 sandervl Exp $ */
 /*
  * Critical sections in the Win32 sense
@@ -6 +6 @@
  *
  */
-#define INCL_DOS
 #define INCL_DOSPROCESS
 #define INCL_DOSERRORS
 #define INCL_DOSSEMAPHORES
-#include <os2.h>
-
-#include "dbglog.h"
+#include <os2wrap.h>
+#include <win32type.h>
+#include <win32api.h>
+#include <FastInfoBlocks.h>
+
+#include <assert.h>
+#include <stdio.h>
 
 #include <odincrt.h>
-#include <FastInfoBlocks.h>
+
 
 #undef fibGetPid
@@ -24 +27 @@
 #define dprintf(a)
 #define DebugInt3()
+
+
+ULONG WIN32API DosValidateCriticalSection (CRITICAL_SECTION_OS2 *crit)
+{
+    if (crit->hevLock != NULLHANDLE)
+    {
+        return NO_ERROR;
+    }
+    
+    return ERROR_INVALID_PARAMETER;
+}
 
 //******************************************************************************
@@ -65 +79 @@
 //******************************************************************************
 //******************************************************************************
-ULONG WIN32API DosInitializeCriticalSection(CRITICAL_SECTION_OS2 *crit, char *pszSemName, BOOL fShared)
-{
+inline ULONG GetCurrentProcessId()
+{
+#ifdef fibGetPid
+    return fibGetPid();
+#else
+    PTIB   ptib;
+    PPIB   ppib;
     APIRET rc;
 
-    rc = DosCreateEventSem(pszSemName, &crit->hevLock, (pszSemName || fShared)? DC_SEM_SHARED: 0, 0);
-    
-    if(rc != NO_ERROR) 
-    {
-        crit->hevLock = 0;
-        return rc;
-    }
-    
+    rc = DosGetInfoBlocks(&ptib, &ppib);
+    if(rc == NO_ERROR) {
+        return ppib->pib_ulpid;
+    }
+    DebugInt3();
+    return 0;
+#endif
+}
+
+/***********************************************************************
+ *           DosInitializeCriticalSection
+ */
+ULONG WIN32API DosInitializeCriticalSection(CRITICAL_SECTION_OS2 *crit,
+                                            PSZ pszSemName, BOOL fShared)
+{
+    APIRET rc;
+
     // initialize lock count with special value -1, meaning noone posesses it
     crit->LockCount      = -1;
@@ -82 +110 @@
     crit->OwningThread   = 0;
 
+    rc = DosCreateEventSem(pszSemName, &crit->hevLock, (pszSemName || fShared) ? DC_SEM_SHARED : 0, 0);
+    if(rc != NO_ERROR) {
+        DebugInt3();
+        crit->hevLock = 0;
+        return rc;
+    }
     crit->CreationCount  = 1;
-    crit->Reserved       = 0;
-    
-    return NO_ERROR;
-}
-
-ULONG WIN32API DosValidateCriticalSection (CRITICAL_SECTION_OS2 *crit)
-{
-    if (crit->hevLock != NULLHANDLE)
-    {
-        return NO_ERROR;
-    }
-    
-    return ERROR_INVALID_PARAMETER;
-}
-
-// Initializes or opens a critical section
-ULONG WIN32API DosAccessCriticalSection(CRITICAL_SECTION_OS2 *crit, char *pszSemName)
+    crit->Reserved       = GetCurrentProcessId();
+    return NO_ERROR;
+}
+
+
+/***********************************************************************
+ *           DosAccessCriticalSection
+ */
+ULONG WIN32API DosAccessCriticalSection(CRITICAL_SECTION_OS2 *crit, PSZ pszSemName)
 {
     APIRET rc = NO_ERROR;
@@ -132 +158 @@
     return NO_ERROR;
 }
-
+/***********************************************************************
+ *           DosDeleteCriticalSection
+ */
 ULONG WIN32API DosDeleteCriticalSection( CRITICAL_SECTION_OS2 *crit )
 {
-    if (DosValidateCriticalSection (crit))
-    {
-        DosCloseEventSem (crit->hevLock);
-        
+    if (crit->hevLock)
+    {
+#ifdef DEBUG
+        if (  (crit->LockCount != -1 && crit->CreationCount == 1)
+            || crit->OwningThread
+            || crit->RecursionCount)  /* Should not happen */
+        {
+           DebugInt3();
+        }
+#endif
+        DosCloseEventSem(crit->hevLock);
         if(DosInterlockedDecrement(&crit->CreationCount) == 0)
         {
@@ -144 +179 @@
             crit->RecursionCount = 0;
             crit->OwningThread   = 0;
-            crit->hevLock        = 0;
-            crit->Reserved       = 0;
-        }
-    }
-    return NO_ERROR;
-}
-
-
+            crit->hevLock       = 0;
+            crit->Reserved       = (DWORD)-1;
+        }
+    }
+    return NO_ERROR;
+}
+
+
+/***********************************************************************
+ *           DosEnterCriticalSection
+ */
 ULONG WIN32API DosEnterCriticalSection( CRITICAL_SECTION_OS2 *crit, ULONG ulTimeout )
 {
-    APIRET rc = NO_ERROR;
-            
-    ULONG threadid = GetCurrentThreadId();
-            
+    DWORD res;
+    DWORD threadid = GetCurrentThreadId();
+
+    // create crit sect just in time...
     if (!crit->hevLock)
     {
-        rc = DosInitializeCriticalSection (crit, NULL, FALSE);
-        if (rc != NO_ERROR)
-        {
+        DosInitializeCriticalSection(crit, NULL);
+    }
+    // if the same thread is requesting it again, memorize it
+    if (crit->OwningThread == threadid)
+    {
+        crit->RecursionCount++;
+        return NO_ERROR;
+    }
+
+    // do an atomic increase of the lockcounter
+    DosInterlockedIncrement(&crit->LockCount);
+
+    // do an atomic operation where we compare the owning thread id with 0
+    // and if this is true, exchange it with the id of the current thread.
+testenter:
+    if(DosInterlockedCompareExchange((PLONG)&crit->OwningThread, threadid, 0))
+    {
+        // the crit sect is in use
+        ULONG ulnrposts;
+
+        // now wait for it
+        APIRET rc = DosWaitEventSem(crit->hevLock, ulTimeout);
+        if(rc != NO_ERROR) {
+            DebugInt3();
             return rc;
         }
-    }
-
-    dprintf(("Entering the section: owner = %8.8X\n", crit->OwningThread));
-
-    // We want to acquire the section, count the entering
-    DosInterlockedIncrement (&crit->LockCount);
-    
-    // try to acquire the section
-    for (;;)
-    {
-        // try to assign owning thread id atomically
-        if (DosInterlockedCompareExchange((PLONG)&crit->OwningThread, threadid, 0) == 0)
-        {
-            ULONG ulnrposts = 0;
-
-            dprintf(("Acquired the section: owner = %8.8X\n", crit->OwningThread));
-            DosResetEventSem (crit->hevLock, &ulnrposts);
-            break;
-        }
-        
-        if (crit->OwningThread == threadid)
-        {
-            // This thread already owns the section
-            crit->RecursionCount++;
-            dprintf(("Recursion: %d\n", crit->RecursionCount));
-            return NO_ERROR;
-        }
-
-        // Arise any timing problems and let others to run
-        DosSleep (0);
-
-        dprintf(("Waiting on sem: owner = %8.8X\n", crit->OwningThread));
-        rc = DosWaitEventSem (crit->hevLock, ulTimeout);
-        dprintf(("Returned from wait: owner = %8.8X, rc = %d\n", crit->OwningThread, rc));
-       
-        if (rc != NO_ERROR) 
-        {
-            dprintf(("Returned from wait: FAILED!!!\n"));
-            // We fail, deregister itself
-            DosInterlockedDecrement (&crit->LockCount);
-            return rc;
-        }
-    }
-    
-    // the section was successfully aquired
+        DosResetEventSem(crit->hevLock, &ulnrposts);
+        // multiple waiters could be running now. Repeat the logic so that
+        // only one actually can get the critical section
+        goto testenter;
+    }
     crit->RecursionCount = 1;
-    
-    if (crit->Reserved != 0)
-    {
-        // the section already entered!!!!
-        DosBeep (2000, 200);
-    }
-    
-    crit->Reserved = 1;
-    
-    return NO_ERROR;
-}
-
-
+    return NO_ERROR;
+}
+
+
+/***********************************************************************
+ *           DosLeaveCriticalSection
+ */
 ULONG WIN32API DosLeaveCriticalSection( CRITICAL_SECTION_OS2 *crit )
 {
-    dprintf(("Leaving the section\n"));
     if (crit->OwningThread != GetCurrentThreadId()) {
-        dprintf(("WRONG THREAD ID!!! owner is %8.8X\n", crit->OwningThread));
+        DebugInt3();
         return ERROR_INVALID_PARAMETER;
     }
@@ -234 +246 @@
     if (--crit->RecursionCount)
     {
-        dprintf(("Recursion exit: %d\n", crit->RecursionCount));
-        DosInterlockedDecrement( &crit->LockCount );
+        //just return
         return NO_ERROR;
     }
-    
-    crit->Reserved = 0;
     crit->OwningThread = 0;
-
-    dprintf(("Released the section\n"));
-
     if (DosInterlockedDecrement( &crit->LockCount ) >= 0)
     {
-        dprintf(("Posted the semaphore\n"));
+        /* Someone is waiting */
         DosPostEventSem(crit->hevLock);
     }
-    
-    return NO_ERROR;
-}
-
-
-/**
- * Checks if the current thread is in the critical section or now.
- *
- * @returns NO_ERROR if in the critical section.
- * @returns ERROR_NOT_OWNER if not in the critical section.
- * @param   pCrit   Pointer to the critical section.
- */
-ULONG WIN32API DosIsInCriticalSection( CRITICAL_SECTION_OS2 *pCrit )
-{
-    return  (pCrit->hevLock && pCrit->OwningThread == GetCurrentThreadId() ? NO_ERROR : ERROR_NOT_OWNER);
-}
-
+    return NO_ERROR;
+}