summaryrefslogtreecommitdiffstats
path: root/locks/win32/thread_cond.c
diff options
context:
space:
mode:
Diffstat (limited to 'locks/win32/thread_cond.c')
-rw-r--r--locks/win32/thread_cond.c188
1 files changed, 188 insertions, 0 deletions
diff --git a/locks/win32/thread_cond.c b/locks/win32/thread_cond.c
new file mode 100644
index 0000000..f571f9e
--- /dev/null
+++ b/locks/win32/thread_cond.c
@@ -0,0 +1,188 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "apr.h"
+#include "apr_private.h"
+#include "apr_general.h"
+#include "apr_strings.h"
+#include "apr_arch_thread_mutex.h"
+#include "apr_arch_thread_cond.h"
+#include "apr_portable.h"
+
+#include <limits.h>
+
+static apr_status_t thread_cond_cleanup(void *data)
+{
+ apr_thread_cond_t *cond = data;
+ CloseHandle(cond->semaphore);
+ DeleteCriticalSection(&cond->csection);
+ return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_create(apr_thread_cond_t **cond,
+ apr_pool_t *pool)
+{
+ apr_thread_cond_t *cv;
+
+ cv = apr_pcalloc(pool, sizeof(**cond));
+ if (cv == NULL) {
+ return APR_ENOMEM;
+ }
+
+ cv->semaphore = CreateSemaphore(NULL, 0, LONG_MAX, NULL);
+ if (cv->semaphore == NULL) {
+ return apr_get_os_error();
+ }
+
+ *cond = cv;
+ cv->pool = pool;
+ InitializeCriticalSection(&cv->csection);
+ apr_pool_cleanup_register(cv->pool, cv, thread_cond_cleanup,
+ apr_pool_cleanup_null);
+
+ return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_destroy(apr_thread_cond_t *cond)
+{
+ return apr_pool_cleanup_run(cond->pool, cond, thread_cond_cleanup);
+}
+
+static APR_INLINE apr_status_t thread_cond_timedwait(apr_thread_cond_t *cond,
+ apr_thread_mutex_t *mutex,
+ apr_interval_time_t timeout)
+{
+ DWORD res;
+ apr_status_t rv;
+ unsigned int wake = 0;
+ unsigned long generation;
+ DWORD timeout_ms = 0;
+
+ EnterCriticalSection(&cond->csection);
+ cond->num_waiting++;
+ generation = cond->generation;
+ LeaveCriticalSection(&cond->csection);
+
+ apr_thread_mutex_unlock(mutex);
+
+ do {
+ apr_interval_time_t t = timeout;
+
+ do {
+ if (t < 0) {
+ timeout_ms = INFINITE;
+ }
+ else if (t > 0) {
+ /* Given timeout is 64bit usecs whereas Windows timeouts are
+ * 32bit msecs and below INFINITE (2^32 - 1), so we may need
+ * multiple timed out waits...
+ */
+ if (t > apr_time_from_msec(INFINITE - 1)) {
+ timeout_ms = INFINITE - 1;
+ t -= apr_time_from_msec(INFINITE - 1);
+ }
+ else {
+ timeout_ms = (DWORD)apr_time_as_msec(t);
+ t = 0;
+ }
+ }
+ res = WaitForSingleObject(cond->semaphore, timeout_ms);
+ } while (res == WAIT_TIMEOUT && t > 0);
+
+ EnterCriticalSection(&cond->csection);
+
+ if (cond->num_wake) {
+ if (cond->generation != generation) {
+ cond->num_wake--;
+ cond->num_waiting--;
+ rv = APR_SUCCESS;
+ break;
+ } else {
+ wake = 1;
+ }
+ }
+ else if (res != WAIT_OBJECT_0) {
+ cond->num_waiting--;
+ rv = APR_TIMEUP;
+ break;
+ }
+
+ LeaveCriticalSection(&cond->csection);
+
+ if (wake) {
+ wake = 0;
+ ReleaseSemaphore(cond->semaphore, 1, NULL);
+ }
+ } while (1);
+
+ LeaveCriticalSection(&cond->csection);
+ apr_thread_mutex_lock(mutex);
+
+ return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_wait(apr_thread_cond_t *cond,
+ apr_thread_mutex_t *mutex)
+{
+ return thread_cond_timedwait(cond, mutex, (apr_interval_time_t)-1);
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_timedwait(apr_thread_cond_t *cond,
+ apr_thread_mutex_t *mutex,
+ apr_interval_time_t timeout)
+{
+ return thread_cond_timedwait(cond, mutex, timeout);
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_signal(apr_thread_cond_t *cond)
+{
+ unsigned int wake = 0;
+
+ EnterCriticalSection(&cond->csection);
+ if (cond->num_waiting > cond->num_wake) {
+ wake = 1;
+ cond->num_wake++;
+ cond->generation++;
+ }
+ LeaveCriticalSection(&cond->csection);
+
+ if (wake) {
+ ReleaseSemaphore(cond->semaphore, 1, NULL);
+ }
+
+ return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_broadcast(apr_thread_cond_t *cond)
+{
+ unsigned long num_wake = 0;
+
+ EnterCriticalSection(&cond->csection);
+ if (cond->num_waiting > cond->num_wake) {
+ num_wake = cond->num_waiting - cond->num_wake;
+ cond->num_wake = cond->num_waiting;
+ cond->generation++;
+ }
+ LeaveCriticalSection(&cond->csection);
+
+ if (num_wake) {
+ ReleaseSemaphore(cond->semaphore, num_wake, NULL);
+ }
+
+ return APR_SUCCESS;
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(thread_cond)