int ofp_timer_cancel(odp_timer_t tim)
{
odp_event_t timeout_event = ODP_EVENT_INVALID;
odp_timeout_t tmo;
uint32_t t = (uint32_t)tim;
struct ofp_timer_internal *bufdata;
struct ofp_timer_internal *prev = NULL;
if (tim == ODP_TIMER_INVALID)
return 0;
if (t & 0x80000000) {
/* long timeout */
odp_spinlock_lock(&shm->lock);
bufdata = shm->long_table[t & TIMER_LONG_MASK];
while (bufdata) {
struct ofp_timer_internal *next = bufdata->next;
if (bufdata->id == t) {
if (prev == NULL)
shm->long_table[t & TIMER_LONG_MASK] = next;
else
prev->next = next;
odp_buffer_free(bufdata->buf);
odp_spinlock_unlock(&shm->lock);
return 0;
}
prev = bufdata;
bufdata = next;
}
odp_spinlock_unlock(&shm->lock);
return -1;
}
else {
if (odp_timer_cancel(tim, &timeout_event) < 0)
{
OFP_WARN("Timeout already expired or inactive");
return 0;
}
if (timeout_event != ODP_EVENT_INVALID) {
tmo = odp_timeout_from_event(timeout_event);
bufdata = odp_timeout_user_ptr(tmo);
odp_buffer_free(bufdata->buf);
odp_timeout_free(tmo);
} else {
OFP_WARN("Lost timeout buffer at timer cancel");
return -1;
}
if (odp_timer_free(tim) != ODP_EVENT_INVALID) {
OFP_ERR("odp_timer_free failed");
return -1;
}
}
return 0;
}
/* @private Handle a received (timeout) event */
static void handle_tmo(odp_event_t ev, bool stale, uint64_t prev_tick)
{
CU_ASSERT_FATAL(ev != ODP_EVENT_INVALID); /* Internal error */
if (odp_event_type(ev) != ODP_EVENT_TIMEOUT) {
/* Not a timeout event */
CU_FAIL("Unexpected event type received");
return;
}
/* Read the metadata from the timeout */
odp_timeout_t tmo = odp_timeout_from_event(ev);
odp_timer_t tim = odp_timeout_timer(tmo);
uint64_t tick = odp_timeout_tick(tmo);
struct test_timer *ttp = odp_timeout_user_ptr(tmo);
if (tim == ODP_TIMER_INVALID)
CU_FAIL("odp_timeout_timer() invalid timer");
if (!ttp)
CU_FAIL("odp_timeout_user_ptr() null user ptr");
if (ttp && ttp->ev2 != ev)
CU_FAIL("odp_timeout_user_ptr() wrong user ptr");
if (ttp && ttp->tim != tim)
CU_FAIL("odp_timeout_timer() wrong timer");
if (stale) {
if (odp_timeout_fresh(tmo))
CU_FAIL("Wrong status (fresh) for stale timeout");
/* Stale timeout => local timer must have invalid tick */
if (ttp && ttp->tick != TICK_INVALID)
CU_FAIL("Stale timeout for active timer");
} else {
if (!odp_timeout_fresh(tmo))
CU_FAIL("Wrong status (stale) for fresh timeout");
/* Fresh timeout => local timer must have matching tick */
if (ttp && ttp->tick != tick) {
LOG_DBG("Wrong tick: expected %" PRIu64
" actual %" PRIu64 "\n",
ttp->tick, tick);
CU_FAIL("odp_timeout_tick() wrong tick");
}
/* Check that timeout was delivered 'timely' */
if (tick > odp_timer_current_tick(tp))
CU_FAIL("Timeout delivered early");
if (tick < prev_tick) {
LOG_DBG("Too late tick: %" PRIu64
" prev_tick %" PRIu64"\n",
tick, prev_tick);
/* We don't report late timeouts using CU_FAIL */
odp_atomic_inc_u32(&ndelivtoolate);
}
}
if (ttp) {
/* Internal error */
CU_ASSERT_FATAL(ttp->ev == ODP_EVENT_INVALID);
ttp->ev = ev;
}
}
/*
* During shutdown process, all OFP submodules cancel their timers. However, it
* is possible that the timer is cancelled (thus preventing further expiration),
* but a timeout event for a previous expiration of this timer is sitting in a
* queue waiting to be scheduled. schedule_shutdown() calls this function to
* cleanup these events.
*/
void ofp_timer_evt_cleanup(odp_event_t ev)
{
odp_timeout_t tmo;
odp_timer_t tim;
struct ofp_timer_internal *bufdata;
tmo = odp_timeout_from_event(ev);
tim = odp_timeout_timer(tmo);
bufdata = (struct ofp_timer_internal *) odp_timeout_user_ptr(tmo);
odp_buffer_free(bufdata->buf);
odp_timeout_free(tmo);
odp_timer_free(tim);
}
void ofp_timer_handle(odp_event_t ev)
{
struct ofp_timer_internal *bufdata;
odp_timeout_t tmo = odp_timeout_from_event(ev);
odp_timer_t tim = odp_timeout_timer(tmo);
bufdata = (struct ofp_timer_internal *)odp_timeout_user_ptr(tmo);
fflush(NULL);
bufdata->callback(&bufdata->arg);
odp_buffer_free(bufdata->buf);
odp_timeout_free(tmo);
odp_timer_free(tim);
}
/** @private test timeout */
static void test_abs_timeouts(int thr, test_globals_t *gbls)
{
uint64_t period;
uint64_t period_ns;
odp_queue_t queue;
uint64_t tick;
struct test_timer *ttp;
odp_timeout_t tmo;
EXAMPLE_DBG(" [%i] test_timeouts\n", thr);
queue = odp_queue_lookup("timer_queue");
period_ns = gbls->args.period_us*ODP_TIME_USEC;
period = odp_timer_ns_to_tick(gbls->tp, period_ns);
EXAMPLE_DBG(" [%i] period %"PRIu64" ticks, %"PRIu64" ns\n", thr,
period, period_ns);
EXAMPLE_DBG(" [%i] current tick %"PRIu64"\n", thr,
odp_timer_current_tick(gbls->tp));
ttp = &gbls->tt[thr];
ttp->tim = odp_timer_alloc(gbls->tp, queue, ttp);
if (ttp->tim == ODP_TIMER_INVALID) {
EXAMPLE_ERR("Failed to allocate timer\n");
return;
}
tmo = odp_timeout_alloc(gbls->pool);
if (tmo == ODP_TIMEOUT_INVALID) {
EXAMPLE_ERR("Failed to allocate timeout\n");
return;
}
ttp->ev = odp_timeout_to_event(tmo);
tick = odp_timer_current_tick(gbls->tp);
while ((int)odp_atomic_load_u32(&gbls->remain) > 0) {
odp_event_t ev;
odp_timer_set_t rc;
tick += period;
rc = odp_timer_set_abs(ttp->tim, tick, &ttp->ev);
if (odp_unlikely(rc != ODP_TIMER_SUCCESS)) {
/* Too early or too late timeout requested */
EXAMPLE_ABORT("odp_timer_set_abs() failed: %s\n",
timerset2str(rc));
}
/* Get the next expired timeout.
* We invoke the scheduler in a loop with a timeout because
* we are not guaranteed to receive any more timeouts. The
* scheduler isn't guaranteeing fairness when scheduling
* buffers to threads.
* Use 1.5 second timeout for scheduler */
uint64_t sched_tmo =
odp_schedule_wait_time(1500000000ULL);
do {
ev = odp_schedule(&queue, sched_tmo);
/* Check if odp_schedule() timed out, possibly there
* are no remaining timeouts to receive */
} while (ev == ODP_EVENT_INVALID &&
(int)odp_atomic_load_u32(&gbls->remain) > 0);
if (ev == ODP_EVENT_INVALID)
break; /* No more timeouts */
if (odp_event_type(ev) != ODP_EVENT_TIMEOUT) {
/* Not a default timeout event */
EXAMPLE_ABORT("Unexpected event type (%u) received\n",
odp_event_type(ev));
}
odp_timeout_t tmo = odp_timeout_from_event(ev);
tick = odp_timeout_tick(tmo);
ttp = odp_timeout_user_ptr(tmo);
ttp->ev = ev;
if (!odp_timeout_fresh(tmo)) {
/* Not the expected expiration tick, timer has
* been reset or cancelled or freed */
EXAMPLE_ABORT("Unexpected timeout received (timer %" PRIx32 ", tick %" PRIu64 ")\n",
ttp->tim, tick);
}
EXAMPLE_DBG(" [%i] timeout, tick %"PRIu64"\n", thr, tick);
odp_atomic_dec_u32(&gbls->remain);
}
/* Cancel and free last timer used */
(void)odp_timer_cancel(ttp->tim, &ttp->ev);
if (ttp->ev != ODP_EVENT_INVALID)
odp_timeout_free(odp_timeout_from_event(ttp->ev));
else
EXAMPLE_ERR("Lost timeout event at timer cancel\n");
/* Since we have cancelled the timer, there is no timeout event to
* return from odp_timer_free() */
(void)odp_timer_free(ttp->tim);
/* Remove any prescheduled events */
remove_prescheduled_events();
}
void timer_test_odp_timer_cancel(void)
{
odp_pool_t pool;
odp_pool_param_t params;
odp_timer_pool_param_t tparam;
odp_timer_pool_t tp;
odp_queue_t queue;
odp_timer_t tim;
odp_event_t ev;
odp_timeout_t tmo;
odp_timer_set_t rc;
uint64_t tick;
odp_pool_param_init(¶ms);
params.type = ODP_POOL_TIMEOUT;
params.tmo.num = 1;
pool = odp_pool_create("tmo_pool_for_cancel", ¶ms);
if (pool == ODP_POOL_INVALID)
CU_FAIL_FATAL("Timeout pool create failed");
tparam.res_ns = 100 * ODP_TIME_MSEC_IN_NS;
tparam.min_tmo = 1 * ODP_TIME_SEC_IN_NS;
tparam.max_tmo = 10 * ODP_TIME_SEC_IN_NS;
tparam.num_timers = 1;
tparam.priv = 0;
tparam.clk_src = ODP_CLOCK_CPU;
tp = odp_timer_pool_create("timer_pool0", &tparam);
if (tp == ODP_TIMER_POOL_INVALID)
CU_FAIL_FATAL("Timer pool create failed");
/* Start all created timer pools */
odp_timer_pool_start();
queue = odp_queue_create("timer_queue", NULL);
if (queue == ODP_QUEUE_INVALID)
CU_FAIL_FATAL("Queue create failed");
#define USER_PTR ((void *)0xdead)
tim = odp_timer_alloc(tp, queue, USER_PTR);
if (tim == ODP_TIMER_INVALID)
CU_FAIL_FATAL("Failed to allocate timer");
LOG_DBG("Timer handle: %" PRIu64 "\n", odp_timer_to_u64(tim));
ev = odp_timeout_to_event(odp_timeout_alloc(pool));
if (ev == ODP_EVENT_INVALID)
CU_FAIL_FATAL("Failed to allocate timeout");
tick = odp_timer_ns_to_tick(tp, 2 * ODP_TIME_SEC_IN_NS);
rc = odp_timer_set_rel(tim, tick, &ev);
if (rc != ODP_TIMER_SUCCESS)
CU_FAIL_FATAL("Failed to set timer (relative time)");
ev = ODP_EVENT_INVALID;
if (odp_timer_cancel(tim, &ev) != 0)
CU_FAIL_FATAL("Failed to cancel timer (relative time)");
if (ev == ODP_EVENT_INVALID)
CU_FAIL_FATAL("Cancel did not return event");
tmo = odp_timeout_from_event(ev);
if (tmo == ODP_TIMEOUT_INVALID)
CU_FAIL_FATAL("Cancel did not return timeout");
LOG_DBG("Timeout handle: %" PRIu64 "\n", odp_timeout_to_u64(tmo));
if (odp_timeout_timer(tmo) != tim)
CU_FAIL("Cancel invalid tmo.timer");
if (odp_timeout_user_ptr(tmo) != USER_PTR)
CU_FAIL("Cancel invalid tmo.user_ptr");
odp_timeout_free(tmo);
ev = odp_timer_free(tim);
if (ev != ODP_EVENT_INVALID)
CU_FAIL_FATAL("Free returned event");
odp_timer_pool_destroy(tp);
if (odp_queue_destroy(queue) != 0)
CU_FAIL_FATAL("Failed to destroy queue");
if (odp_pool_destroy(pool) != 0)
CU_FAIL_FATAL("Failed to destroy pool");
}
/** @private test timeout */
static void test_abs_timeouts(int thr, test_globals_t *gbls)
{
uint64_t period;
uint64_t period_ns;
odp_queue_t queue;
uint64_t tick;
struct test_timer *ttp;
odp_timeout_t tmo;
uint32_t num_workers = gbls->num_workers;
EXAMPLE_DBG(" [%i] test_timeouts\n", thr);
queue = odp_queue_lookup("timer_queue");
period_ns = gbls->args.period_us * ODP_TIME_USEC;
period = odp_timer_ns_to_tick(gbls->tp, period_ns);
EXAMPLE_DBG(" [%i] period %d ticks, %d ns\n", thr,
period, period_ns);
EXAMPLE_DBG(" [%i] current tick %d\n", thr,
odp_timer_current_tick(gbls->tp));
ttp = &gbls->tt[thr];
ttp->tim = odp_timer_alloc(gbls->tp, queue, ttp);
if (ttp->tim == ODP_TIMER_INVALID) {
EXAMPLE_ERR("Failed to allocate timer\n");
return;
}
tmo = odp_timeout_alloc(gbls->pool);
if (tmo == ODP_TIMEOUT_INVALID) {
EXAMPLE_ERR("Failed to allocate timeout\n");
return;
}
ttp->ev = odp_timeout_to_event(tmo);
tick = odp_timer_current_tick(gbls->tp);
while (1) {
int wait = 0;
odp_event_t ev;
odp_timer_set_t rc;
if (ttp) {
tick += period;
rc = odp_timer_set_abs(ttp->tim, tick, &ttp->ev);
if (odp_unlikely(rc != ODP_TIMER_SUCCESS))
/* Too early or too late timeout requested */
EXAMPLE_ABORT("odp_timer_set_abs() failed: %s\n",
timerset2str(rc));
}
/* Get the next expired timeout.
* We invoke the scheduler in a loop with a timeout because
* we are not guaranteed to receive any more timeouts. The
* scheduler isn't guaranteeing fairness when scheduling
* buffers to threads.
* Use 1.5 second timeout for scheduler */
uint64_t sched_tmo =
odp_schedule_wait_time(1500000000ULL);
do {
ev = odp_schedule(&queue, sched_tmo);
/* Check if odp_schedule() timed out, possibly there
* are no remaining timeouts to receive */
if ((++wait > WAIT_NUM)
&& (odp_atomic_load_u32(&gbls->remain) < num_workers))
EXAMPLE_ABORT("At least one TMO was lost\n");
} while (ev == ODP_EVENT_INVALID
&& (int)odp_atomic_load_u32(&gbls->remain) > 0);
if (ev == ODP_EVENT_INVALID)
break; /* No more timeouts */
if (odp_event_type(ev) != ODP_EVENT_TIMEOUT)
/* Not a default timeout event */
EXAMPLE_ABORT("Unexpected event type (%u) received\n",
odp_event_type(ev));
odp_timeout_t tmo = odp_timeout_from_event(ev);
tick = odp_timeout_tick(tmo);
ttp = odp_timeout_user_ptr(tmo);
ttp->ev = ev;
if (!odp_timeout_fresh(tmo))
/* Not the expected expiration tick, timer has
* been reset or cancelled or freed */
EXAMPLE_ABORT("Unexpected timeout received (timer %x, tick %d)\n",
ttp->tim, tick);
EXAMPLE_DBG(" [%i] timeout, tick %d\n", thr, tick);
uint32_t rx_num = odp_atomic_fetch_dec_u32(&gbls->remain);
if (!rx_num)
EXAMPLE_ABORT("Unexpected timeout received (timer %x, tick %d)\n",
ttp->tim, tick);
else if (rx_num > num_workers)
continue;
odp_timeout_free(odp_timeout_from_event(ttp->ev));
odp_timer_free(ttp->tim);
ttp = NULL;
}
/* Remove any prescheduled events */
remove_prescheduled_events();
}
