Changeset 8527 for branches/windows-client/src/common/gen-locks/gen-win-locks.c

Timestamp:

09/28/10 17:31:36 (3 years ago)

Author:

sampson

Message:

Working on gen_locks

Files:

• branches/windows-client/src/common/gen-locks/gen-win-locks.c (modified) (3 diffs)

branches/windows-client/src/common/gen-locks/gen-win-locks.c

@@ -24 +24 @@
 /* TODO: may need to init and delete in DLL enter/exit functions */
 LPCRITICAL_SECTION cond_list_lock = NULL;
+LPCRITICAL_SECTION cond_test_init_lock = NULL;
 
 pgen_cond_t cond_list_head = NULL;
@@ -137 +138 @@
 }
 
-int gen_win_cond_destroy(HANDLE cond)
-{
-    if(!cond)
+int gen_win_cond_destroy(pgen_cond_t *cond)
+{
+    pgen_cond_t cv;
+    int result = 0, result1 = 0, result2 = 0;
+
+    if(!cond || !(*cond))
     {
         return -EINVAL;
     }
-    pthread_cond_destroy(cond);
-    return 0;
-}
-
-int gen_win_cond_wait(HANDLE cond, HANDLE mut)
+    
+    if (*cond != GEN_COND_INITIALIZER)
+    {
+        EnterCriticalSection(cond_list_lock);
+
+        cv = *cond;
+
+        if (WaitForSingleObject(&(cv->semBlockLock), INFINITE) != WAIT_OBJECT_0)
+        {   
+            return GetLastError();
+        }
+
+        if ((result = gen_mutex_trylock(&(cv->mtxUnblockLock))) != 0)
+        {
+            ReleaseSemaphore(&(cv->semBlockLock), 1, NULL);
+            return result;
+        }
+
+        if (cv->nWaitersBlocked > cv->nWaitersGone)
+        {
+            if (!ReleaseSemaphore(&(cv->semBlockLock), 1, NULL))
+            {
+                result = GetLastError();
+            }
+            result1 = gen_mutex_unlock(&(cv->mtxUnblockLock));
+            result2 = EBUSY;
+        }
+        else
+        {
+            /* Now it is safe to destroy */
+            *cond = NULL;
+
+            if (CloseHandle(&(cv->semBlockLock)) != 0)
+            {
+                result = GetLastError();
+            }
+            if (CloseHandle(&(cv->semBlockQueue)) != 0)
+            {
+                result1 = GetLastError();
+            }
+            if ((result2 = gen_mutex_unlock(&(cv->mtxUnblockLock))) == 0)
+            {
+                result2 = gen_mutex_destroy(&(cv->mtxUnblockLock));
+            }
+
+            /* Unlink the CV from the list */
+            if (cond_list_head == cv)
+            {
+                cond_list_head = cv->next;
+            }
+            else 
+            {
+                cv->prev->next = cv->next;
+            }
+
+            if (cond_list_tail == cv) 
+            {
+                cond_list_tail = cv->prev;
+            }
+            else {
+                cv->next->prev = cv->prev;
+            }
+
+            free(cv);
+        }
+
+        LeaveCriticalSection(cond_list_lock);
+    }
+    else
+    {
+        EnterCriticalSection(cond_test_init_lock);
+
+        if (*cond == GEN_COND_INITIALIZER) 
+        {
+            *cond = NULL;
+        }
+        else 
+        {
+            result = EBUSY;
+        }
+
+        LeaveCriticalSection(cond_test_init_lock);
+    }
+
+    return ((result != 0) ? result : ((result1 != 0) ? result1 : result2));
+}
+
+typedef struct
+{
+    gen_mutex_t *mutexPtr;
+    pgen_cond_t cv;
+    int *resultPtr;
+} cond_wait_cleanup_args_t;
+
+static void __cdecl cond_wait_cleanup(void *args)
+{
+    cond_wait_cleanup_args_t *cleanup_args = (cond_wait_cleanup_args_t *) args;
+    pgen_cond_t cv = cleanup_args->cv;
+    int *resultPtr = cleanup_args->resultPtr;
+    int nSignalsWasLeft;
+    int result;
+
+    if ((result = gen_mutex_lock(&(cv->mtxUnblockLock))) != 0) 
+    {
+        *resultPtr = result;
+        return;
+    }
+
+    if ((nSignalsWasLeft = cv->nWaitersToUnblock) != 0)
+    {
+        --(cv->nWaitersToUnblock);
+    }
+    else if (INT_MAX / 2 == ++(cv->nWaitersGone))
+    {
+        if (WaitForSingleObject(&(cv->semBlockLock), INFINITE) != 0)
+        {
+            *resultPtr = (int) GetLastError();
+            return;
+        }
+        cv->nWaitersBlocked -= cv->nWaitersGone;
+        if (!ReleaseSemaphore(&(cv->semBlockLock), 1, NULL))
+        {
+            *resultPtr = (int) GetLastError();
+            return;
+        }
+        cv->nWaitersGone = 0;
+    }
+
+    if ((result = gen_mutex_unlock(&(cv->mtxUnblockLock))) != 0)
+    {
+        *resultPtr = result;
+        return;
+    }
+
+    if (nSignalsWasLeft == 1) 
+    {
+        if (!ReleaseSemaphore(&(cv->semBlockLock), 1, NULL))
+        {
+            *resultPtr = (int) GetLastError();
+            return;
+        }
+    }
+
+    if ((result = gen_mutex_lock(cleanup_args->mutexPtr)) != 0)
+    {
+        *resultPtr = result;
+    }
+
+}
+
+static __inline int cond_timedwait(pgen_cond_t *cond,
+                                   HANDLE *mutex, const struct timespec *abstime)
+{
+    int result = 0;
+    pgen_cond_t cv;
+    cond_wait_cleanup_args_t cleanup_args;
+
+    if (cond == NULL || *cond == NULL) 
+    {
+        return EINVAL;
+    }
+
+    if (*cond == GEN_COND_INITIALIZER)
+    {
+        result = cond_check_need_init(cond);
+    }
+
+    if (result != 0 && result != EBUSY) 
+    {
+        return result;
+    }
+
+    cv = *cond;
+
+    if (WaitForSingleObject(&(cv->semBlockLock), INFINITE) != 0)
+    {
+        return (int) GetLastError();
+    }
+
+    ++(cv->nWaitersBlocked);
+
+    if (!ReleaseSemaphore(&(cv->semBlockLock), 1, NULL))
+    {
+        return (int) GetLastError();
+    }
+
+    cleanup_args.mutexPtr = mutex;
+    cleanup_args.cv = cv;
+    cleanup_args.resultPtr = &result;
+
+    // TODO: pthread_cleanup_push(cond_wait_cleanup, (void*) &cleanup_args);
+
+    /* Now we can release mutex and... */
+    if ((result = gen_mutex_unlock(mutex)) == 0) 
+    {
+
+    }
+
+    return result;
+}
+
+int gen_win_cond_wait(pgen_cond_t *cond, HANDLE *mut)
 {
     return pthread_cond_wait(cond, mut);
 }
 
-int gen_win_cond_timedwait(HANDLE cond, HANDLE mut,
+int gen_win_cond_timedwait(pgen_cond_t *cond, HANDLE *mut,
                              const struct timespec *abstime)
 {
@@ -158 +359 @@
 }
 
-int gen_win_cond_signal(HANDLE cond)
+int gen_win_cond_signal(pgen_cond_t *cond)
 {
     return pthread_cond_signal(cond);
 }
 
-int gen_win_cond_broadcast(HANDLE cond)
+int gen_win_cond_broadcast(pgen_cond_t *cond)
 {
     return pthread_cond_broadcast(cond);