static t_info *
new_task(isc_mem_t *mctx, const char *name) {
t_info *ti;
isc_time_t expires;
isc_interval_t interval;
RUNTIME_CHECK(task_count < MAX_TASKS);
ti = &tasks[task_count];
ti->mctx = mctx;
ti->task = NULL;
ti->timer = NULL;
ti->ticks = 0;
if (name != NULL) {
INSIST(strlen(name) < sizeof(ti->name));
strcpy(ti->name, name);
} else
sprintf(ti->name, "%d", task_count);
RUNTIME_CHECK(isc_task_create(task_manager, 0, &ti->task) ==
ISC_R_SUCCESS);
RUNTIME_CHECK(isc_task_onshutdown(ti->task, shutdown_action, ti) ==
ISC_R_SUCCESS);
isc_time_settoepoch(&expires);
isc_interval_set(&interval, 1, 0);
RUNTIME_CHECK(isc_timer_create(timer_manager, isc_timertype_ticker,
&expires, &interval, ti->task,
tick, ti, &ti->timer) ==
ISC_R_SUCCESS);
task_count++;
return (ti);
}
int
main(int argc, char *argv[]) {
isc_interval_t linterval;
int i;
UNUSED(argc);
UNUSED(argv);
isc__mem_register();
isc__task_register();
isc__timer_register();
isc__socket_register();
isc_app_start();
isc_interval_set(&linterval, 1, 0);
RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
RUNTIME_CHECK(isc_taskmgr_create(mctx, 3, 0, &taskmgr) ==
ISC_R_SUCCESS);
RUNTIME_CHECK(isc_timermgr_create(mctx, &timermgr) ==
ISC_R_SUCCESS);
RUNTIME_CHECK(isc_task_create(taskmgr, 0, &g_task) ==
ISC_R_SUCCESS);
RUNTIME_CHECK(isc_ratelimiter_create(mctx, timermgr, g_task,
&rlim) == ISC_R_SUCCESS);
RUNTIME_CHECK(isc_ratelimiter_setinterval(rlim, &linterval) ==
ISC_R_SUCCESS);
for (i = 0; i < NEVENTS; i++) {
isc_interval_t uinterval;
int ms = schedule[i].milliseconds;
isc_interval_set(&uinterval, ms / 1000,
(ms % 1000) * 1000000);
timers[i] = NULL;
RUNTIME_CHECK(isc_timer_create(timermgr,
isc_timertype_once, NULL,
&uinterval,
g_task, schedule[i].fun, NULL,
&timers[i]) == ISC_R_SUCCESS);
}
isc_app_run();
isc_task_destroy(&g_task);
isc_ratelimiter_detach(&rlim);
isc_timermgr_destroy(&timermgr);
isc_taskmgr_destroy(&taskmgr);
isc_mem_stats(mctx, stdout);
isc_app_finish();
return (0);
}
isc_result_t
isc_ratelimiter_create(isc_mem_t *mctx, isc_timermgr_t *timermgr,
isc_task_t *task, isc_ratelimiter_t **ratelimiterp)
{
isc_result_t result;
isc_ratelimiter_t *rl;
INSIST(ratelimiterp != NULL && *ratelimiterp == NULL);
rl = isc_mem_get(mctx, sizeof(*rl));
if (rl == NULL)
return ISC_R_NOMEMORY;
rl->mctx = mctx;
rl->refs = 1;
rl->task = task;
isc_interval_set(&rl->interval, 0, 0);
rl->timer = NULL;
rl->pertic = 1;
rl->state = isc_ratelimiter_idle;
ISC_LIST_INIT(rl->pending);
result = isc_mutex_init(&rl->lock);
if (result != ISC_R_SUCCESS)
goto free_mem;
result = isc_timer_create(timermgr, isc_timertype_inactive,
NULL, NULL, rl->task, ratelimiter_tick,
rl, &rl->timer);
if (result != ISC_R_SUCCESS)
goto free_mutex;
/*
* Increment the reference count to indicate that we may
* (soon) have events outstanding.
*/
rl->refs++;
ISC_EVENT_INIT(&rl->shutdownevent,
sizeof(isc_event_t),
0, NULL, ISC_RATELIMITEREVENT_SHUTDOWN,
ratelimiter_shutdowncomplete, rl, rl, NULL, NULL);
*ratelimiterp = rl;
return (ISC_R_SUCCESS);
free_mutex:
DESTROYLOCK(&rl->lock);
free_mem:
isc_mem_put(mctx, rl, sizeof(*rl));
return (result);
}
static isc_result_t
newconnection(controllistener_t *listener, isc_socket_t *sock) {
controlconnection_t *conn;
isc_interval_t interval;
isc_result_t result;
conn = isc_mem_get(listener->mctx, sizeof(*conn));
if (conn == NULL)
return (ISC_R_NOMEMORY);
conn->sock = sock;
isccc_ccmsg_init(listener->mctx, sock, &conn->ccmsg);
conn->ccmsg_valid = ISC_TRUE;
conn->sending = ISC_FALSE;
conn->buffer = NULL;
conn->timer = NULL;
isc_interval_set(&interval, 60, 0);
result = isc_timer_create(ns_g_timermgr, isc_timertype_once,
NULL, &interval, listener->task,
control_timeout, conn, &conn->timer);
if (result != ISC_R_SUCCESS)
goto cleanup;
conn->listener = listener;
conn->nonce = 0;
ISC_LINK_INIT(conn, link);
result = isccc_ccmsg_readmessage(&conn->ccmsg, listener->task,
control_recvmessage, conn);
if (result != ISC_R_SUCCESS)
goto cleanup;
ISC_LIST_APPEND(listener->connections, conn, link);
return (ISC_R_SUCCESS);
cleanup:
if (conn->buffer != NULL)
isc_buffer_free(&conn->buffer);
isccc_ccmsg_invalidate(&conn->ccmsg);
if (conn->timer != NULL)
isc_timer_detach(&conn->timer);
isc_mem_put(listener->mctx, conn, sizeof(*conn));
return (result);
}
static int
t_timers5(void) {
char *p;
int result;
isc_mem_t *mctx;
isc_taskmgr_t *tmgr;
unsigned int workers;
isc_result_t isc_result;
isc_timermgr_t *timermgr;
isc_event_t *event;
isc_time_t expires;
isc_interval_t interval;
T5_startflag = 0;
T5_shutdownflag = 0;
T5_eventcnt = 0;
workers = 2;
p = t_getenv("ISC_TASK_WORKERS");
if (p != NULL)
workers = atoi(p);
mctx = NULL;
isc_result = isc_mem_create(0, 0, &mctx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mem_create failed %s\n",
isc_result_totext(isc_result));
return(T_UNRESOLVED);
}
isc_result = isc_mutex_init(&T5_mx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mutex_init failed %s\n",
isc_result_totext(isc_result));
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
isc_result = isc_condition_init(&T5_cv);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_condition_init failed %s\n",
isc_result_totext(isc_result));
DESTROYLOCK(&T5_mx);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
tmgr = NULL;
isc_result = isc_taskmgr_create(mctx, workers, 0, &tmgr);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_taskmgr_create failed %s\n",
isc_result_totext(isc_result));
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
timermgr = NULL;
isc_result = isc_timermgr_create(mctx, &timermgr);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_timermgr_create failed %s\n",
isc_result_totext(isc_result));
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
T5_task1 = NULL;
isc_result = isc_task_create(tmgr, 0, &T5_task1);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_task_create failed %s\n",
isc_result_totext(isc_result));
isc_timermgr_destroy(&timermgr);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
isc_result = isc_task_onshutdown(T5_task1, t5_shutdown_event, NULL);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_task_onshutdown failed %s\n",
isc_result_totext(isc_result));
isc_timermgr_destroy(&timermgr);
isc_task_destroy(&T5_task1);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
T5_task2 = NULL;
isc_result = isc_task_create(tmgr, 0, &T5_task2);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_task_create failed %s\n",
isc_result_totext(isc_result));
isc_timermgr_destroy(&timermgr);
isc_task_destroy(&T5_task1);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
isc_result = isc_mutex_lock(&T5_mx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mutex_lock failed %s\n",
isc_result_totext(isc_result));
isc_timermgr_destroy(&timermgr);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
event = isc_event_allocate(mctx, (void *)1 , (isc_eventtype_t)1,
t5_start_event, NULL, sizeof(*event));
isc_task_send(T5_task1, &event);
isc_time_settoepoch(&expires);
isc_interval_set(&interval, T5_SECONDS, 0);
T5_tickertimer = NULL;
isc_result = isc_timer_create(timermgr, isc_timertype_ticker,
&expires, &interval, T5_task1,
t5_tick_event, NULL, &T5_tickertimer);
if (isc_result != ISC_R_SUCCESS) {
isc_timermgr_destroy(&timermgr);
(void) isc_condition_signal(&T5_cv);
(void) isc_mutex_unlock(&T5_mx);
isc_task_destroy(&T5_task1);
isc_task_destroy(&T5_task2);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
T5_oncetimer = NULL;
isc_interval_set(&interval, (T5_SECONDS * T5_NTICKS) + 2, 0);
isc_result = isc_time_nowplusinterval(&expires, &interval);
if (isc_result != ISC_R_SUCCESS) {
isc_timer_detach(&T5_tickertimer);
isc_timermgr_destroy(&timermgr);
(void)isc_condition_signal(&T5_cv);
(void)isc_mutex_unlock(&T5_mx);
isc_task_destroy(&T5_task1);
isc_task_destroy(&T5_task2);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
return(T_UNRESOLVED);
}
isc_interval_set(&interval, 0, 0);
isc_result = isc_timer_create(timermgr, isc_timertype_once,
&expires, &interval, T5_task2,
t5_once_event, NULL, &T5_oncetimer);
if (isc_result != ISC_R_SUCCESS) {
isc_timer_detach(&T5_tickertimer);
isc_timermgr_destroy(&timermgr);
(void) isc_condition_signal(&T5_cv);
(void) isc_mutex_unlock(&T5_mx);
isc_task_destroy(&T5_task1);
isc_task_destroy(&T5_task2);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
++T5_nprobs;
return(T_UNRESOLVED);
}
/*
* Wait for shutdown processing to complete.
*/
while (! T5_shutdownflag) {
isc_result = isc_condition_wait(&T5_cv, &T5_mx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_condition_waituntil failed %s\n",
isc_result_totext(isc_result));
++T5_nprobs;
}
}
isc_result = isc_mutex_unlock(&T5_mx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mutex_unlock failed %s\n",
isc_result_totext(isc_result));
++T5_nprobs;
}
if (T5_eventcnt != 1) {
t_info("processed %d events\n", T5_eventcnt);
++T5_nfails;
}
isc_timer_detach(&T5_tickertimer);
isc_timer_detach(&T5_oncetimer);
isc_timermgr_destroy(&timermgr);
isc_task_destroy(&T5_task1);
isc_task_destroy(&T5_task2);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&T5_mx);
(void) isc_condition_destroy(&T5_cv);
isc_mem_destroy(&mctx);
result = T_UNRESOLVED;
if ((T5_nfails == 0) && (T5_nprobs == 0))
result = T_PASS;
else if (T5_nfails)
result = T_FAIL;
return (result);
}
static void
t_timers_x(isc_timertype_t timertype, isc_time_t *expires,
isc_interval_t *interval,
void (*action)(isc_task_t *, isc_event_t *))
{
char *p;
isc_mem_t *mctx;
isc_taskmgr_t *tmgr;
isc_task_t *task;
unsigned int workers;
isc_result_t isc_result;
isc_timermgr_t *timermgr;
Tx_eventcnt = 0;
isc_time_settoepoch(&Tx_endtime);
workers = 2;
p = t_getenv("ISC_TASK_WORKERS");
if (p != NULL)
workers = atoi(p);
mctx = NULL;
isc_result = isc_mem_create(0, 0, &mctx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mem_create failed %s\n",
isc_result_totext(isc_result));
++Tx_nprobs;
return;
}
isc_result = isc_mutex_init(&Tx_mx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mutex_init failed %s\n",
isc_result_totext(isc_result));
isc_mem_destroy(&mctx);
++Tx_nprobs;
return;
}
isc_result = isc_condition_init(&Tx_cv);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_condition_init failed %s\n",
isc_result_totext(isc_result));
DESTROYLOCK(&Tx_mx);
isc_mem_destroy(&mctx);
++Tx_nprobs;
return;
}
tmgr = NULL;
isc_result = isc_taskmgr_create(mctx, workers, 0, &tmgr);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_taskmgr_create failed %s\n",
isc_result_totext(isc_result));
DESTROYLOCK(&Tx_mx);
(void) isc_condition_destroy(&Tx_cv);
isc_mem_destroy(&mctx);
++Tx_nprobs;
return;
}
timermgr = NULL;
isc_result = isc_timermgr_create(mctx, &timermgr);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_timermgr_create failed %s\n",
isc_result_totext(isc_result));
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&Tx_mx);
(void) isc_condition_destroy(&Tx_cv);
isc_mem_destroy(&mctx);
++Tx_nprobs;
return;
}
isc_result = isc_mutex_lock(&Tx_mx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mutex_lock failed %s\n",
isc_result_totext(isc_result));
isc_timermgr_destroy(&timermgr);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&Tx_mx);
(void) isc_condition_destroy(&Tx_cv);
isc_mem_destroy(&mctx);
++Tx_nprobs;
return;
}
task = NULL;
isc_result = isc_task_create(tmgr, 0, &task);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_task_create failed %s\n",
isc_result_totext(isc_result));
isc_timermgr_destroy(&timermgr);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&Tx_mx);
(void) isc_condition_destroy(&Tx_cv);
isc_mem_destroy(&mctx);
++Tx_nprobs;
return;
}
isc_result = isc_task_onshutdown(task, tx_sde, NULL);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_task_onshutdown failed %s\n",
isc_result_totext(isc_result));
isc_timermgr_destroy(&timermgr);
isc_task_destroy(&task);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&Tx_mx);
(void) isc_condition_destroy(&Tx_cv);
isc_mem_destroy(&mctx);
++Tx_nprobs;
return;
}
isc_result = isc_time_now(&Tx_lasttime);
if (isc_result != ISC_R_SUCCESS) {
isc_timermgr_destroy(&timermgr);
isc_task_destroy(&task);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&Tx_mx);
(void) isc_condition_destroy(&Tx_cv);
isc_mem_destroy(&mctx);
++Tx_nprobs;
return;
}
Tx_timer = NULL;
isc_result = isc_timer_create(timermgr, timertype, expires, interval,
task, action, (void *)timertype,
&Tx_timer);
if (isc_result != ISC_R_SUCCESS) {
isc_timermgr_destroy(&timermgr);
isc_task_destroy(&task);
isc_taskmgr_destroy(&tmgr);
DESTROYLOCK(&Tx_mx);
(void) isc_condition_destroy(&Tx_cv);
isc_mem_destroy(&mctx);
++Tx_nprobs;
return;
}
/*
* Wait for shutdown processing to complete.
*/
while (Tx_eventcnt != Tx_nevents) {
isc_result = isc_condition_wait(&Tx_cv, &Tx_mx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_condition_waituntil failed %s\n",
isc_result_totext(isc_result));
++Tx_nprobs;
}
}
isc_result = isc_mutex_unlock(&Tx_mx);
if (isc_result != ISC_R_SUCCESS) {
t_info("isc_mutex_unlock failed %s\n",
isc_result_totext(isc_result));
++Tx_nprobs;
}
isc_task_detach(&task);
isc_taskmgr_destroy(&tmgr);
isc_timermgr_destroy(&timermgr);
DESTROYLOCK(&Tx_mx);
(void) isc_condition_destroy(&Tx_cv);
isc_mem_destroy(&mctx);
}
int
main(int argc, char *argv[]) {
isc_task_t *t1, *t2;
isc_timermgr_t *timgr;
isc_time_t expires;
isc_interval_t interval;
isc_timer_t *ti1;
unsigned int workers;
isc_socketmgr_t *socketmgr;
isc_socket_t *so1, *so2;
isc_sockaddr_t sockaddr;
struct in_addr ina;
struct in6_addr in6a;
isc_result_t result;
int pf;
if (argc > 1)
workers = atoi(argv[1]);
else
workers = 2;
printf("%d workers\n", workers);
if (isc_net_probeipv6() == ISC_R_SUCCESS)
pf = PF_INET6;
else
pf = PF_INET;
/*
* EVERYTHING needs a memory context.
*/
mctx = NULL;
RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
/*
* The task manager is independent (other than memory context)
*/
manager = NULL;
RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, 0, &manager) ==
ISC_R_SUCCESS);
/*
* Timer manager depends only on the memory context as well.
*/
timgr = NULL;
RUNTIME_CHECK(isc_timermgr_create(mctx, &timgr) == ISC_R_SUCCESS);
t1 = NULL;
RUNTIME_CHECK(isc_task_create(manager, 0, &t1) == ISC_R_SUCCESS);
t2 = NULL;
RUNTIME_CHECK(isc_task_create(manager, 0, &t2) == ISC_R_SUCCESS);
RUNTIME_CHECK(isc_task_onshutdown(t1, my_shutdown, "1") ==
ISC_R_SUCCESS);
RUNTIME_CHECK(isc_task_onshutdown(t2, my_shutdown, "2") ==
ISC_R_SUCCESS);
printf("task 1 = %p\n", t1);
printf("task 2 = %p\n", t2);
socketmgr = NULL;
RUNTIME_CHECK(isc_socketmgr_create(mctx, &socketmgr) == ISC_R_SUCCESS);
/*
* Open up a listener socket.
*/
so1 = NULL;
if (pf == PF_INET6) {
in6a = in6addr_any;
isc_sockaddr_fromin6(&sockaddr, &in6a, 5544);
} else {
ina.s_addr = INADDR_ANY;
isc_sockaddr_fromin(&sockaddr, &ina, 5544);
}
RUNTIME_CHECK(isc_socket_create(socketmgr, pf, isc_sockettype_tcp,
&so1) == ISC_R_SUCCESS);
result = isc_socket_bind(so1, &sockaddr, ISC_SOCKET_REUSEADDRESS);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
RUNTIME_CHECK(isc_socket_listen(so1, 0) == ISC_R_SUCCESS);
/*
* Queue up the first accept event.
*/
RUNTIME_CHECK(isc_socket_accept(so1, t1, my_listen, "so1")
== ISC_R_SUCCESS);
isc_time_settoepoch(&expires);
isc_interval_set(&interval, 10, 0);
ti1 = NULL;
RUNTIME_CHECK(isc_timer_create(timgr, isc_timertype_once, &expires,
&interval, t1, timeout, so1, &ti1) ==
ISC_R_SUCCESS);
/*
* Open up a socket that will connect to www.flame.org, port 80.
* Why not. :)
*/
so2 = NULL;
ina.s_addr = inet_addr("204.152.184.97");
if (0 && pf == PF_INET6)
isc_sockaddr_v6fromin(&sockaddr, &ina, 80);
else
isc_sockaddr_fromin(&sockaddr, &ina, 80);
RUNTIME_CHECK(isc_socket_create(socketmgr, isc_sockaddr_pf(&sockaddr),
isc_sockettype_tcp,
&so2) == ISC_R_SUCCESS);
RUNTIME_CHECK(isc_socket_connect(so2, &sockaddr, t2,
my_connect, "so2") == ISC_R_SUCCESS);
/*
* Detaching these is safe, since the socket will attach to the
* task for any outstanding requests.
*/
isc_task_detach(&t1);
isc_task_detach(&t2);
/*
* Wait a short while.
*/
sleep(10);
fprintf(stderr, "Destroying socket manager\n");
isc_socketmgr_destroy(&socketmgr);
fprintf(stderr, "Destroying timer manager\n");
isc_timermgr_destroy(&timgr);
fprintf(stderr, "Destroying task manager\n");
isc_taskmgr_destroy(&manager);
isc_mem_stats(mctx, stdout);
isc_mem_destroy(&mctx);
return (0);
}
int main (int argc, char *argv[])
{
isc_taskmgr_t *manager = NULL;
isc_timermgr_t *timgr = NULL;
unsigned int workers;
isc_time_t expires, now;
isc_interval_t interval;
if (argc > 1)
workers = atoi (argv[1]);
else
workers = 2;
printf ("%d workers\n", workers);
RUNTIME_CHECK (isc_mem_create (0, 0, &mctx1) == ISC_R_SUCCESS);
RUNTIME_CHECK (isc_taskmgr_create (mctx1, workers, 0, &manager) == ISC_R_SUCCESS);
RUNTIME_CHECK (isc_timermgr_create (mctx1, &timgr) == ISC_R_SUCCESS);
RUNTIME_CHECK (isc_task_create (manager, 0, &t1) == ISC_R_SUCCESS);
RUNTIME_CHECK (isc_task_create (manager, 0, &t2) == ISC_R_SUCCESS);
RUNTIME_CHECK (isc_task_create (manager, 0, &t3) == ISC_R_SUCCESS);
RUNTIME_CHECK (isc_task_onshutdown (t1, shutdown_task, "1") == ISC_R_SUCCESS);
RUNTIME_CHECK (isc_task_onshutdown (t2, shutdown_task, "2") == ISC_R_SUCCESS);
RUNTIME_CHECK (isc_task_onshutdown (t3, shutdown_task, "3") == ISC_R_SUCCESS);
printf ("task 1: %p\n", t1);
printf ("task 2: %p\n", t2);
printf ("task 3: %p\n", t3);
TIME_NOW (&now);
isc_interval_set (&interval, 2, 0);
RUNTIME_CHECK (isc_timer_create (timgr, isc_timertype_once, NULL,
&interval, t2, timeout, "2", &ti2) == ISC_R_SUCCESS);
isc_interval_set (&interval, 1, 0);
RUNTIME_CHECK (isc_timer_create (timgr, isc_timertype_ticker, NULL,
&interval, t1, tick, "1", &ti1) == ISC_R_SUCCESS);
isc_interval_set (&interval, 10, 0);
RUNTIME_CHECK (isc_time_add (&now, &interval, &expires) == ISC_R_SUCCESS);
isc_interval_set (&interval, 2, 0);
RUNTIME_CHECK (isc_timer_create (timgr, isc_timertype_once, &expires,
&interval, t3, timeout, "3", &ti3) == ISC_R_SUCCESS);
isc_task_detach (&t1);
isc_task_detach (&t2);
isc_task_detach (&t3);
sleep (15);
printf ("destroy\n");
isc_timer_detach (&ti1);
isc_timer_detach (&ti2);
isc_timer_detach (&ti3);
sleep (2);
isc_timermgr_destroy (&timgr);
isc_taskmgr_destroy (&manager);
printf ("destroyed\n");
printf ("Statistics for mctx1:\n");
isc_mem_stats (mctx1, stdout);
isc_mem_destroy (&mctx1);
return (0);
}
int
main(int argc, char *argv[]) {
isc_taskmgr_t *manager = NULL;
isc_task_t *t1 = NULL, *t2 = NULL;
isc_task_t *t3 = NULL, *t4 = NULL;
isc_event_t *event;
unsigned int workers;
isc_timermgr_t *timgr;
isc_timer_t *ti1, *ti2;
struct isc_interval interval;
if (argc > 1) {
workers = atoi(argv[1]);
if (workers < 1)
workers = 1;
if (workers > 8192)
workers = 8192;
} else
workers = 2;
printf("%d workers\n", workers);
RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, 0, &manager) ==
ISC_R_SUCCESS);
RUNTIME_CHECK(isc_task_create(manager, 0, &t1) == ISC_R_SUCCESS);
RUNTIME_CHECK(isc_task_create(manager, 0, &t2) == ISC_R_SUCCESS);
RUNTIME_CHECK(isc_task_create(manager, 0, &t3) == ISC_R_SUCCESS);
RUNTIME_CHECK(isc_task_create(manager, 0, &t4) == ISC_R_SUCCESS);
RUNTIME_CHECK(isc_task_onshutdown(t1, my_shutdown, "1") ==
ISC_R_SUCCESS);
RUNTIME_CHECK(isc_task_onshutdown(t2, my_shutdown, "2") ==
ISC_R_SUCCESS);
RUNTIME_CHECK(isc_task_onshutdown(t3, my_shutdown, "3") ==
ISC_R_SUCCESS);
RUNTIME_CHECK(isc_task_onshutdown(t4, my_shutdown, "4") ==
ISC_R_SUCCESS);
timgr = NULL;
RUNTIME_CHECK(isc_timermgr_create(mctx, &timgr) == ISC_R_SUCCESS);
ti1 = NULL;
isc_interval_set(&interval, 1, 0);
RUNTIME_CHECK(isc_timer_create(timgr, isc_timertype_ticker, NULL,
&interval, t1, my_tick, "foo", &ti1) ==
ISC_R_SUCCESS);
ti2 = NULL;
isc_interval_set(&interval, 1, 0);
RUNTIME_CHECK(isc_timer_create(timgr, isc_timertype_ticker, NULL,
&interval, t2, my_tick, "bar", &ti2) ==
ISC_R_SUCCESS);
printf("task 1 = %p\n", t1);
printf("task 2 = %p\n", t2);
sleep(2);
/*
* Note: (void *)1 is used as a sender here, since some compilers
* don't like casting a function pointer to a (void *).
*
* In a real use, it is more likely the sender would be a
* structure (socket, timer, task, etc) but this is just a test
* program.
*/
event = isc_event_allocate(mctx, (void *)1, 1, my_callback, "1",
sizeof(*event));
isc_task_send(t1, &event);
event = isc_event_allocate(mctx, (void *)1, 1, my_callback, "1",
sizeof(*event));
isc_task_send(t1, &event);
event = isc_event_allocate(mctx, (void *)1, 1, my_callback, "1",
sizeof(*event));
isc_task_send(t1, &event);
event = isc_event_allocate(mctx, (void *)1, 1, my_callback, "1",
sizeof(*event));
isc_task_send(t1, &event);
event = isc_event_allocate(mctx, (void *)1, 1, my_callback, "1",
sizeof(*event));
isc_task_send(t1, &event);
event = isc_event_allocate(mctx, (void *)1, 1, my_callback, "1",
sizeof(*event));
isc_task_send(t1, &event);
event = isc_event_allocate(mctx, (void *)1, 1, my_callback, "1",
sizeof(*event));
isc_task_send(t1, &event);
event = isc_event_allocate(mctx, (void *)1, 1, my_callback, "1",
sizeof(*event));
isc_task_send(t1, &event);
event = isc_event_allocate(mctx, (void *)1, 1, my_callback, "1",
sizeof(*event));
isc_task_send(t1, &event);
event = isc_event_allocate(mctx, (void *)1, 1, my_callback, "2",
sizeof(*event));
isc_task_send(t2, &event);
event = isc_event_allocate(mctx, (void *)1, 1, my_callback, "3",
sizeof(*event));
isc_task_send(t3, &event);
event = isc_event_allocate(mctx, (void *)1, 1, my_callback, "4",
sizeof(*event));
isc_task_send(t4, &event);
event = isc_event_allocate(mctx, (void *)1, 1, my_callback, "2",
sizeof(*event));
isc_task_send(t2, &event);
event = isc_event_allocate(mctx, (void *)1, 1, my_callback, "3",
sizeof(*event));
isc_task_send(t3, &event);
event = isc_event_allocate(mctx, (void *)1, 1, my_callback, "4",
sizeof(*event));
isc_task_send(t4, &event);
isc_task_purgerange(t3,
NULL,
ISC_EVENTTYPE_FIRSTEVENT,
ISC_EVENTTYPE_LASTEVENT, NULL);
isc_task_detach(&t1);
isc_task_detach(&t2);
isc_task_detach(&t3);
isc_task_detach(&t4);
sleep(10);
printf("destroy\n");
isc_timer_detach(&ti1);
isc_timer_detach(&ti2);
isc_timermgr_destroy(&timgr);
isc_taskmgr_destroy(&manager);
printf("destroyed\n");
isc_mem_stats(mctx, stdout);
isc_mem_destroy(&mctx);
return (0);
}