minix/external/bsd/libevent/dist/test/regress_thread.c

521 lines
13 KiB
C
Raw Normal View History

/* $NetBSD: regress_thread.c,v 1.4 2013/04/12 20:00:21 christos Exp $ */
/*
* Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* The old tests here need assertions to work. */
#undef NDEBUG
#include "event2/event-config.h"
#include <sys/cdefs.h>
__RCSID("$NetBSD: regress_thread.c,v 1.4 2013/04/12 20:00:21 christos Exp $");
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef _EVENT_HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef _EVENT_HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif
#ifdef _EVENT_HAVE_PTHREADS
#include <pthread.h>
#elif defined(WIN32)
#include <process.h>
#endif
#include <assert.h>
#ifdef _EVENT_HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <time.h>
#include "sys/queue.h"
#include "event2/util.h"
#include "event2/event.h"
#include "event2/event_struct.h"
#include "event2/thread.h"
#include "evthread-internal.h"
#include "event-internal.h"
#include "defer-internal.h"
#include "regress.h"
#include "tinytest_macros.h"
#ifdef _EVENT_HAVE_PTHREADS
#define THREAD_T pthread_t
#define THREAD_FN void *
#define THREAD_RETURN() return (NULL)
#define THREAD_START(threadvar, fn, arg) \
pthread_create(&(threadvar), NULL, fn, arg)
#define THREAD_JOIN(th) pthread_join(th, NULL)
#else
#define THREAD_T HANDLE
#define THREAD_FN unsigned __stdcall
#define THREAD_RETURN() return (0)
#define THREAD_START(threadvar, fn, arg) do { \
uintptr_t threadhandle = _beginthreadex(NULL,0,fn,(arg),0,NULL); \
(threadvar) = (HANDLE) threadhandle; \
} while (/*CONSTCOND*/0)
#define THREAD_JOIN(th) WaitForSingleObject(th, INFINITE)
#endif
struct cond_wait {
void *lock;
void *cond;
};
static void
wake_all_timeout(evutil_socket_t fd, short what, void *arg)
{
struct cond_wait *cw = arg;
EVLOCK_LOCK(cw->lock, 0);
EVTHREAD_COND_BROADCAST(cw->cond);
EVLOCK_UNLOCK(cw->lock, 0);
}
#if 0
static void
wake_one_timeout(evutil_socket_t fd, short what, void *arg)
{
struct cond_wait *cw = arg;
EVLOCK_LOCK(cw->lock, 0);
EVTHREAD_COND_SIGNAL(cw->cond);
EVLOCK_UNLOCK(cw->lock, 0);
}
#endif
#define NUM_THREADS 100
#define NUM_ITERATIONS 100
void *count_lock;
static int count;
static THREAD_FN
basic_thread(void *arg)
{
struct cond_wait cw;
struct event_base *base = arg;
struct event ev;
int i = 0;
EVTHREAD_ALLOC_LOCK(cw.lock, 0);
EVTHREAD_ALLOC_COND(cw.cond);
assert(cw.lock);
assert(cw.cond);
evtimer_assign(&ev, base, wake_all_timeout, &cw);
for (i = 0; i < NUM_ITERATIONS; i++) {
struct timeval tv;
evutil_timerclear(&tv);
tv.tv_sec = 0;
tv.tv_usec = 3000;
EVLOCK_LOCK(cw.lock, 0);
/* we need to make sure that event does not happen before
* we get to wait on the conditional variable */
assert(evtimer_add(&ev, &tv) == 0);
assert(EVTHREAD_COND_WAIT(cw.cond, cw.lock) == 0);
EVLOCK_UNLOCK(cw.lock, 0);
EVLOCK_LOCK(count_lock, 0);
++count;
EVLOCK_UNLOCK(count_lock, 0);
}
/* exit the loop only if all threads fired all timeouts */
EVLOCK_LOCK(count_lock, 0);
if (count >= NUM_THREADS * NUM_ITERATIONS)
event_base_loopexit(base, NULL);
EVLOCK_UNLOCK(count_lock, 0);
EVTHREAD_FREE_LOCK(cw.lock, 0);
EVTHREAD_FREE_COND(cw.cond);
THREAD_RETURN();
}
static int notification_fd_used = 0;
#ifndef WIN32
static int got_sigchld = 0;
static void
sigchld_cb(evutil_socket_t fd, short event, void *arg)
{
struct timeval tv;
struct event_base *base = arg;
got_sigchld++;
tv.tv_usec = 100000;
tv.tv_sec = 0;
event_base_loopexit(base, &tv);
}
static void
notify_fd_cb(evutil_socket_t fd, short event, void *arg)
{
++notification_fd_used;
}
#endif
static void
thread_basic(void *arg)
{
THREAD_T threads[NUM_THREADS];
struct event ev;
struct timeval tv;
int i;
struct basic_test_data *data = arg;
struct event_base *base = data->base;
struct event *notification_event = NULL;
struct event *sigchld_event = NULL;
EVTHREAD_ALLOC_LOCK(count_lock, 0);
tt_assert(count_lock);
tt_assert(base);
if (evthread_make_base_notifiable(base)<0) {
tt_abort_msg("Couldn't make base notifiable!");
}
#ifndef WIN32
if (data->setup_data && !strcmp(data->setup_data, "forking")) {
pid_t pid;
int status;
sigchld_event = evsignal_new(base, SIGCHLD, sigchld_cb, base);
/* This piggybacks on the th_notify_fd weirdly, and looks
* inside libevent internals. Not a good idea in non-testing
* code! */
notification_event = event_new(base,
base->th_notify_fd[0], EV_READ|EV_PERSIST, notify_fd_cb,
NULL);
event_add(sigchld_event, NULL);
event_add(notification_event, NULL);
if ((pid = fork()) == 0) {
event_del(notification_event);
if (event_reinit(base) < 0) {
TT_FAIL(("reinit"));
exit(1);
}
event_assign(notification_event, base,
base->th_notify_fd[0], EV_READ|EV_PERSIST,
notify_fd_cb, NULL);
event_add(notification_event, NULL);
goto child;
}
event_base_dispatch(base);
if (waitpid(pid, &status, 0) == -1)
tt_abort_perror("waitpid");
TT_BLATHER(("Waitpid okay\n"));
tt_assert(got_sigchld);
tt_int_op(notification_fd_used, ==, 0);
goto end;
}
child:
#endif
for (i = 0; i < NUM_THREADS; ++i)
THREAD_START(threads[i], basic_thread, base);
evtimer_assign(&ev, base, NULL, NULL);
evutil_timerclear(&tv);
tv.tv_sec = 1000;
event_add(&ev, &tv);
event_base_dispatch(base);
for (i = 0; i < NUM_THREADS; ++i)
THREAD_JOIN(threads[i]);
event_del(&ev);
tt_int_op(count, ==, NUM_THREADS * NUM_ITERATIONS);
EVTHREAD_FREE_LOCK(count_lock, 0);
TT_BLATHER(("notifiations==%d", notification_fd_used));
end:
if (notification_event)
event_free(notification_event);
if (sigchld_event)
event_free(sigchld_event);
}
#undef NUM_THREADS
#define NUM_THREADS 10
struct alerted_record {
struct cond_wait *cond;
struct timeval delay;
struct timeval alerted_at;
int timed_out;
};
#if 0
static THREAD_FN
wait_for_condition(void *arg)
{
struct alerted_record *rec = arg;
int r;
EVLOCK_LOCK(rec->cond->lock, 0);
if (rec->delay.tv_sec || rec->delay.tv_usec) {
r = EVTHREAD_COND_WAIT_TIMED(rec->cond->cond, rec->cond->lock,
&rec->delay);
} else {
r = EVTHREAD_COND_WAIT(rec->cond->cond, rec->cond->lock);
}
EVLOCK_UNLOCK(rec->cond->lock, 0);
evutil_gettimeofday(&rec->alerted_at, NULL);
if (r == 1)
rec->timed_out = 1;
THREAD_RETURN();
}
static void
thread_conditions_simple(void *arg)
{
struct timeval tv_signal, tv_timeout, tv_broadcast;
struct alerted_record alerted[NUM_THREADS];
THREAD_T threads[NUM_THREADS];
struct cond_wait cond;
int i;
struct timeval launched_at;
struct event wake_one;
struct event wake_all;
struct basic_test_data *data = arg;
struct event_base *base = data->base;
int n_timed_out=0, n_signal=0, n_broadcast=0;
tv_signal.tv_sec = tv_timeout.tv_sec = tv_broadcast.tv_sec = 0;
tv_signal.tv_usec = 30*1000;
tv_timeout.tv_usec = 150*1000;
tv_broadcast.tv_usec = 500*1000;
EVTHREAD_ALLOC_LOCK(cond.lock, EVTHREAD_LOCKTYPE_RECURSIVE);
EVTHREAD_ALLOC_COND(cond.cond);
tt_assert(cond.lock);
tt_assert(cond.cond);
for (i = 0; i < NUM_THREADS; ++i) {
memset(&alerted[i], 0, sizeof(struct alerted_record));
alerted[i].cond = &cond;
}
/* Threads 5 and 6 will be allowed to time out */
memcpy(&alerted[5].delay, &tv_timeout, sizeof(tv_timeout));
memcpy(&alerted[6].delay, &tv_timeout, sizeof(tv_timeout));
evtimer_assign(&wake_one, base, wake_one_timeout, &cond);
evtimer_assign(&wake_all, base, wake_all_timeout, &cond);
evutil_gettimeofday(&launched_at, NULL);
/* Launch the threads... */
for (i = 0; i < NUM_THREADS; ++i) {
THREAD_START(threads[i], wait_for_condition, &alerted[i]);
}
/* Start the timers... */
tt_int_op(event_add(&wake_one, &tv_signal), ==, 0);
tt_int_op(event_add(&wake_all, &tv_broadcast), ==, 0);
/* And run for a bit... */
event_base_dispatch(base);
/* And wait till the threads are done. */
for (i = 0; i < NUM_THREADS; ++i)
THREAD_JOIN(threads[i]);
/* Now, let's see what happened. At least one of 5 or 6 should
* have timed out. */
n_timed_out = alerted[5].timed_out + alerted[6].timed_out;
tt_int_op(n_timed_out, >=, 1);
tt_int_op(n_timed_out, <=, 2);
for (i = 0; i < NUM_THREADS; ++i) {
const struct timeval *target_delay;
struct timeval target_time, actual_delay;
if (alerted[i].timed_out) {
TT_BLATHER(("%d looks like a timeout\n", i));
target_delay = &tv_timeout;
tt_assert(i == 5 || i == 6);
} else if (evutil_timerisset(&alerted[i].alerted_at)) {
long diff1,diff2;
evutil_timersub(&alerted[i].alerted_at,
&launched_at, &actual_delay);
diff1 = timeval_msec_diff(&actual_delay,
&tv_signal);
diff2 = timeval_msec_diff(&actual_delay,
&tv_broadcast);
if (abs(diff1) < abs(diff2)) {
TT_BLATHER(("%d looks like a signal\n", i));
target_delay = &tv_signal;
++n_signal;
} else {
TT_BLATHER(("%d looks like a broadcast\n", i));
target_delay = &tv_broadcast;
++n_broadcast;
}
} else {
TT_FAIL(("Thread %d never got woken", i));
continue;
}
evutil_timeradd(target_delay, &launched_at, &target_time);
test_timeval_diff_leq(&target_time, &alerted[i].alerted_at,
0, 150);
}
tt_int_op(n_broadcast + n_signal + n_timed_out, ==, NUM_THREADS);
tt_int_op(n_signal, ==, 1);
end:
;
}
#endif
#define CB_COUNT 128
#define QUEUE_THREAD_COUNT 8
#ifdef WIN32
#define SLEEP_MS(ms) Sleep(ms)
#else
#define SLEEP_MS(ms) usleep((ms) * 1000)
#endif
struct deferred_test_data {
struct deferred_cb cbs[CB_COUNT];
struct deferred_cb_queue *queue;
};
static time_t timer_start = 0;
static time_t timer_end = 0;
static unsigned callback_count = 0;
static THREAD_T load_threads[QUEUE_THREAD_COUNT];
static struct deferred_test_data deferred_data[QUEUE_THREAD_COUNT];
static void
deferred_callback(struct deferred_cb *cb, void *arg)
{
SLEEP_MS(1);
callback_count += 1;
}
static THREAD_FN
load_deferred_queue(void *arg)
{
struct deferred_test_data *data = arg;
size_t i;
for (i = 0; i < CB_COUNT; ++i) {
event_deferred_cb_init(&data->cbs[i], deferred_callback, NULL);
event_deferred_cb_schedule(data->queue, &data->cbs[i]);
SLEEP_MS(1);
}
THREAD_RETURN();
}
static void
timer_callback(evutil_socket_t fd, short what, void *arg)
{
timer_end = time(NULL);
}
static void
start_threads_callback(evutil_socket_t fd, short what, void *arg)
{
int i;
for (i = 0; i < QUEUE_THREAD_COUNT; ++i) {
THREAD_START(load_threads[i], load_deferred_queue,
&deferred_data[i]);
}
}
static void
thread_deferred_cb_skew(void *arg)
{
struct basic_test_data *data = arg;
struct timeval tv_timer = {4, 0};
struct deferred_cb_queue *queue;
time_t elapsed;
int i;
queue = event_base_get_deferred_cb_queue(data->base);
tt_assert(queue);
for (i = 0; i < QUEUE_THREAD_COUNT; ++i)
deferred_data[i].queue = queue;
timer_start = time(NULL);
event_base_once(data->base, -1, EV_TIMEOUT, timer_callback, NULL,
&tv_timer);
event_base_once(data->base, -1, EV_TIMEOUT, start_threads_callback,
NULL, NULL);
event_base_dispatch(data->base);
elapsed = timer_end - timer_start;
TT_BLATHER(("callback count, %u", callback_count));
TT_BLATHER(("elapsed time, %u", (unsigned)elapsed));
/* XXX be more intelligent here. just make sure skew is
* within 2 seconds for now. */
tt_assert(elapsed >= 4 && elapsed <= 6);
end:
for (i = 0; i < QUEUE_THREAD_COUNT; ++i)
THREAD_JOIN(load_threads[i]);
}
#define TEST(name) \
{ #name, thread_##name, TT_FORK|TT_NEED_THREADS|TT_NEED_BASE, \
&basic_setup, NULL }
struct testcase_t thread_testcases[] = {
{ "basic", thread_basic, TT_FORK|TT_NEED_THREADS|TT_NEED_BASE,
&basic_setup, NULL },
#ifndef WIN32
{ "forking", thread_basic, TT_FORK|TT_NEED_THREADS|TT_NEED_BASE,
&basic_setup, __UNCONST("forking") },
#endif
#if 0
TEST(conditions_simple),
#endif
TEST(deferred_cb_skew),
END_OF_TESTCASES
};