2 * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * 3. The name of the author may not be used to endorse or promote products
13 * derived from this software without specific prior written permission.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 /* The old tests here need assertions to work. */
30 #include "event2/event-config.h"
32 #include <sys/types.h>
36 #ifdef _EVENT_HAVE_UNISTD_H
39 #ifdef _EVENT_HAVE_SYS_WAIT_H
43 #ifdef _EVENT_HAVE_PTHREADS
49 #ifdef _EVENT_HAVE_UNISTD_H
54 #include "sys/queue.h"
56 #include "event2/util.h"
57 #include "event2/event.h"
58 #include "event2/event_struct.h"
59 #include "event2/thread.h"
60 #include "evthread-internal.h"
61 #include "event-internal.h"
62 #include "defer-internal.h"
64 #include "tinytest_macros.h"
66 #ifdef _EVENT_HAVE_PTHREADS
67 #define THREAD_T pthread_t
68 #define THREAD_FN void *
69 #define THREAD_RETURN() return (NULL)
70 #define THREAD_START(threadvar, fn, arg) \
71 pthread_create(&(threadvar), NULL, fn, arg)
72 #define THREAD_JOIN(th) pthread_join(th, NULL)
74 #define THREAD_T HANDLE
75 #define THREAD_FN unsigned __stdcall
76 #define THREAD_RETURN() return (0)
77 #define THREAD_START(threadvar, fn, arg) do { \
78 uintptr_t threadhandle = _beginthreadex(NULL,0,fn,(arg),0,NULL); \
79 (threadvar) = (HANDLE) threadhandle; \
81 #define THREAD_JOIN(th) WaitForSingleObject(th, INFINITE)
90 wake_all_timeout(evutil_socket_t fd
, short what
, void *arg
)
92 struct cond_wait
*cw
= arg
;
93 EVLOCK_LOCK(cw
->lock
, 0);
94 EVTHREAD_COND_BROADCAST(cw
->cond
);
95 EVLOCK_UNLOCK(cw
->lock
, 0);
100 wake_one_timeout(evutil_socket_t fd
, short what
, void *arg
)
102 struct cond_wait
*cw
= arg
;
103 EVLOCK_LOCK(cw
->lock
, 0);
104 EVTHREAD_COND_SIGNAL(cw
->cond
);
105 EVLOCK_UNLOCK(cw
->lock
, 0);
108 #define NUM_THREADS 100
109 #define NUM_ITERATIONS 100
114 basic_thread(void *arg
)
117 struct event_base
*base
= arg
;
121 EVTHREAD_ALLOC_LOCK(cw
.lock
, 0);
122 EVTHREAD_ALLOC_COND(cw
.cond
);
126 evtimer_assign(&ev
, base
, wake_all_timeout
, &cw
);
127 for (i
= 0; i
< NUM_ITERATIONS
; i
++) {
129 evutil_timerclear(&tv
);
133 EVLOCK_LOCK(cw
.lock
, 0);
134 /* we need to make sure that event does not happen before
135 * we get to wait on the conditional variable */
136 assert(evtimer_add(&ev
, &tv
) == 0);
138 assert(EVTHREAD_COND_WAIT(cw
.cond
, cw
.lock
) == 0);
139 EVLOCK_UNLOCK(cw
.lock
, 0);
141 EVLOCK_LOCK(count_lock
, 0);
143 EVLOCK_UNLOCK(count_lock
, 0);
146 /* exit the loop only if all threads fired all timeouts */
147 EVLOCK_LOCK(count_lock
, 0);
148 if (count
>= NUM_THREADS
* NUM_ITERATIONS
)
149 event_base_loopexit(base
, NULL
);
150 EVLOCK_UNLOCK(count_lock
, 0);
152 EVTHREAD_FREE_LOCK(cw
.lock
, 0);
153 EVTHREAD_FREE_COND(cw
.cond
);
158 static int notification_fd_used
= 0;
160 static int got_sigchld
= 0;
162 sigchld_cb(evutil_socket_t fd
, short event
, void *arg
)
165 struct event_base
*base
= arg
;
170 event_base_loopexit(base
, &tv
);
175 notify_fd_cb(evutil_socket_t fd
, short event
, void *arg
)
177 ++notification_fd_used
;
182 thread_basic(void *arg
)
184 THREAD_T threads
[NUM_THREADS
];
188 struct basic_test_data
*data
= arg
;
189 struct event_base
*base
= data
->base
;
191 struct event
*notification_event
= NULL
;
192 struct event
*sigchld_event
= NULL
;
194 EVTHREAD_ALLOC_LOCK(count_lock
, 0);
195 tt_assert(count_lock
);
198 if (evthread_make_base_notifiable(base
)<0) {
199 tt_abort_msg("Couldn't make base notifiable!");
203 if (data
->setup_data
&& !strcmp(data
->setup_data
, "forking")) {
206 sigchld_event
= evsignal_new(base
, SIGCHLD
, sigchld_cb
, base
);
207 /* This piggybacks on the th_notify_fd weirdly, and looks
208 * inside libevent internals. Not a good idea in non-testing
210 notification_event
= event_new(base
,
211 base
->th_notify_fd
[0], EV_READ
|EV_PERSIST
, notify_fd_cb
,
213 event_add(sigchld_event
, NULL
);
214 event_add(notification_event
, NULL
);
216 if ((pid
= fork()) == 0) {
217 event_del(notification_event
);
218 if (event_reinit(base
) < 0) {
222 event_assign(notification_event
, base
,
223 base
->th_notify_fd
[0], EV_READ
|EV_PERSIST
,
225 event_add(notification_event
, NULL
);
229 event_base_dispatch(base
);
231 if (waitpid(pid
, &status
, 0) == -1)
232 tt_abort_perror("waitpid");
233 TT_BLATHER(("Waitpid okay\n"));
235 tt_assert(got_sigchld
);
236 tt_int_op(notification_fd_used
, ==, 0);
243 for (i
= 0; i
< NUM_THREADS
; ++i
)
244 THREAD_START(threads
[i
], basic_thread
, base
);
246 evtimer_assign(&ev
, base
, NULL
, NULL
);
247 evutil_timerclear(&tv
);
251 event_base_dispatch(base
);
253 for (i
= 0; i
< NUM_THREADS
; ++i
)
254 THREAD_JOIN(threads
[i
]);
258 tt_int_op(count
, ==, NUM_THREADS
* NUM_ITERATIONS
);
260 EVTHREAD_FREE_LOCK(count_lock
, 0);
262 TT_BLATHER(("notifiations==%d", notification_fd_used
));
266 if (notification_event
)
267 event_free(notification_event
);
269 event_free(sigchld_event
);
273 #define NUM_THREADS 10
275 struct alerted_record
{
276 struct cond_wait
*cond
;
277 struct timeval delay
;
278 struct timeval alerted_at
;
283 wait_for_condition(void *arg
)
285 struct alerted_record
*rec
= arg
;
288 EVLOCK_LOCK(rec
->cond
->lock
, 0);
289 if (rec
->delay
.tv_sec
|| rec
->delay
.tv_usec
) {
290 r
= EVTHREAD_COND_WAIT_TIMED(rec
->cond
->cond
, rec
->cond
->lock
,
293 r
= EVTHREAD_COND_WAIT(rec
->cond
->cond
, rec
->cond
->lock
);
295 EVLOCK_UNLOCK(rec
->cond
->lock
, 0);
297 evutil_gettimeofday(&rec
->alerted_at
, NULL
);
305 thread_conditions_simple(void *arg
)
307 struct timeval tv_signal
, tv_timeout
, tv_broadcast
;
308 struct alerted_record alerted
[NUM_THREADS
];
309 THREAD_T threads
[NUM_THREADS
];
310 struct cond_wait cond
;
312 struct timeval launched_at
;
313 struct event wake_one
;
314 struct event wake_all
;
315 struct basic_test_data
*data
= arg
;
316 struct event_base
*base
= data
->base
;
317 int n_timed_out
=0, n_signal
=0, n_broadcast
=0;
319 tv_signal
.tv_sec
= tv_timeout
.tv_sec
= tv_broadcast
.tv_sec
= 0;
320 tv_signal
.tv_usec
= 30*1000;
321 tv_timeout
.tv_usec
= 150*1000;
322 tv_broadcast
.tv_usec
= 500*1000;
324 EVTHREAD_ALLOC_LOCK(cond
.lock
, EVTHREAD_LOCKTYPE_RECURSIVE
);
325 EVTHREAD_ALLOC_COND(cond
.cond
);
326 tt_assert(cond
.lock
);
327 tt_assert(cond
.cond
);
328 for (i
= 0; i
< NUM_THREADS
; ++i
) {
329 memset(&alerted
[i
], 0, sizeof(struct alerted_record
));
330 alerted
[i
].cond
= &cond
;
333 /* Threads 5 and 6 will be allowed to time out */
334 memcpy(&alerted
[5].delay
, &tv_timeout
, sizeof(tv_timeout
));
335 memcpy(&alerted
[6].delay
, &tv_timeout
, sizeof(tv_timeout
));
337 evtimer_assign(&wake_one
, base
, wake_one_timeout
, &cond
);
338 evtimer_assign(&wake_all
, base
, wake_all_timeout
, &cond
);
340 evutil_gettimeofday(&launched_at
, NULL
);
342 /* Launch the threads... */
343 for (i
= 0; i
< NUM_THREADS
; ++i
) {
344 THREAD_START(threads
[i
], wait_for_condition
, &alerted
[i
]);
347 /* Start the timers... */
348 tt_int_op(event_add(&wake_one
, &tv_signal
), ==, 0);
349 tt_int_op(event_add(&wake_all
, &tv_broadcast
), ==, 0);
351 /* And run for a bit... */
352 event_base_dispatch(base
);
354 /* And wait till the threads are done. */
355 for (i
= 0; i
< NUM_THREADS
; ++i
)
356 THREAD_JOIN(threads
[i
]);
358 /* Now, let's see what happened. At least one of 5 or 6 should
360 n_timed_out
= alerted
[5].timed_out
+ alerted
[6].timed_out
;
361 tt_int_op(n_timed_out
, >=, 1);
362 tt_int_op(n_timed_out
, <=, 2);
364 for (i
= 0; i
< NUM_THREADS
; ++i
) {
365 const struct timeval
*target_delay
;
366 struct timeval target_time
, actual_delay
;
367 if (alerted
[i
].timed_out
) {
368 TT_BLATHER(("%d looks like a timeout\n", i
));
369 target_delay
= &tv_timeout
;
370 tt_assert(i
== 5 || i
== 6);
371 } else if (evutil_timerisset(&alerted
[i
].alerted_at
)) {
373 evutil_timersub(&alerted
[i
].alerted_at
,
374 &launched_at
, &actual_delay
);
375 diff1
= timeval_msec_diff(&actual_delay
,
377 diff2
= timeval_msec_diff(&actual_delay
,
379 if (abs(diff1
) < abs(diff2
)) {
380 TT_BLATHER(("%d looks like a signal\n", i
));
381 target_delay
= &tv_signal
;
384 TT_BLATHER(("%d looks like a broadcast\n", i
));
385 target_delay
= &tv_broadcast
;
389 TT_FAIL(("Thread %d never got woken", i
));
392 evutil_timeradd(target_delay
, &launched_at
, &target_time
);
393 test_timeval_diff_leq(&target_time
, &alerted
[i
].alerted_at
,
396 tt_int_op(n_broadcast
+ n_signal
+ n_timed_out
, ==, NUM_THREADS
);
397 tt_int_op(n_signal
, ==, 1);
404 #define QUEUE_THREAD_COUNT 8
407 #define SLEEP_MS(ms) Sleep(ms)
409 #define SLEEP_MS(ms) usleep((ms) * 1000)
412 struct deferred_test_data
{
413 struct deferred_cb cbs
[CB_COUNT
];
414 struct deferred_cb_queue
*queue
;
417 static time_t timer_start
= 0;
418 static time_t timer_end
= 0;
419 static unsigned callback_count
= 0;
420 static THREAD_T load_threads
[QUEUE_THREAD_COUNT
];
421 static struct deferred_test_data deferred_data
[QUEUE_THREAD_COUNT
];
424 deferred_callback(struct deferred_cb
*cb
, void *arg
)
431 load_deferred_queue(void *arg
)
433 struct deferred_test_data
*data
= arg
;
436 for (i
= 0; i
< CB_COUNT
; ++i
) {
437 event_deferred_cb_init(&data
->cbs
[i
], deferred_callback
, NULL
);
438 event_deferred_cb_schedule(data
->queue
, &data
->cbs
[i
]);
446 timer_callback(evutil_socket_t fd
, short what
, void *arg
)
448 timer_end
= time(NULL
);
452 start_threads_callback(evutil_socket_t fd
, short what
, void *arg
)
456 for (i
= 0; i
< QUEUE_THREAD_COUNT
; ++i
) {
457 THREAD_START(load_threads
[i
], load_deferred_queue
,
463 thread_deferred_cb_skew(void *arg
)
465 struct basic_test_data
*data
= arg
;
466 struct timeval tv_timer
= {4, 0};
467 struct deferred_cb_queue
*queue
;
471 queue
= event_base_get_deferred_cb_queue(data
->base
);
474 for (i
= 0; i
< QUEUE_THREAD_COUNT
; ++i
)
475 deferred_data
[i
].queue
= queue
;
477 timer_start
= time(NULL
);
478 event_base_once(data
->base
, -1, EV_TIMEOUT
, timer_callback
, NULL
,
480 event_base_once(data
->base
, -1, EV_TIMEOUT
, start_threads_callback
,
482 event_base_dispatch(data
->base
);
484 elapsed
= timer_end
- timer_start
;
485 TT_BLATHER(("callback count, %u", callback_count
));
486 TT_BLATHER(("elapsed time, %u", (unsigned)elapsed
));
487 /* XXX be more intelligent here. just make sure skew is
488 * within 2 seconds for now. */
489 tt_assert(elapsed
>= 4 && elapsed
<= 6);
492 for (i
= 0; i
< QUEUE_THREAD_COUNT
; ++i
)
493 THREAD_JOIN(load_threads
[i
]);
497 { #name, thread_##name, TT_FORK|TT_NEED_THREADS|TT_NEED_BASE, \
500 struct testcase_t thread_testcases
[] = {
501 { "basic", thread_basic
, TT_FORK
|TT_NEED_THREADS
|TT_NEED_BASE
,
502 &basic_setup
, NULL
},
504 { "forking", thread_basic
, TT_FORK
|TT_NEED_THREADS
|TT_NEED_BASE
,
505 &basic_setup
, (char*)"forking" },
507 TEST(conditions_simple
),
508 TEST(deferred_cb_skew
),