summaryrefslogtreecommitdiffstats
path: root/test/testcond.c
diff options
context:
space:
mode:
Diffstat (limited to 'test/testcond.c')
-rw-r--r--test/testcond.c670
1 files changed, 670 insertions, 0 deletions
diff --git a/test/testcond.c b/test/testcond.c
new file mode 100644
index 0000000..b5a20bc
--- /dev/null
+++ b/test/testcond.c
@@ -0,0 +1,670 @@
+/* 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_file_io.h"
+#include "apr_thread_proc.h"
+#include "apr_thread_mutex.h"
+#include "apr_thread_cond.h"
+#include "apr_errno.h"
+#include "apr_general.h"
+#include "apr_atomic.h"
+#include "testutil.h"
+
+#define NTHREADS 10
+
+#define ABTS_SUCCESS(rv) ABTS_INT_EQUAL(tc, APR_SUCCESS, rv)
+
+#if APR_HAS_THREADS
+
+typedef struct toolbox_t toolbox_t;
+
+struct toolbox_t {
+ void *data;
+ abts_case *tc;
+ apr_thread_mutex_t *mutex;
+ apr_thread_cond_t *cond;
+ void (*func)(toolbox_t *box);
+};
+
+typedef struct toolbox_fnptr_t toolbox_fnptr_t;
+
+struct toolbox_fnptr_t {
+ void (*func)(toolbox_t *box);
+};
+
+static void lost_signal(abts_case *tc, void *data)
+{
+ apr_status_t rv;
+ apr_thread_cond_t *cond = NULL;
+ apr_thread_mutex_t *mutex = NULL;
+
+ rv = apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_DEFAULT, p);
+ ABTS_SUCCESS(rv);
+ ABTS_PTR_NOTNULL(tc, mutex);
+
+ rv = apr_thread_cond_create(&cond, p);
+ ABTS_SUCCESS(rv);
+ ABTS_PTR_NOTNULL(tc, cond);
+
+ rv = apr_thread_cond_signal(cond);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_lock(mutex);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_cond_timedwait(cond, mutex, 10000);
+ ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(rv));
+
+ rv = apr_thread_mutex_unlock(mutex);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_cond_broadcast(cond);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_lock(mutex);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_cond_timedwait(cond, mutex, 10000);
+ ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(rv));
+
+ rv = apr_thread_mutex_unlock(mutex);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_cond_destroy(cond);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_destroy(mutex);
+ ABTS_SUCCESS(rv);
+}
+
+static void *APR_THREAD_FUNC thread_routine(apr_thread_t *thd, void *data)
+{
+ toolbox_t *box = data;
+
+ box->func(box);
+
+ apr_thread_exit(thd, 0);
+
+ return NULL;
+}
+
+static void lock_and_signal(toolbox_t *box)
+{
+ apr_status_t rv;
+ abts_case *tc = box->tc;
+
+ rv = apr_thread_mutex_lock(box->mutex);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_cond_signal(box->cond);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_unlock(box->mutex);
+ ABTS_SUCCESS(rv);
+}
+
+static void dynamic_binding(abts_case *tc, void *data)
+{
+ unsigned int i;
+ apr_status_t rv;
+ toolbox_t box[NTHREADS];
+ apr_thread_t *thread[NTHREADS];
+ apr_thread_mutex_t *mutex[NTHREADS];
+ apr_thread_cond_t *cond = NULL;
+
+ rv = apr_thread_cond_create(&cond, p);
+ ABTS_SUCCESS(rv);
+ ABTS_PTR_NOTNULL(tc, cond);
+
+ for (i = 0; i < NTHREADS; i++) {
+ rv = apr_thread_mutex_create(&mutex[i], APR_THREAD_MUTEX_DEFAULT, p);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_lock(mutex[i]);
+ ABTS_SUCCESS(rv);
+
+ box[i].tc = tc;
+ box[i].cond = cond;
+ box[i].mutex = mutex[i];
+ box[i].func = lock_and_signal;
+
+ rv = apr_thread_create(&thread[i], NULL, thread_routine, &box[i], p);
+ ABTS_SUCCESS(rv);
+ }
+
+ /*
+ * The dynamic binding should be preserved because we use only one waiter
+ */
+
+ for (i = 0; i < NTHREADS; i++) {
+ rv = apr_thread_cond_wait(cond, mutex[i]);
+ ABTS_SUCCESS(rv);
+ }
+
+ for (i = 0; i < NTHREADS; i++) {
+ rv = apr_thread_cond_timedwait(cond, mutex[i], 10000);
+ ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(rv));
+
+ rv = apr_thread_mutex_unlock(mutex[i]);
+ ABTS_SUCCESS(rv);
+ }
+
+ for (i = 0; i < NTHREADS; i++) {
+ apr_status_t retval;
+ rv = apr_thread_join(&retval, thread[i]);
+ ABTS_SUCCESS(rv);
+ }
+
+ rv = apr_thread_cond_destroy(cond);
+ ABTS_SUCCESS(rv);
+
+ for (i = 0; i < NTHREADS; i++) {
+ rv = apr_thread_mutex_destroy(mutex[i]);
+ ABTS_SUCCESS(rv);
+ }
+}
+
+static void lock_and_wait(toolbox_t *box)
+{
+ apr_status_t rv;
+ abts_case *tc = box->tc;
+ apr_uint32_t *count = box->data;
+
+ rv = apr_thread_mutex_lock(box->mutex);
+ ABTS_SUCCESS(rv);
+
+ apr_atomic_inc32(count);
+
+ rv = apr_thread_cond_wait(box->cond, box->mutex);
+ ABTS_SUCCESS(rv);
+
+ apr_atomic_dec32(count);
+
+ rv = apr_thread_mutex_unlock(box->mutex);
+ ABTS_SUCCESS(rv);
+}
+
+static void broadcast_threads(abts_case *tc, void *data)
+{
+ toolbox_t box;
+ unsigned int i;
+ apr_status_t rv;
+ apr_uint32_t count = 0;
+ apr_thread_cond_t *cond = NULL;
+ apr_thread_mutex_t *mutex = NULL;
+ apr_thread_t *thread[NTHREADS];
+
+ rv = apr_thread_cond_create(&cond, p);
+ ABTS_SUCCESS(rv);
+ ABTS_PTR_NOTNULL(tc, cond);
+
+ rv = apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_DEFAULT, p);
+ ABTS_SUCCESS(rv);
+ ABTS_PTR_NOTNULL(tc, mutex);
+
+ rv = apr_thread_mutex_lock(mutex);
+ ABTS_SUCCESS(rv);
+
+ box.tc = tc;
+ box.data = &count;
+ box.mutex = mutex;
+ box.cond = cond;
+ box.func = lock_and_wait;
+
+ for (i = 0; i < NTHREADS; i++) {
+ rv = apr_thread_create(&thread[i], NULL, thread_routine, &box, p);
+ ABTS_SUCCESS(rv);
+ }
+
+ do {
+ rv = apr_thread_mutex_unlock(mutex);
+ ABTS_SUCCESS(rv);
+ apr_sleep(100000);
+ rv = apr_thread_mutex_lock(mutex);
+ ABTS_SUCCESS(rv);
+ } while (apr_atomic_read32(&count) != NTHREADS);
+
+ rv = apr_thread_cond_broadcast(cond);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_unlock(mutex);
+ ABTS_SUCCESS(rv);
+
+ for (i = 0; i < NTHREADS; i++) {
+ apr_status_t retval;
+ rv = apr_thread_join(&retval, thread[i]);
+ ABTS_SUCCESS(rv);
+ }
+
+ ABTS_INT_EQUAL(tc, 0, count);
+
+ rv = apr_thread_cond_destroy(cond);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_destroy(mutex);
+ ABTS_SUCCESS(rv);
+}
+
+static void nested_lock_and_wait(toolbox_t *box)
+{
+ apr_status_t rv;
+ abts_case *tc = box->tc;
+
+ rv = apr_thread_mutex_lock(box->mutex);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_lock(box->mutex);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_lock(box->mutex);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_cond_wait(box->cond, box->mutex);
+ ABTS_SUCCESS(rv);
+}
+
+static void nested_lock_and_unlock(toolbox_t *box)
+{
+ apr_status_t rv;
+ abts_case *tc = box->tc;
+
+ rv = apr_thread_mutex_lock(box->mutex);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_lock(box->mutex);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_lock(box->mutex);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_cond_timedwait(box->cond, box->mutex, 2000000);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_unlock(box->mutex);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_unlock(box->mutex);
+ ABTS_SUCCESS(rv);
+}
+
+static void nested_wait(abts_case *tc, void *data)
+{
+ toolbox_fnptr_t *fnptr = data;
+ toolbox_t box;
+ apr_status_t rv, retval;
+ apr_thread_cond_t *cond = NULL;
+ apr_thread_t *thread = NULL;
+ apr_thread_mutex_t *mutex = NULL;
+
+ rv = apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_NESTED, p);
+ ABTS_SUCCESS(rv);
+ ABTS_PTR_NOTNULL(tc, mutex);
+
+ rv = apr_thread_cond_create(&cond, p);
+ ABTS_SUCCESS(rv);
+ ABTS_PTR_NOTNULL(tc, cond);
+
+ rv = apr_thread_mutex_lock(mutex);
+ ABTS_SUCCESS(rv);
+
+ box.tc = tc;
+ box.cond = cond;
+ box.mutex = mutex;
+ box.func = fnptr->func;
+
+ rv = apr_thread_create(&thread, NULL, thread_routine, &box, p);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_unlock(mutex);
+ ABTS_SUCCESS(rv);
+
+ /* yield the processor */
+ apr_sleep(500000);
+
+ rv = apr_thread_cond_signal(cond);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_join(&retval, thread);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_trylock(mutex);
+ ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_EBUSY(rv));
+
+ rv = apr_thread_mutex_trylock(mutex);
+ ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_EBUSY(rv));
+}
+
+static volatile apr_uint64_t pipe_count;
+static volatile apr_uint32_t exiting;
+
+static void pipe_consumer(toolbox_t *box)
+{
+ char ch;
+ apr_status_t rv;
+ apr_size_t nbytes;
+ abts_case *tc = box->tc;
+ apr_file_t *out = box->data;
+ apr_uint32_t consumed = 0;
+
+ do {
+ rv = apr_thread_mutex_lock(box->mutex);
+ ABTS_SUCCESS(rv);
+
+ while (!pipe_count && !exiting) {
+ rv = apr_thread_cond_wait(box->cond, box->mutex);
+ ABTS_SUCCESS(rv);
+ }
+
+ if (!pipe_count && exiting) {
+ rv = apr_thread_mutex_unlock(box->mutex);
+ ABTS_SUCCESS(rv);
+ break;
+ }
+
+ pipe_count--;
+ consumed++;
+
+ rv = apr_thread_mutex_unlock(box->mutex);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_file_read_full(out, &ch, 1, &nbytes);
+ ABTS_SUCCESS(rv);
+ ABTS_SIZE_EQUAL(tc, 1, nbytes);
+ ABTS_TRUE(tc, ch == '.');
+ } while (1);
+
+ /* naive fairness test - it would be good to introduce or solidify
+ * a solid test to ensure one thread is not starved.
+ * ABTS_INT_EQUAL(tc, 1, !!consumed);
+ */
+}
+
+static void pipe_write(toolbox_t *box, char ch)
+{
+ apr_status_t rv;
+ apr_size_t nbytes;
+ abts_case *tc = box->tc;
+ apr_file_t *in = box->data;
+
+ rv = apr_file_write_full(in, &ch, 1, &nbytes);
+ ABTS_SUCCESS(rv);
+ ABTS_SIZE_EQUAL(tc, 1, nbytes);
+
+ rv = apr_thread_mutex_lock(box->mutex);
+ ABTS_SUCCESS(rv);
+
+ if (!pipe_count) {
+ rv = apr_thread_cond_signal(box->cond);
+ ABTS_SUCCESS(rv);
+ }
+
+ pipe_count++;
+
+ rv = apr_thread_mutex_unlock(box->mutex);
+ ABTS_SUCCESS(rv);
+}
+
+static void pipe_producer(toolbox_t *box)
+{
+ apr_uint32_t loop = 500;
+
+ do {
+ pipe_write(box, '.');
+ } while (loop--);
+}
+
+static void pipe_producer_consumer(abts_case *tc, void *data)
+{
+ apr_status_t rv;
+ toolbox_t boxcons, boxprod;
+ apr_thread_t *thread[NTHREADS];
+ apr_thread_cond_t *cond = NULL;
+ apr_thread_mutex_t *mutex = NULL;
+ apr_file_t *in = NULL, *out = NULL;
+ apr_uint32_t i, ncons = (apr_uint32_t)(NTHREADS * 0.70);
+
+ rv = apr_file_pipe_create(&in, &out, p);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_DEFAULT, p);
+ ABTS_SUCCESS(rv);
+ ABTS_PTR_NOTNULL(tc, mutex);
+
+ rv = apr_thread_cond_create(&cond, p);
+ ABTS_SUCCESS(rv);
+ ABTS_PTR_NOTNULL(tc, cond);
+
+ boxcons.tc = tc;
+ boxcons.data = in;
+ boxcons.mutex = mutex;
+ boxcons.cond = cond;
+ boxcons.func = pipe_consumer;
+
+ for (i = 0; i < ncons; i++) {
+ rv = apr_thread_create(&thread[i], NULL, thread_routine, &boxcons, p);
+ ABTS_SUCCESS(rv);
+ }
+
+ boxprod.tc = tc;
+ boxprod.data = out;
+ boxprod.mutex = mutex;
+ boxprod.cond = cond;
+ boxprod.func = pipe_producer;
+
+ for (; i < NTHREADS; i++) {
+ rv = apr_thread_create(&thread[i], NULL, thread_routine, &boxprod, p);
+ ABTS_SUCCESS(rv);
+ }
+
+ for (i = ncons; i < NTHREADS; i++) {
+ apr_status_t retval;
+ rv = apr_thread_join(&retval, thread[i]);
+ ABTS_SUCCESS(rv);
+ }
+
+ rv = apr_thread_mutex_lock(mutex);
+ ABTS_SUCCESS(rv);
+
+ exiting = 1;
+
+ rv = apr_thread_cond_broadcast(cond);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_unlock(mutex);
+ ABTS_SUCCESS(rv);
+
+ for (i = 0; i < ncons; i++) {
+ apr_status_t retval;
+ rv = apr_thread_join(&retval, thread[i]);
+ ABTS_SUCCESS(rv);
+ }
+
+ rv = apr_thread_cond_destroy(cond);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_destroy(mutex);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_file_close(in);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_file_close(out);
+ ABTS_SUCCESS(rv);
+}
+
+volatile enum {
+ TOSS,
+ PING,
+ PONG,
+ OVER
+} state;
+
+static void ping(toolbox_t *box)
+{
+ apr_status_t rv;
+ abts_case *tc = box->tc;
+
+ rv = apr_thread_mutex_lock(box->mutex);
+ ABTS_SUCCESS(rv);
+
+ if (state == TOSS)
+ state = PING;
+
+ do {
+ rv = apr_thread_cond_signal(box->cond);
+ ABTS_SUCCESS(rv);
+
+ state = PONG;
+
+ rv = apr_thread_cond_wait(box->cond, box->mutex);
+ ABTS_SUCCESS(rv);
+
+ ABTS_TRUE(tc, state == PING || state == OVER);
+ } while (state != OVER);
+
+ rv = apr_thread_mutex_unlock(box->mutex);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_cond_broadcast(box->cond);
+ ABTS_SUCCESS(rv);
+}
+
+static void pong(toolbox_t *box)
+{
+ apr_status_t rv;
+ abts_case *tc = box->tc;
+
+ rv = apr_thread_mutex_lock(box->mutex);
+ ABTS_SUCCESS(rv);
+
+ if (state == TOSS)
+ state = PONG;
+
+ do {
+ rv = apr_thread_cond_signal(box->cond);
+ ABTS_SUCCESS(rv);
+
+ state = PING;
+
+ rv = apr_thread_cond_wait(box->cond, box->mutex);
+ ABTS_SUCCESS(rv);
+
+ ABTS_TRUE(tc, state == PONG || state == OVER);
+ } while (state != OVER);
+
+ rv = apr_thread_mutex_unlock(box->mutex);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_cond_broadcast(box->cond);
+ ABTS_SUCCESS(rv);
+}
+
+static void ping_pong(abts_case *tc, void *data)
+{
+ apr_status_t rv, retval;
+ toolbox_t box_ping, box_pong;
+ apr_thread_cond_t *cond = NULL;
+ apr_thread_mutex_t *mutex = NULL;
+ apr_thread_t *thr_ping = NULL, *thr_pong = NULL;
+
+ rv = apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_DEFAULT, p);
+ ABTS_SUCCESS(rv);
+ ABTS_PTR_NOTNULL(tc, mutex);
+
+ rv = apr_thread_cond_create(&cond, p);
+ ABTS_SUCCESS(rv);
+ ABTS_PTR_NOTNULL(tc, cond);
+
+ rv = apr_thread_mutex_lock(mutex);
+ ABTS_SUCCESS(rv);
+
+ box_ping.tc = tc;
+ box_ping.data = NULL;
+ box_ping.mutex = mutex;
+ box_ping.cond = cond;
+ box_ping.func = ping;
+
+ rv = apr_thread_create(&thr_ping, NULL, thread_routine, &box_ping, p);
+ ABTS_SUCCESS(rv);
+
+ box_pong.tc = tc;
+ box_pong.data = NULL;
+ box_pong.mutex = mutex;
+ box_pong.cond = cond;
+ box_pong.func = pong;
+
+ rv = apr_thread_create(&thr_pong, NULL, thread_routine, &box_pong, p);
+ ABTS_SUCCESS(rv);
+
+ state = TOSS;
+
+ rv = apr_thread_mutex_unlock(mutex);
+ ABTS_SUCCESS(rv);
+
+ apr_sleep(3000000);
+
+ rv = apr_thread_mutex_lock(mutex);
+ ABTS_SUCCESS(rv);
+
+ state = OVER;
+
+ rv = apr_thread_mutex_unlock(mutex);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_join(&retval, thr_ping);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_join(&retval, thr_pong);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_cond_destroy(cond);
+ ABTS_SUCCESS(rv);
+
+ rv = apr_thread_mutex_destroy(mutex);
+ ABTS_SUCCESS(rv);
+}
+#endif /* !APR_HAS_THREADS */
+
+#if !APR_HAS_THREADS
+static void threads_not_impl(abts_case *tc, void *data)
+{
+ ABTS_NOT_IMPL(tc, "Threads not implemented on this platform");
+}
+#endif
+
+abts_suite *testcond(abts_suite *suite)
+{
+#if APR_HAS_THREADS
+ toolbox_fnptr_t fnptr;
+#endif
+ suite = ADD_SUITE(suite)
+
+#if !APR_HAS_THREADS
+ abts_run_test(suite, threads_not_impl, NULL);
+#else
+ abts_run_test(suite, lost_signal, NULL);
+ abts_run_test(suite, dynamic_binding, NULL);
+ abts_run_test(suite, broadcast_threads, NULL);
+ fnptr.func = nested_lock_and_wait;
+ abts_run_test(suite, nested_wait, &fnptr);
+ fnptr.func = nested_lock_and_unlock;
+ abts_run_test(suite, nested_wait, &fnptr);
+ abts_run_test(suite, pipe_producer_consumer, NULL);
+ abts_run_test(suite, ping_pong, NULL);
+#endif
+
+ return suite;
+}