static int empty_inq(odp_pktio_t pktio)
{
odp_queue_t queue;
odp_event_t ev;
odp_queue_type_t q_type;
if (odp_pktin_event_queue(pktio, &queue, 1) != 1)
return -1;
q_type = odp_queue_type(queue);
/* flush any pending events */
while (1) {
if (q_type == ODP_QUEUE_TYPE_PLAIN)
ev = odp_queue_deq(queue);
else
ev = odp_schedule(NULL, ODP_SCHED_NO_WAIT);
if (ev != ODP_EVENT_INVALID)
odp_event_free(ev);
else
break;
}
return 0;
}
static int destroy_inq(odp_pktio_t pktio)
{
odp_queue_t inq;
odp_event_t ev;
odp_queue_type_t q_type;
inq = odp_pktio_inq_getdef(pktio);
if (inq == ODP_QUEUE_INVALID) {
CU_FAIL("attempting to destroy invalid inq");
return -1;
}
CU_ASSERT(odp_pktio_inq_remdef(pktio) == 0);
q_type = odp_queue_type(inq);
/* flush any pending events */
while (1) {
if (q_type == ODP_QUEUE_TYPE_POLL)
ev = odp_queue_deq(inq);
else
ev = odp_schedule(NULL, ODP_SCHED_NO_WAIT);
if (ev != ODP_EVENT_INVALID)
odp_event_free(ev);
else
break;
}
return odp_queue_destroy(inq);
}
void pktio_test_inq_remdef(void)
{
odp_pktio_t pktio;
odp_queue_t inq;
odp_event_t ev;
uint64_t wait;
int i;
pktio = create_pktio(0, ODP_PKTIN_MODE_SCHED,
ODP_PKTOUT_MODE_SEND);
CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
CU_ASSERT(create_inq(pktio, ODP_QUEUE_TYPE_POLL) == 0);
inq = odp_pktio_inq_getdef(pktio);
CU_ASSERT(inq != ODP_QUEUE_INVALID);
CU_ASSERT(odp_pktio_inq_remdef(pktio) == 0);
wait = odp_schedule_wait_time(ODP_TIME_MSEC_IN_NS);
for (i = 0; i < 100; i++) {
ev = odp_schedule(NULL, wait);
if (ev != ODP_EVENT_INVALID) {
odp_event_free(ev);
CU_FAIL("received unexpected event");
}
}
CU_ASSERT(odp_queue_destroy(inq) == 0);
CU_ASSERT(odp_pktio_close(pktio) == 0);
}
int destroy_inq(odp_pktio_t pktio)
{
odp_queue_t inq;
odp_event_t ev;
inq = odp_pktio_inq_getdef(pktio);
if (inq == ODP_QUEUE_INVALID) {
CU_FAIL("attempting to destroy invalid inq");
return -1;
}
if (0 > odp_pktio_inq_remdef(pktio))
return -1;
while (1) {
ev = odp_schedule(NULL, ODP_SCHED_NO_WAIT);
if (ev != ODP_EVENT_INVALID)
odp_event_free(ev);
else
break;
}
return odp_queue_destroy(inq);
}
/** @private test timeout */
static void remove_prescheduled_events(void)
{
odp_event_t ev;
odp_queue_t queue;
odp_schedule_pause();
while ((ev = odp_schedule(&queue, ODP_SCHED_NO_WAIT)) !=
ODP_EVENT_INVALID) {
odp_event_free(ev);
}
}
static int drain_queues(void)
{
odp_event_t ev;
uint64_t wait = odp_schedule_wait_time(100 * ODP_TIME_MSEC_IN_NS);
int ret = 0;
while ((ev = odp_schedule(NULL, wait)) != ODP_EVENT_INVALID) {
odp_event_free(ev);
ret++;
}
return ret;
}
static int send_packets(odp_queue_t outq,
odp_event_t *event_tbl, unsigned num_pkts)
{
int ret;
unsigned i;
if (num_pkts == 0)
return 0;
else if (num_pkts == 1) {
if (odp_queue_enq(outq, event_tbl[0])) {
odp_event_free(event_tbl[0]);
return 0;
} else {
return 1;
}
}
ret = odp_queue_enq_multi(outq, event_tbl, num_pkts);
i = ret < 0 ? 0 : ret;
for ( ; i < num_pkts; i++)
odp_event_free(event_tbl[i]);
return ret;
}
static int exit_schedule_loop(void)
{
odp_event_t ev;
int ret = 0;
odp_schedule_pause();
while ((ev = odp_schedule(NULL, ODP_SCHED_NO_WAIT))
!= ODP_EVENT_INVALID) {
odp_event_free(ev);
ret++;
}
return ret;
}
static int run_thread_rx(void *arg)
{
test_globals_t *globals;
int thr_id, batch_len;
odp_queue_t queue = ODP_QUEUE_INVALID;
odp_packet_t pkt;
thread_args_t *targs = arg;
batch_len = targs->batch_len;
if (batch_len > BATCH_LEN_MAX)
batch_len = BATCH_LEN_MAX;
thr_id = odp_thread_id();
globals = odp_shm_addr(odp_shm_lookup("test_globals"));
pkt_rx_stats_t *stats = &globals->rx_stats[thr_id];
if (gbl_args->args.schedule == 0) {
if (odp_pktin_event_queue(globals->pktio_rx, &queue, 1) != 1)
LOG_ABORT("No input queue.\n");
}
odp_barrier_wait(&globals->rx_barrier);
while (1) {
odp_event_t ev[BATCH_LEN_MAX];
int i, n_ev;
n_ev = receive_packets(queue, ev, batch_len);
for (i = 0; i < n_ev; ++i) {
if (odp_event_type(ev[i]) == ODP_EVENT_PACKET) {
pkt = odp_packet_from_event(ev[i]);
if (pktio_pkt_has_magic(pkt))
stats->s.rx_cnt++;
else
stats->s.rx_ignore++;
}
odp_event_free(ev[i]);
}
if (n_ev == 0 && odp_atomic_load_u32(&shutdown))
break;
}
return 0;
}
static odp_packet_t wait_for_packet(pktio_info_t *pktio_rx,
uint32_t seq, uint64_t ns)
{
odp_time_t wait_time, end;
odp_event_t ev;
odp_packet_t pkt;
uint64_t wait;
wait = odp_schedule_wait_time(ns);
wait_time = odp_time_local_from_ns(ns);
end = odp_time_sum(odp_time_local(), wait_time);
do {
pkt = ODP_PACKET_INVALID;
if (pktio_rx->in_mode == ODP_PKTIN_MODE_RECV) {
odp_pktio_recv(pktio_rx->id, &pkt, 1);
} else {
if (pktio_rx->in_mode == ODP_PKTIN_MODE_POLL)
ev = queue_deq_wait_time(pktio_rx->inq, ns);
else
ev = odp_schedule(NULL, wait);
if (ev != ODP_EVENT_INVALID) {
if (odp_event_type(ev) == ODP_EVENT_PACKET)
pkt = odp_packet_from_event(ev);
else
odp_event_free(ev);
}
}
if (pkt != ODP_PACKET_INVALID) {
if (pktio_pkt_seq(pkt) == seq)
return pkt;
odp_packet_free(pkt);
}
} while (odp_time_cmp(end, odp_time_local()) > 0);
CU_FAIL("failed to receive transmitted packet");
return ODP_PACKET_INVALID;
}
/** @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_IN_NS;
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 (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 %d, tick %lld)\n",
ttp->tim, tick);
}
EXAMPLE_DBG(" [%i] timeout, tick %"PRIu64"\n", thr, tick);
uint32_t rx_num = odp_atomic_fetch_dec_u32(&gbls->remain);
if (!rx_num)
EXAMPLE_ABORT("Unexpected timeout received (timer %d, tick %lld)\n",
ttp->tim, tick);
else if (rx_num > num_workers)
continue;
odp_event_free(ttp->ev);
odp_timer_free(ttp->tim);
ttp = NULL;
}
/* Remove any prescheduled events */
remove_prescheduled_events();
}
static int schedule_common_(void *arg)
{
thread_args_t *args = (thread_args_t *)arg;
odp_schedule_sync_t sync;
test_globals_t *globals;
queue_context *qctx;
buf_contents *bctx, *bctx_cpy;
odp_pool_t pool;
int locked;
int num;
odp_event_t ev;
odp_buffer_t buf, buf_cpy;
odp_queue_t from;
globals = args->globals;
sync = args->sync;
pool = odp_pool_lookup(MSG_POOL_NAME);
CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
if (args->num_workers > 1)
odp_barrier_wait(&globals->barrier);
while (1) {
from = ODP_QUEUE_INVALID;
num = 0;
odp_ticketlock_lock(&globals->lock);
if (globals->buf_count == 0) {
odp_ticketlock_unlock(&globals->lock);
break;
}
odp_ticketlock_unlock(&globals->lock);
if (args->enable_schd_multi) {
odp_event_t events[BURST_BUF_SIZE],
ev_cpy[BURST_BUF_SIZE];
odp_buffer_t buf_cpy[BURST_BUF_SIZE];
int j;
num = odp_schedule_multi(&from, ODP_SCHED_NO_WAIT,
events, BURST_BUF_SIZE);
CU_ASSERT(num >= 0);
CU_ASSERT(num <= BURST_BUF_SIZE);
if (num == 0)
continue;
if (sync == ODP_SCHED_SYNC_ORDERED) {
int ndx;
int ndx_max;
int rc;
ndx_max = odp_queue_lock_count(from);
CU_ASSERT_FATAL(ndx_max >= 0);
qctx = odp_queue_context(from);
for (j = 0; j < num; j++) {
bctx = odp_buffer_addr(
odp_buffer_from_event
(events[j]));
buf_cpy[j] = odp_buffer_alloc(pool);
CU_ASSERT_FATAL(buf_cpy[j] !=
ODP_BUFFER_INVALID);
bctx_cpy = odp_buffer_addr(buf_cpy[j]);
memcpy(bctx_cpy, bctx,
sizeof(buf_contents));
bctx_cpy->output_sequence =
bctx_cpy->sequence;
ev_cpy[j] =
odp_buffer_to_event(buf_cpy[j]);
}
rc = odp_queue_enq_multi(qctx->pq_handle,
ev_cpy, num);
CU_ASSERT(rc == num);
bctx = odp_buffer_addr(
odp_buffer_from_event(events[0]));
for (ndx = 0; ndx < ndx_max; ndx++) {
odp_schedule_order_lock(ndx);
CU_ASSERT(bctx->sequence ==
qctx->lock_sequence[ndx]);
qctx->lock_sequence[ndx] += num;
odp_schedule_order_unlock(ndx);
}
}
for (j = 0; j < num; j++)
odp_event_free(events[j]);
} else {
ev = odp_schedule(&from, ODP_SCHED_NO_WAIT);
if (ev == ODP_EVENT_INVALID)
continue;
buf = odp_buffer_from_event(ev);
num = 1;
if (sync == ODP_SCHED_SYNC_ORDERED) {
int ndx;
int ndx_max;
int rc;
ndx_max = odp_queue_lock_count(from);
CU_ASSERT_FATAL(ndx_max >= 0);
qctx = odp_queue_context(from);
bctx = odp_buffer_addr(buf);
buf_cpy = odp_buffer_alloc(pool);
CU_ASSERT_FATAL(buf_cpy != ODP_BUFFER_INVALID);
bctx_cpy = odp_buffer_addr(buf_cpy);
memcpy(bctx_cpy, bctx, sizeof(buf_contents));
bctx_cpy->output_sequence = bctx_cpy->sequence;
rc = odp_queue_enq(qctx->pq_handle,
odp_buffer_to_event
(buf_cpy));
CU_ASSERT(rc == 0);
for (ndx = 0; ndx < ndx_max; ndx++) {
odp_schedule_order_lock(ndx);
CU_ASSERT(bctx->sequence ==
qctx->lock_sequence[ndx]);
qctx->lock_sequence[ndx] += num;
odp_schedule_order_unlock(ndx);
}
}
odp_buffer_free(buf);
}
if (args->enable_excl_atomic) {
locked = odp_spinlock_trylock(&globals->atomic_lock);
CU_ASSERT(locked != 0);
CU_ASSERT(from != ODP_QUEUE_INVALID);
if (locked) {
int cnt;
odp_time_t time = ODP_TIME_NULL;
/* Do some work here to keep the thread busy */
for (cnt = 0; cnt < 1000; cnt++)
time = odp_time_sum(time,
odp_time_local());
odp_spinlock_unlock(&globals->atomic_lock);
}
}
if (sync == ODP_SCHED_SYNC_ATOMIC)
odp_schedule_release_atomic();
if (sync == ODP_SCHED_SYNC_ORDERED)
odp_schedule_release_ordered();
odp_ticketlock_lock(&globals->lock);
globals->buf_count -= num;
if (globals->buf_count < 0) {
odp_ticketlock_unlock(&globals->lock);
CU_FAIL_FATAL("Buffer counting failed");
}
odp_ticketlock_unlock(&globals->lock);
}
if (args->num_workers > 1)
odp_barrier_wait(&globals->barrier);
if (sync == ODP_SCHED_SYNC_ORDERED)
locked = odp_ticketlock_trylock(&globals->lock);
else
locked = 0;
if (locked && globals->buf_count_cpy > 0) {
odp_event_t ev;
odp_queue_t pq;
uint64_t seq;
uint64_t bcount = 0;
int i, j;
char name[32];
uint64_t num_bufs = args->num_bufs;
uint64_t buf_count = globals->buf_count_cpy;
for (i = 0; i < args->num_prio; i++) {
for (j = 0; j < args->num_queues; j++) {
snprintf(name, sizeof(name),
"plain_%d_%d_o", i, j);
pq = odp_queue_lookup(name);
CU_ASSERT_FATAL(pq != ODP_QUEUE_INVALID);
seq = 0;
while (1) {
ev = odp_queue_deq(pq);
if (ev == ODP_EVENT_INVALID) {
CU_ASSERT(seq == num_bufs);
break;
}
bctx = odp_buffer_addr(
odp_buffer_from_event(ev));
CU_ASSERT(bctx->sequence == seq);
seq++;
bcount++;
odp_event_free(ev);
}
}
}
CU_ASSERT(bcount == buf_count);
globals->buf_count_cpy = 0;
}
if (locked)
odp_ticketlock_unlock(&globals->lock);
/* Clear scheduler atomic / ordered context between tests */
num = exit_schedule_loop();
CU_ASSERT(num == 0);
if (num)
printf("\nDROPPED %i events\n\n", num);
return 0;
}
void queue_test_param(void)
{
odp_queue_t queue;
odp_event_t enev[MAX_BUFFER_QUEUE];
odp_event_t deev[MAX_BUFFER_QUEUE];
odp_buffer_t buf;
odp_event_t ev;
odp_pool_t msg_pool;
odp_event_t *pev_tmp;
int i, deq_ret, ret;
int nr_deq_entries = 0;
int max_iteration = CONFIG_MAX_ITERATION;
odp_queue_param_t qparams;
odp_buffer_t enbuf;
/* Schedule type queue */
odp_queue_param_init(&qparams);
qparams.type = ODP_QUEUE_TYPE_SCHED;
qparams.sched.prio = ODP_SCHED_PRIO_LOWEST;
qparams.sched.sync = ODP_SCHED_SYNC_PARALLEL;
qparams.sched.group = ODP_SCHED_GROUP_WORKER;
queue = odp_queue_create("test_queue", &qparams);
CU_ASSERT(ODP_QUEUE_INVALID != queue);
CU_ASSERT(odp_queue_to_u64(queue) !=
odp_queue_to_u64(ODP_QUEUE_INVALID));
CU_ASSERT(queue == odp_queue_lookup("test_queue"));
CU_ASSERT(ODP_QUEUE_TYPE_SCHED == odp_queue_type(queue));
CU_ASSERT(ODP_SCHED_PRIO_LOWEST == odp_queue_sched_prio(queue));
CU_ASSERT(ODP_SCHED_SYNC_PARALLEL == odp_queue_sched_type(queue));
CU_ASSERT(ODP_SCHED_GROUP_WORKER == odp_queue_sched_group(queue));
CU_ASSERT(0 == odp_queue_context_set(queue, &queue_context,
sizeof(queue_context)));
CU_ASSERT(&queue_context == odp_queue_context(queue));
CU_ASSERT(odp_queue_destroy(queue) == 0);
/* Plain type queue */
odp_queue_param_init(&qparams);
qparams.type = ODP_QUEUE_TYPE_PLAIN;
qparams.context = &queue_context;
qparams.context_len = sizeof(queue_context);
queue = odp_queue_create("test_queue", &qparams);
CU_ASSERT(ODP_QUEUE_INVALID != queue);
CU_ASSERT(queue == odp_queue_lookup("test_queue"));
CU_ASSERT(ODP_QUEUE_TYPE_PLAIN == odp_queue_type(queue));
CU_ASSERT(&queue_context == odp_queue_context(queue));
msg_pool = odp_pool_lookup("msg_pool");
buf = odp_buffer_alloc(msg_pool);
CU_ASSERT_FATAL(buf != ODP_BUFFER_INVALID);
ev = odp_buffer_to_event(buf);
if (!(CU_ASSERT(odp_queue_enq(queue, ev) == 0))) {
odp_buffer_free(buf);
} else {
CU_ASSERT(ev == odp_queue_deq(queue));
odp_buffer_free(buf);
}
for (i = 0; i < MAX_BUFFER_QUEUE; i++) {
buf = odp_buffer_alloc(msg_pool);
enev[i] = odp_buffer_to_event(buf);
}
/*
* odp_queue_enq_multi may return 0..n buffers due to the resource
* constraints in the implementation at that given point of time.
* But here we assume that we succeed in enqueuing all buffers.
*/
ret = odp_queue_enq_multi(queue, enev, MAX_BUFFER_QUEUE);
CU_ASSERT(MAX_BUFFER_QUEUE == ret);
i = ret < 0 ? 0 : ret;
for ( ; i < MAX_BUFFER_QUEUE; i++)
odp_event_free(enev[i]);
pev_tmp = deev;
do {
deq_ret = odp_queue_deq_multi(queue, pev_tmp,
MAX_BUFFER_QUEUE);
nr_deq_entries += deq_ret;
max_iteration--;
pev_tmp += deq_ret;
CU_ASSERT(max_iteration >= 0);
} while (nr_deq_entries < MAX_BUFFER_QUEUE);
for (i = 0; i < MAX_BUFFER_QUEUE; i++) {
enbuf = odp_buffer_from_event(enev[i]);
CU_ASSERT(enev[i] == deev[i]);
odp_buffer_free(enbuf);
}
CU_ASSERT(odp_queue_destroy(queue) == 0);
}
int default_event_dispatcher(void *arg)
{
odp_event_t ev;
odp_packet_t pkt;
odp_queue_t in_queue;
int event_idx = 0;
int event_cnt = 0;
ofp_pkt_processing_func pkt_func = (ofp_pkt_processing_func)arg;
odp_bool_t *is_running = NULL;
if (ofp_init_local()) {
OFP_ERR("ofp_init_local failed");
return -1;
}
int rx_burst = global_param->evt_rx_burst_size;
odp_event_t events[rx_burst];
is_running = ofp_get_processing_state();
if (is_running == NULL) {
OFP_ERR("ofp_get_processing_state failed");
ofp_term_local();
return -1;
}
/* PER CORE DISPATCHER */
while (*is_running) {
event_cnt = odp_schedule_multi(&in_queue, ODP_SCHED_WAIT,
events, rx_burst);
for (event_idx = 0; event_idx < event_cnt; event_idx++) {
odp_event_type_t ev_type;
ev = events[event_idx];
if (ev == ODP_EVENT_INVALID)
continue;
ev_type = odp_event_type(ev);
if (odp_likely(ev_type == ODP_EVENT_PACKET)) {
pkt = odp_packet_from_event(ev);
#if 0
if (odp_unlikely(odp_packet_has_error(pkt))) {
OFP_DBG("Dropping packet with error");
odp_packet_free(pkt);
continue;
}
#endif
ofp_packet_input(pkt, in_queue, pkt_func);
continue;
}
if (ev_type == ODP_EVENT_TIMEOUT) {
ofp_timer_handle(ev);
continue;
}
OFP_ERR("Unexpected event type: %u", ev_type);
odp_event_free(ev);
}
ofp_send_pending_pkt();
}
if (ofp_term_local())
OFP_ERR("ofp_term_local failed");
return 0;
}
static void *chaos_thread(void *arg)
{
uint64_t i, wait;
int rc;
chaos_buf *cbuf;
odp_event_t ev;
odp_queue_t from;
thread_args_t *args = (thread_args_t *)arg;
test_globals_t *globals = args->globals;
int me = odp_thread_id();
if (CHAOS_DEBUG)
printf("Chaos thread %d starting...\n", me);
/* Wait for all threads to start */
odp_barrier_wait(&globals->barrier);
/* Run the test */
wait = odp_schedule_wait_time(CHAOS_WAIT_FAIL);
for (i = 0; i < CHAOS_NUM_ROUNDS * CHAOS_NUM_EVENTS; i++) {
ev = odp_schedule(&from, wait);
CU_ASSERT_FATAL(ev != ODP_EVENT_INVALID);
cbuf = odp_buffer_addr(odp_buffer_from_event(ev));
CU_ASSERT_FATAL(cbuf != NULL);
INVALIDATE(cbuf);
if (CHAOS_DEBUG)
printf("Thread %d received event %" PRIu64
" seq %" PRIu64
" from Q %s, sending to Q %s\n",
me, cbuf->evno, cbuf->seqno,
globals->
chaos_q
[CHAOS_PTR_TO_NDX(odp_queue_context(from))].name,
globals->
chaos_q[cbuf->seqno % CHAOS_NUM_QUEUES].name);
rc = odp_queue_enq(
globals->
chaos_q[cbuf->seqno++ % CHAOS_NUM_QUEUES].handle,
ev);
CU_ASSERT(rc == 0);
}
if (CHAOS_DEBUG)
printf("Thread %d completed %d rounds...terminating\n",
odp_thread_id(), CHAOS_NUM_EVENTS);
/* Thread complete--drain locally cached scheduled events */
odp_schedule_pause();
while (odp_atomic_load_u32(&globals->chaos_pending_event_count) > 0) {
ev = odp_schedule(&from, ODP_SCHED_NO_WAIT);
if (ev == ODP_EVENT_INVALID)
break;
odp_atomic_dec_u32(&globals->chaos_pending_event_count);
cbuf = odp_buffer_addr(odp_buffer_from_event(ev));
if (CHAOS_DEBUG)
printf("Thread %d drained event %" PRIu64
" seq %" PRIu64
" from Q %s\n",
odp_thread_id(), cbuf->evno, cbuf->seqno,
globals->
chaos_q
[CHAOS_PTR_TO_NDX(odp_queue_context(from))].
name);
odp_event_free(ev);
}
return NULL;
}
void scheduler_test_chaos(void)
{
odp_pool_t pool;
odp_pool_param_t params;
odp_queue_param_t qp;
odp_buffer_t buf;
chaos_buf *cbuf;
odp_event_t ev;
test_globals_t *globals;
thread_args_t *args;
odp_shm_t shm;
odp_queue_t from;
int i, rc;
uint64_t wait;
odp_schedule_sync_t sync[] = {ODP_SCHED_SYNC_NONE,
ODP_SCHED_SYNC_ATOMIC/* , */
/* ODP_SCHED_SYNC_ORDERED */};
const int num_sync = (sizeof(sync) / sizeof(sync[0]));
const char *const qtypes[] = {"parallel", "atomic", "ordered"};
/* Set up the scheduling environment */
shm = odp_shm_lookup(GLOBALS_SHM_NAME);
CU_ASSERT_FATAL(shm != ODP_SHM_INVALID);
globals = odp_shm_addr(shm);
CU_ASSERT_PTR_NOT_NULL_FATAL(shm);
shm = odp_shm_lookup(SHM_THR_ARGS_NAME);
CU_ASSERT_FATAL(shm != ODP_SHM_INVALID);
args = odp_shm_addr(shm);
CU_ASSERT_PTR_NOT_NULL_FATAL(args);
args->globals = globals;
args->cu_thr.numthrds = globals->num_workers;
odp_queue_param_init(&qp);
odp_pool_param_init(¶ms);
params.buf.size = sizeof(chaos_buf);
params.buf.align = 0;
params.buf.num = CHAOS_NUM_EVENTS;
params.type = ODP_POOL_BUFFER;
pool = odp_pool_create("sched_chaos_pool", ¶ms);
CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
qp.sched.prio = ODP_SCHED_PRIO_DEFAULT;
for (i = 0; i < CHAOS_NUM_QUEUES; i++) {
qp.sched.sync = sync[i % num_sync];
snprintf(globals->chaos_q[i].name,
sizeof(globals->chaos_q[i].name),
"chaos queue %d - %s", i,
qtypes[i % num_sync]);
globals->chaos_q[i].handle =
odp_queue_create(globals->chaos_q[i].name,
ODP_QUEUE_TYPE_SCHED,
&qp);
CU_ASSERT_FATAL(globals->chaos_q[i].handle !=
ODP_QUEUE_INVALID);
rc = odp_queue_context_set(globals->chaos_q[i].handle,
CHAOS_NDX_TO_PTR(i));
CU_ASSERT_FATAL(rc == 0);
}
/* Now populate the queues with the initial seed elements */
odp_atomic_init_u32(&globals->chaos_pending_event_count, 0);
for (i = 0; i < CHAOS_NUM_EVENTS; i++) {
buf = odp_buffer_alloc(pool);
CU_ASSERT_FATAL(buf != ODP_BUFFER_INVALID);
cbuf = odp_buffer_addr(buf);
cbuf->evno = i;
cbuf->seqno = 0;
rc = odp_queue_enq(
globals->chaos_q[i % CHAOS_NUM_QUEUES].handle,
odp_buffer_to_event(buf));
CU_ASSERT_FATAL(rc == 0);
odp_atomic_inc_u32(&globals->chaos_pending_event_count);
}
/* Run the test */
odp_cunit_thread_create(chaos_thread, &args->cu_thr);
odp_cunit_thread_exit(&args->cu_thr);
if (CHAOS_DEBUG)
printf("Thread %d returning from chaos threads..cleaning up\n",
odp_thread_id());
/* Cleanup: Drain queues, free events */
wait = odp_schedule_wait_time(CHAOS_WAIT_FAIL);
while (odp_atomic_fetch_dec_u32(
&globals->chaos_pending_event_count) > 0) {
ev = odp_schedule(&from, wait);
CU_ASSERT_FATAL(ev != ODP_EVENT_INVALID);
cbuf = odp_buffer_addr(odp_buffer_from_event(ev));
if (CHAOS_DEBUG)
printf("Draining event %" PRIu64
" seq %" PRIu64 " from Q %s...\n",
cbuf->evno,
cbuf->seqno,
globals->
chaos_q
[CHAOS_PTR_TO_NDX(odp_queue_context(from))].
name);
odp_event_free(ev);
}
odp_schedule_release_ordered();
for (i = 0; i < CHAOS_NUM_QUEUES; i++) {
if (CHAOS_DEBUG)
printf("Destroying queue %s\n",
globals->chaos_q[i].name);
rc = odp_queue_destroy(globals->chaos_q[i].handle);
CU_ASSERT(rc == 0);
}
rc = odp_pool_destroy(pool);
CU_ASSERT(rc == 0);
}
void pktio_test_start_stop(void)
{
odp_pktio_t pktio[MAX_NUM_IFACES];
odp_packet_t pkt;
odp_event_t tx_ev[100];
odp_event_t ev;
int i, pkts, ret, alloc = 0;
odp_queue_t outq;
uint64_t wait = odp_schedule_wait_time(ODP_TIME_MSEC_IN_NS);
for (i = 0; i < num_ifaces; i++) {
pktio[i] = create_pktio(i, ODP_PKTIN_MODE_SCHED,
ODP_PKTOUT_MODE_SEND);
CU_ASSERT_FATAL(pktio[i] != ODP_PKTIO_INVALID);
create_inq(pktio[i], ODP_QUEUE_TYPE_SCHED);
}
outq = odp_pktio_outq_getdef(pktio[0]);
/* Interfaces are stopped by default,
* Check that stop when stopped generates an error */
ret = odp_pktio_stop(pktio[0]);
CU_ASSERT(ret <= 0);
/* start first */
ret = odp_pktio_start(pktio[0]);
CU_ASSERT(ret == 0);
/* Check that start when started generates an error */
ret = odp_pktio_start(pktio[0]);
CU_ASSERT(ret < 0);
/* Test Rx on a stopped interface. Only works if there are 2 */
if (num_ifaces > 1) {
for (alloc = 0; alloc < 100; alloc++) {
pkt = odp_packet_alloc(default_pkt_pool, packet_len);
if (pkt == ODP_PACKET_INVALID)
break;
pktio_init_packet(pkt);
pktio_pkt_set_macs(pkt, pktio[0], pktio[1]);
if (pktio_fixup_checksums(pkt) != 0) {
odp_packet_free(pkt);
break;
}
tx_ev[alloc] = odp_packet_to_event(pkt);
}
for (pkts = 0; pkts != alloc; ) {
ret = odp_queue_enq_multi(outq, &tx_ev[pkts],
alloc - pkts);
if (ret < 0) {
CU_FAIL("unable to enqueue packet\n");
break;
}
pkts += ret;
}
/* check that packets did not arrive */
for (i = 0, pkts = 0; i < 1000; i++) {
ev = odp_schedule(NULL, wait);
if (ev == ODP_EVENT_INVALID)
continue;
if (odp_event_type(ev) == ODP_EVENT_PACKET) {
pkt = odp_packet_from_event(ev);
if (pktio_pkt_seq(pkt) != TEST_SEQ_INVALID)
pkts++;
}
odp_event_free(ev);
}
if (pkts)
CU_FAIL("pktio stopped, received unexpected events");
/* start both, send and get packets */
/* 0 already started */
ret = odp_pktio_start(pktio[1]);
CU_ASSERT(ret == 0);
/* flush packets with magic number in pipes */
for (i = 0; i < 1000; i++) {
ev = odp_schedule(NULL, wait);
if (ev != ODP_EVENT_INVALID)
odp_event_free(ev);
}
}
/* alloc */
for (alloc = 0; alloc < 100; alloc++) {
pkt = odp_packet_alloc(default_pkt_pool, packet_len);
if (pkt == ODP_PACKET_INVALID)
break;
pktio_init_packet(pkt);
if (num_ifaces > 1) {
pktio_pkt_set_macs(pkt, pktio[0], pktio[1]);
if (pktio_fixup_checksums(pkt) != 0) {
odp_packet_free(pkt);
break;
}
}
tx_ev[alloc] = odp_packet_to_event(pkt);
}
/* send */
for (pkts = 0; pkts != alloc; ) {
ret = odp_queue_enq_multi(outq, &tx_ev[pkts], alloc - pkts);
if (ret < 0) {
CU_FAIL("unable to enqueue packet\n");
break;
}
pkts += ret;
}
/* get */
for (i = 0, pkts = 0; i < 100; i++) {
ev = odp_schedule(NULL, wait);
if (ev != ODP_EVENT_INVALID) {
if (odp_event_type(ev) == ODP_EVENT_PACKET) {
pkt = odp_packet_from_event(ev);
if (pktio_pkt_seq(pkt) != TEST_SEQ_INVALID)
pkts++;
}
odp_event_free(ev);
}
}
CU_ASSERT(pkts == alloc);
for (i = 0; i < num_ifaces; i++) {
CU_ASSERT(odp_pktio_stop(pktio[i]) == 0);
destroy_inq(pktio[i]);
CU_ASSERT(odp_pktio_close(pktio[i]) == 0);
}
}
void queue_test_sunnydays(void)
{
odp_queue_t queue_creat_id, queue_id;
odp_event_t enev[MAX_BUFFER_QUEUE];
odp_event_t deev[MAX_BUFFER_QUEUE];
odp_buffer_t buf;
odp_event_t ev;
odp_pool_t msg_pool;
odp_event_t *pev_tmp;
int i, deq_ret, ret;
int nr_deq_entries = 0;
int max_iteration = CONFIG_MAX_ITERATION;
void *prtn = NULL;
odp_queue_param_t qparams;
odp_queue_param_init(&qparams);
qparams.sched.prio = ODP_SCHED_PRIO_LOWEST;
qparams.sched.sync = ODP_SCHED_SYNC_NONE;
qparams.sched.group = ODP_SCHED_GROUP_WORKER;
queue_creat_id = odp_queue_create("test_queue",
ODP_QUEUE_TYPE_POLL, &qparams);
CU_ASSERT(ODP_QUEUE_INVALID != queue_creat_id);
CU_ASSERT_EQUAL(ODP_QUEUE_TYPE_POLL,
odp_queue_type(queue_creat_id));
queue_id = odp_queue_lookup("test_queue");
CU_ASSERT_EQUAL(queue_creat_id, queue_id);
CU_ASSERT_EQUAL(ODP_SCHED_GROUP_WORKER,
odp_queue_sched_group(queue_id));
CU_ASSERT_EQUAL(ODP_SCHED_PRIO_LOWEST, odp_queue_sched_prio(queue_id));
CU_ASSERT_EQUAL(ODP_SCHED_SYNC_NONE, odp_queue_sched_type(queue_id));
CU_ASSERT(0 == odp_queue_context_set(queue_id, &queue_contest));
prtn = odp_queue_context(queue_id);
CU_ASSERT(&queue_contest == (int *)prtn);
msg_pool = odp_pool_lookup("msg_pool");
buf = odp_buffer_alloc(msg_pool);
CU_ASSERT_FATAL(buf != ODP_BUFFER_INVALID);
ev = odp_buffer_to_event(buf);
if (!(CU_ASSERT(odp_queue_enq(queue_id, ev) == 0))) {
odp_buffer_free(buf);
} else {
CU_ASSERT_EQUAL(ev, odp_queue_deq(queue_id));
odp_buffer_free(buf);
}
for (i = 0; i < MAX_BUFFER_QUEUE; i++) {
odp_buffer_t buf = odp_buffer_alloc(msg_pool);
enev[i] = odp_buffer_to_event(buf);
}
/*
* odp_queue_enq_multi may return 0..n buffers due to the resource
* constraints in the implementation at that given point of time.
* But here we assume that we succeed in enqueuing all buffers.
*/
ret = odp_queue_enq_multi(queue_id, enev, MAX_BUFFER_QUEUE);
CU_ASSERT(MAX_BUFFER_QUEUE == ret);
i = ret < 0 ? 0 : ret;
for ( ; i < MAX_BUFFER_QUEUE; i++)
odp_event_free(enev[i]);
pev_tmp = deev;
do {
deq_ret = odp_queue_deq_multi(queue_id, pev_tmp,
MAX_BUFFER_QUEUE);
nr_deq_entries += deq_ret;
max_iteration--;
pev_tmp += deq_ret;
CU_ASSERT(max_iteration >= 0);
} while (nr_deq_entries < MAX_BUFFER_QUEUE);
for (i = 0; i < MAX_BUFFER_QUEUE; i++) {
odp_buffer_t enbuf = odp_buffer_from_event(enev[i]);
CU_ASSERT_EQUAL(enev[i], deev[i]);
odp_buffer_free(enbuf);
}
CU_ASSERT(odp_queue_destroy(queue_id) == 0);
}
