I have attached a very simple ev_async example where I start one event
loop, and another loop in a thread. Both loops contain an async watcher.
When this watcher receives an event, a timer is kicked off. When the timer
fires, an async event is sent the other way. Hence I would expect these two
to bounce off each other indefinitely.
However when I run the program the slave thread's call to ev_async_send
doesn't seem to register. The callback to master_cb_async is never invoked.
$ bin/async
main - starting loop
slave_loop - starting loop2
master_cb_timeout - sending async_send to loop2
slave_cb_async - received async_send starting timer for loop2
slave_cb_timeout - sending async_send to loop
Why doesn't this ev_async_send register? What am I doing wrong? If If this
is a clear case of RTFM just point me in the right direction. If not, I'd
appreciate some help.
#include <ev.h>
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#define FUNC __FUNCTION__
double timeout = 2.0;
ev_timer timeout_master, timeout_slave;
ev_async async_to_slave, async_to_master;
struct ev_loop *loop;
struct ev_loop *loop2;
// gcc -Wall threads_async.c -o bin/threads_async -lev -lpthread
static void slave_cb_timeout(EV_P_ ev_timer *w, int revents) {
if (ev_async_pending(&async_to_master) == 0) {
printf(" %s - sending async_send to loop\n", FUNC);
ev_async_send(loop, &async_to_master);
} else {
printf(" %s - master ev_async is pending\n", FUNC);
}
}
static void slave_cb_async(EV_P_ ev_async *w, int revents) {
printf(" %s - received async_send starting timer for loop2\n", FUNC);
ev_timer_init(&timeout_slave, slave_cb_timeout, timeout, 0.);
ev_timer_start(loop2, &timeout_slave);
}
static void master_cb_timeout(EV_P_ ev_timer *w, int revents) {
if (ev_async_pending(&async_to_slave)==0) {
printf("%s - sending async_send to loop2\n", FUNC);
ev_async_send(loop2, &async_to_slave);
} else {
printf("%s - slave ev_async is pending\n", FUNC);
}
}
static void master_cb_async(EV_P_ ev_async *w, int revents) {
printf("%s - received async_send starting timer for loop\n", FUNC);
ev_timer_init(&timeout_master, master_cb_timeout, timeout, 0.);
ev_timer_start(loop, &timeout_master);
}
void *slave_loop(void *args) {
printf(" %s - starting loop2\n", FUNC);
ev_async_init(&async_to_slave, slave_cb_async);
ev_async_start(loop2, &async_to_slave);
ev_loop(loop2, 0);
return NULL;
}
int main(int argc, char** argv) {
pthread_t thread;
loop = ev_loop_new(0);
loop2 = ev_loop_new(0);
pthread_create(&thread, NULL, slave_loop, NULL);
printf("%s - starting loop\n", FUNC);
ev_timer_init(&timeout_master, master_cb_timeout, 0.5, 0.);
ev_timer_start(loop, &timeout_master);
ev_async_init(&async_to_master, master_cb_async);
ev_async_start(loop, &async_to_master);
ev_loop(loop, 0);
pthread_join(thread, NULL);
return 0;
}
_______________________________________________
libev mailing list
[email protected]
http://lists.schmorp.de/cgi-bin/mailman/listinfo/libev
