Index: nspr/pr/src/threads/prmon.c |
diff --git a/nspr/pr/src/threads/prmon.c b/nspr/pr/src/threads/prmon.c |
deleted file mode 100644 |
index 36be8a9410bc7087908ac14aae7cff2d3e069e5d..0000000000000000000000000000000000000000 |
--- a/nspr/pr/src/threads/prmon.c |
+++ /dev/null |
@@ -1,346 +0,0 @@ |
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ |
-/* This Source Code Form is subject to the terms of the Mozilla Public |
- * License, v. 2.0. If a copy of the MPL was not distributed with this |
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ |
- |
-#include "primpl.h" |
- |
-/************************************************************************/ |
- |
-/* |
- * Notifies just get posted to the monitor. The actual notification is done |
- * when the monitor is fully exited so that MP systems don't contend for a |
- * monitor that they can't enter. |
- */ |
-static void _PR_PostNotifyToMonitor(PRMonitor *mon, PRBool broadcast) |
-{ |
- PR_ASSERT(mon != NULL); |
- PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mon); |
- |
- /* mon->notifyTimes is protected by the monitor, so we don't need to |
- * acquire mon->lock. |
- */ |
- if (broadcast) |
- mon->notifyTimes = -1; |
- else if (mon->notifyTimes != -1) |
- mon->notifyTimes += 1; |
-} |
- |
-static void _PR_PostNotifiesFromMonitor(PRCondVar *cv, PRIntn times) |
-{ |
- PRStatus rv; |
- |
- /* |
- * Time to actually notify any waits that were affected while the monitor |
- * was entered. |
- */ |
- PR_ASSERT(cv != NULL); |
- PR_ASSERT(times != 0); |
- if (times == -1) { |
- rv = PR_NotifyAllCondVar(cv); |
- PR_ASSERT(rv == PR_SUCCESS); |
- } else { |
- while (times-- > 0) { |
- rv = PR_NotifyCondVar(cv); |
- PR_ASSERT(rv == PR_SUCCESS); |
- } |
- } |
-} |
- |
-/* |
-** Create a new monitor. |
-*/ |
-PR_IMPLEMENT(PRMonitor*) PR_NewMonitor() |
-{ |
- PRMonitor *mon; |
- PRStatus rv; |
- |
- if (!_pr_initialized) _PR_ImplicitInitialization(); |
- |
- mon = PR_NEWZAP(PRMonitor); |
- if (mon == NULL) { |
- PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0); |
- return NULL; |
- } |
- |
- rv = _PR_InitLock(&mon->lock); |
- PR_ASSERT(rv == PR_SUCCESS); |
- if (rv != PR_SUCCESS) |
- goto error1; |
- |
- mon->owner = NULL; |
- |
- rv = _PR_InitCondVar(&mon->entryCV, &mon->lock); |
- PR_ASSERT(rv == PR_SUCCESS); |
- if (rv != PR_SUCCESS) |
- goto error2; |
- |
- rv = _PR_InitCondVar(&mon->waitCV, &mon->lock); |
- PR_ASSERT(rv == PR_SUCCESS); |
- if (rv != PR_SUCCESS) |
- goto error3; |
- |
- mon->notifyTimes = 0; |
- mon->entryCount = 0; |
- mon->name = NULL; |
- return mon; |
- |
-error3: |
- _PR_FreeCondVar(&mon->entryCV); |
-error2: |
- _PR_FreeLock(&mon->lock); |
-error1: |
- PR_Free(mon); |
- return NULL; |
-} |
- |
-PR_IMPLEMENT(PRMonitor*) PR_NewNamedMonitor(const char* name) |
-{ |
- PRMonitor* mon = PR_NewMonitor(); |
- if (mon) |
- mon->name = name; |
- return mon; |
-} |
- |
-/* |
-** Destroy a monitor. There must be no thread waiting on the monitor's |
-** condition variable. The caller is responsible for guaranteeing that the |
-** monitor is no longer in use. |
-*/ |
-PR_IMPLEMENT(void) PR_DestroyMonitor(PRMonitor *mon) |
-{ |
- PR_ASSERT(mon != NULL); |
- _PR_FreeCondVar(&mon->waitCV); |
- _PR_FreeCondVar(&mon->entryCV); |
- _PR_FreeLock(&mon->lock); |
-#if defined(DEBUG) |
- memset(mon, 0xaf, sizeof(PRMonitor)); |
-#endif |
- PR_Free(mon); |
-} |
- |
-/* |
-** Enter the lock associated with the monitor. |
-*/ |
-PR_IMPLEMENT(void) PR_EnterMonitor(PRMonitor *mon) |
-{ |
- PRThread *me = _PR_MD_CURRENT_THREAD(); |
- PRStatus rv; |
- |
- PR_ASSERT(mon != NULL); |
- PR_Lock(&mon->lock); |
- if (mon->entryCount != 0) { |
- if (mon->owner == me) |
- goto done; |
- while (mon->entryCount != 0) { |
- rv = PR_WaitCondVar(&mon->entryCV, PR_INTERVAL_NO_TIMEOUT); |
- PR_ASSERT(rv == PR_SUCCESS); |
- } |
- } |
- /* and now I have the monitor */ |
- PR_ASSERT(mon->notifyTimes == 0); |
- PR_ASSERT(mon->owner == NULL); |
- mon->owner = me; |
- |
-done: |
- mon->entryCount += 1; |
- rv = PR_Unlock(&mon->lock); |
- PR_ASSERT(rv == PR_SUCCESS); |
-} |
- |
-/* |
-** Test and then enter the lock associated with the monitor if it's not |
-** already entered by some other thread. Return PR_FALSE if some other |
-** thread owned the lock at the time of the call. |
-*/ |
-PR_IMPLEMENT(PRBool) PR_TestAndEnterMonitor(PRMonitor *mon) |
-{ |
- PRThread *me = _PR_MD_CURRENT_THREAD(); |
- PRStatus rv; |
- |
- PR_ASSERT(mon != NULL); |
- PR_Lock(&mon->lock); |
- if (mon->entryCount != 0) { |
- if (mon->owner == me) |
- goto done; |
- rv = PR_Unlock(&mon->lock); |
- PR_ASSERT(rv == PR_SUCCESS); |
- return PR_FALSE; |
- } |
- /* and now I have the monitor */ |
- PR_ASSERT(mon->notifyTimes == 0); |
- PR_ASSERT(mon->owner == NULL); |
- mon->owner = me; |
- |
-done: |
- mon->entryCount += 1; |
- rv = PR_Unlock(&mon->lock); |
- PR_ASSERT(rv == PR_SUCCESS); |
- return PR_TRUE; |
-} |
- |
-/* |
-** Exit the lock associated with the monitor once. |
-*/ |
-PR_IMPLEMENT(PRStatus) PR_ExitMonitor(PRMonitor *mon) |
-{ |
- PRThread *me = _PR_MD_CURRENT_THREAD(); |
- PRStatus rv; |
- |
- PR_ASSERT(mon != NULL); |
- PR_Lock(&mon->lock); |
- /* the entries should be > 0 and we'd better be the owner */ |
- PR_ASSERT(mon->entryCount > 0); |
- PR_ASSERT(mon->owner == me); |
- if (mon->entryCount == 0 || mon->owner != me) |
- { |
- rv = PR_Unlock(&mon->lock); |
- PR_ASSERT(rv == PR_SUCCESS); |
- return PR_FAILURE; |
- } |
- |
- mon->entryCount -= 1; /* reduce by one */ |
- if (mon->entryCount == 0) |
- { |
- /* and if it transitioned to zero - notify an entry waiter */ |
- /* make the owner unknown */ |
- mon->owner = NULL; |
- if (mon->notifyTimes != 0) { |
- _PR_PostNotifiesFromMonitor(&mon->waitCV, mon->notifyTimes); |
- mon->notifyTimes = 0; |
- } |
- rv = PR_NotifyCondVar(&mon->entryCV); |
- PR_ASSERT(rv == PR_SUCCESS); |
- } |
- rv = PR_Unlock(&mon->lock); |
- PR_ASSERT(rv == PR_SUCCESS); |
- return PR_SUCCESS; |
-} |
- |
-/* |
-** Return the number of times that the current thread has entered the |
-** lock. Returns zero if the current thread has not entered the lock. |
-*/ |
-PR_IMPLEMENT(PRIntn) PR_GetMonitorEntryCount(PRMonitor *mon) |
-{ |
- PRThread *me = _PR_MD_CURRENT_THREAD(); |
- PRStatus rv; |
- PRIntn count = 0; |
- |
- PR_Lock(&mon->lock); |
- if (mon->owner == me) |
- count = mon->entryCount; |
- rv = PR_Unlock(&mon->lock); |
- PR_ASSERT(rv == PR_SUCCESS); |
- return count; |
-} |
- |
-PR_IMPLEMENT(void) PR_AssertCurrentThreadInMonitor(PRMonitor *mon) |
-{ |
-#if defined(DEBUG) || defined(FORCE_PR_ASSERT) |
- PRStatus rv; |
- |
- PR_Lock(&mon->lock); |
- PR_ASSERT(mon->entryCount != 0 && |
- mon->owner == _PR_MD_CURRENT_THREAD()); |
- rv = PR_Unlock(&mon->lock); |
- PR_ASSERT(rv == PR_SUCCESS); |
-#endif |
-} |
- |
-/* |
-** Wait for a notify on the condition variable. Sleep for "ticks" amount |
-** of time (if "tick" is 0 then the sleep is indefinite). While |
-** the thread is waiting it exits the monitors lock (as if it called |
-** PR_ExitMonitor as many times as it had called PR_EnterMonitor). When |
-** the wait has finished the thread regains control of the monitors lock |
-** with the same entry count as before the wait began. |
-** |
-** The thread waiting on the monitor will be resumed when the monitor is |
-** notified (assuming the thread is the next in line to receive the |
-** notify) or when the "ticks" elapses. |
-** |
-** Returns PR_FAILURE if the caller has not locked the lock associated |
-** with the condition variable. |
-** This routine can return PR_PENDING_INTERRUPT_ERROR if the waiting thread |
-** has been interrupted. |
-*/ |
-PR_IMPLEMENT(PRStatus) PR_Wait(PRMonitor *mon, PRIntervalTime ticks) |
-{ |
- PRStatus rv; |
- PRUint32 saved_entries; |
- PRThread *saved_owner; |
- |
- PR_ASSERT(mon != NULL); |
- PR_Lock(&mon->lock); |
- /* the entries better be positive */ |
- PR_ASSERT(mon->entryCount > 0); |
- /* and it better be owned by us */ |
- PR_ASSERT(mon->owner == _PR_MD_CURRENT_THREAD()); /* XXX return failure */ |
- |
- /* tuck these away 'till later */ |
- saved_entries = mon->entryCount; |
- mon->entryCount = 0; |
- saved_owner = mon->owner; |
- mon->owner = NULL; |
- /* If we have pending notifies, post them now. */ |
- if (mon->notifyTimes != 0) { |
- _PR_PostNotifiesFromMonitor(&mon->waitCV, mon->notifyTimes); |
- mon->notifyTimes = 0; |
- } |
- rv = PR_NotifyCondVar(&mon->entryCV); |
- PR_ASSERT(rv == PR_SUCCESS); |
- |
- rv = PR_WaitCondVar(&mon->waitCV, ticks); |
- PR_ASSERT(rv == PR_SUCCESS); |
- |
- while (mon->entryCount != 0) { |
- rv = PR_WaitCondVar(&mon->entryCV, PR_INTERVAL_NO_TIMEOUT); |
- PR_ASSERT(rv == PR_SUCCESS); |
- } |
- PR_ASSERT(mon->notifyTimes == 0); |
- /* reinstate the interesting information */ |
- mon->entryCount = saved_entries; |
- mon->owner = saved_owner; |
- |
- rv = PR_Unlock(&mon->lock); |
- PR_ASSERT(rv == PR_SUCCESS); |
- return rv; |
-} |
- |
-/* |
-** Notify the highest priority thread waiting on the condition |
-** variable. If a thread is waiting on the condition variable (using |
-** PR_Wait) then it is awakened and begins waiting on the monitor's lock. |
-*/ |
-PR_IMPLEMENT(PRStatus) PR_Notify(PRMonitor *mon) |
-{ |
- _PR_PostNotifyToMonitor(mon, PR_FALSE); |
- return PR_SUCCESS; |
-} |
- |
-/* |
-** Notify all of the threads waiting on the condition variable. All of |
-** threads are notified in turn. The highest priority thread will |
-** probably acquire the monitor first when the monitor is exited. |
-*/ |
-PR_IMPLEMENT(PRStatus) PR_NotifyAll(PRMonitor *mon) |
-{ |
- _PR_PostNotifyToMonitor(mon, PR_TRUE); |
- return PR_SUCCESS; |
-} |
- |
-/************************************************************************/ |
- |
-PRUint32 _PR_MonitorToString(PRMonitor *mon, char *buf, PRUint32 buflen) |
-{ |
- PRUint32 nb; |
- |
- if (mon->owner) { |
- nb = PR_snprintf(buf, buflen, "[%p] owner=%d[%p] count=%ld", |
- mon, mon->owner->id, mon->owner, mon->entryCount); |
- } else { |
- nb = PR_snprintf(buf, buflen, "[%p]", mon); |
- } |
- return nb; |
-} |