void timer_test_timeout_pool_free(void)
{
odp_pool_t pool;
odp_timeout_t tmo;
odp_pool_param_t params;
odp_pool_param_init(¶ms);
params.type = ODP_POOL_TIMEOUT;
params.tmo.num = 1;
pool = odp_pool_create("timeout_pool_free", ¶ms);
CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
odp_pool_print(pool);
/* Allocate the only timeout from the pool */
tmo = odp_timeout_alloc(pool);
CU_ASSERT_FATAL(tmo != ODP_TIMEOUT_INVALID);
/* Pool should have only one timeout */
CU_ASSERT_FATAL(odp_timeout_alloc(pool) == ODP_TIMEOUT_INVALID)
odp_timeout_free(tmo);
/* Check that the timeout was returned back to the pool */
tmo = odp_timeout_alloc(pool);
CU_ASSERT_FATAL(tmo != ODP_TIMEOUT_INVALID);
odp_timeout_free(tmo);
CU_ASSERT(odp_pool_destroy(pool) == 0);
}
int scheduler_suite_init(void)
{
odp_cpumask_t mask;
odp_shm_t shm;
odp_pool_t pool;
test_globals_t *globals;
thread_args_t *args;
odp_pool_param_t params;
odp_pool_param_init(¶ms);
params.buf.size = BUF_SIZE;
params.buf.align = 0;
params.buf.num = MSG_POOL_SIZE;
params.type = ODP_POOL_BUFFER;
pool = odp_pool_create(MSG_POOL_NAME, ¶ms);
if (pool == ODP_POOL_INVALID) {
printf("Pool creation failed (msg).\n");
return -1;
}
shm = odp_shm_reserve(GLOBALS_SHM_NAME,
sizeof(test_globals_t), ODP_CACHE_LINE_SIZE, 0);
globals = odp_shm_addr(shm);
if (!globals) {
printf("Shared memory reserve failed (globals).\n");
return -1;
}
memset(globals, 0, sizeof(test_globals_t));
globals->num_workers = odp_cpumask_default_worker(&mask, 0);
if (globals->num_workers > MAX_WORKERS)
globals->num_workers = MAX_WORKERS;
shm = odp_shm_reserve(SHM_THR_ARGS_NAME, sizeof(thread_args_t),
ODP_CACHE_LINE_SIZE, 0);
args = odp_shm_addr(shm);
if (!args) {
printf("Shared memory reserve failed (args).\n");
return -1;
}
memset(args, 0, sizeof(thread_args_t));
/* Barrier to sync test case execution */
odp_barrier_init(&globals->barrier, globals->num_workers);
odp_ticketlock_init(&globals->lock);
odp_spinlock_init(&globals->atomic_lock);
if (create_queues() != 0)
return -1;
return 0;
}
odp_pool_t open_pool(const char* name,int num){
odp_pool_param_t params;
/* Create packet pool */
odp_pool_param_init(¶ms);
params.pkt.seg_len = (1<<14)-192;
params.pkt.len = (1<<14)-192;
params.pkt.num = num;
params.type = ODP_POOL_PACKET;
return odp_pool_create(name, ¶ms);
}
/**
* IPsec pre argument processing intialization
*/
static
void ipsec_init_pre(void)
{
odp_queue_param_t qparam;
odp_pool_param_t params;
/*
* Create queues
*
* - completion queue (should eventually be ORDERED)
* - sequence number queue (must be ATOMIC)
*/
odp_queue_param_init(&qparam);
qparam.type = ODP_QUEUE_TYPE_SCHED;
qparam.sched.prio = ODP_SCHED_PRIO_HIGHEST;
qparam.sched.sync = ODP_SCHED_SYNC_ATOMIC;
qparam.sched.group = ODP_SCHED_GROUP_ALL;
completionq = queue_create("completion", &qparam);
if (ODP_QUEUE_INVALID == completionq) {
EXAMPLE_ERR("Error: completion queue creation failed\n");
exit(EXIT_FAILURE);
}
qparam.type = ODP_QUEUE_TYPE_SCHED;
qparam.sched.prio = ODP_SCHED_PRIO_HIGHEST;
qparam.sched.sync = ODP_SCHED_SYNC_ATOMIC;
qparam.sched.group = ODP_SCHED_GROUP_ALL;
seqnumq = queue_create("seqnum", &qparam);
if (ODP_QUEUE_INVALID == seqnumq) {
EXAMPLE_ERR("Error: sequence number queue creation failed\n");
exit(EXIT_FAILURE);
}
/* Create output buffer pool */
odp_pool_param_init(¶ms);
params.pkt.seg_len = SHM_OUT_POOL_BUF_SIZE;
params.pkt.len = SHM_OUT_POOL_BUF_SIZE;
params.pkt.num = SHM_PKT_POOL_BUF_COUNT;
params.type = ODP_POOL_PACKET;
out_pool = odp_pool_create("out_pool", ¶ms);
if (ODP_POOL_INVALID == out_pool) {
EXAMPLE_ERR("Error: message pool create failed.\n");
exit(EXIT_FAILURE);
}
/* Initialize our data bases */
init_sp_db();
init_sa_db();
init_tun_db();
init_ipsec_cache();
}
odp_pool_t pool_create(const char *poolname)
{
odp_pool_param_t param;
odp_pool_param_init(¶m);
param.pkt.seg_len = SHM_PKT_BUF_SIZE;
param.pkt.len = SHM_PKT_BUF_SIZE;
param.pkt.num = SHM_PKT_NUM_BUFS;
param.type = ODP_POOL_PACKET;
return odp_pool_create(poolname, ¶m);
}
void timer_test_timeout_pool_alloc(void)
{
odp_pool_t pool;
const int num = 3;
odp_timeout_t tmo[num];
odp_event_t ev;
int index;
char wrong_type = 0;
odp_pool_param_t params;
odp_pool_param_init(¶ms);
params.type = ODP_POOL_TIMEOUT;
params.tmo.num = num;
pool = odp_pool_create("timeout_pool_alloc", ¶ms);
CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
odp_pool_print(pool);
/* Try to allocate num items from the pool */
for (index = 0; index < num; index++) {
tmo[index] = odp_timeout_alloc(pool);
if (tmo[index] == ODP_TIMEOUT_INVALID)
break;
ev = odp_timeout_to_event(tmo[index]);
if (odp_event_type(ev) != ODP_EVENT_TIMEOUT)
wrong_type = 1;
}
/* Check that the pool had at least num items */
CU_ASSERT(index == num);
/* index points out of buffer[] or it point to an invalid buffer */
index--;
/* Check that the pool had correct buffers */
CU_ASSERT(wrong_type == 0);
for (; index >= 0; index--)
odp_timeout_free(tmo[index]);
CU_ASSERT(odp_pool_destroy(pool) == 0);
}
void scheduler_test_groups(void)
{
odp_pool_t p;
odp_pool_param_t params;
odp_queue_t queue_grp1, queue_grp2;
odp_buffer_t buf;
odp_event_t ev;
uint32_t *u32;
int i, j, rc;
odp_schedule_sync_t sync[] = {ODP_SCHED_SYNC_PARALLEL,
ODP_SCHED_SYNC_ATOMIC,
ODP_SCHED_SYNC_ORDERED};
int thr_id = odp_thread_id();
odp_thrmask_t zeromask, mymask, testmask;
odp_schedule_group_t mygrp1, mygrp2, lookup;
odp_schedule_group_info_t info;
odp_thrmask_zero(&zeromask);
odp_thrmask_zero(&mymask);
odp_thrmask_set(&mymask, thr_id);
/* Can't find a group before we create it */
lookup = odp_schedule_group_lookup("Test Group 1");
CU_ASSERT(lookup == ODP_SCHED_GROUP_INVALID);
/* Now create the group */
mygrp1 = odp_schedule_group_create("Test Group 1", &zeromask);
CU_ASSERT_FATAL(mygrp1 != ODP_SCHED_GROUP_INVALID);
/* Verify we can now find it */
lookup = odp_schedule_group_lookup("Test Group 1");
CU_ASSERT(lookup == mygrp1);
/* Threadmask should be retrievable and be what we expect */
rc = odp_schedule_group_thrmask(mygrp1, &testmask);
CU_ASSERT(rc == 0);
CU_ASSERT(!odp_thrmask_isset(&testmask, thr_id));
/* Now join the group and verify we're part of it */
rc = odp_schedule_group_join(mygrp1, &mymask);
CU_ASSERT(rc == 0);
rc = odp_schedule_group_thrmask(mygrp1, &testmask);
CU_ASSERT(rc == 0);
CU_ASSERT(odp_thrmask_isset(&testmask, thr_id));
/* Info struct */
memset(&info, 0, sizeof(odp_schedule_group_info_t));
rc = odp_schedule_group_info(mygrp1, &info);
CU_ASSERT(rc == 0);
CU_ASSERT(odp_thrmask_equal(&info.thrmask, &mymask) != 0);
CU_ASSERT(strcmp(info.name, "Test Group 1") == 0);
/* We can't join or leave an unknown group */
rc = odp_schedule_group_join(ODP_SCHED_GROUP_INVALID, &mymask);
CU_ASSERT(rc != 0);
rc = odp_schedule_group_leave(ODP_SCHED_GROUP_INVALID, &mymask);
CU_ASSERT(rc != 0);
/* But we can leave our group */
rc = odp_schedule_group_leave(mygrp1, &mymask);
CU_ASSERT(rc == 0);
rc = odp_schedule_group_thrmask(mygrp1, &testmask);
CU_ASSERT(rc == 0);
CU_ASSERT(!odp_thrmask_isset(&testmask, thr_id));
/* We shouldn't be able to find our second group before creating it */
lookup = odp_schedule_group_lookup("Test Group 2");
CU_ASSERT(lookup == ODP_SCHED_GROUP_INVALID);
/* Now create it and verify we can find it */
mygrp2 = odp_schedule_group_create("Test Group 2", &zeromask);
CU_ASSERT_FATAL(mygrp2 != ODP_SCHED_GROUP_INVALID);
lookup = odp_schedule_group_lookup("Test Group 2");
CU_ASSERT(lookup == mygrp2);
/* Verify we're not part of it */
rc = odp_schedule_group_thrmask(mygrp2, &testmask);
CU_ASSERT(rc == 0);
CU_ASSERT(!odp_thrmask_isset(&testmask, thr_id));
/* Now join the group and verify we're part of it */
rc = odp_schedule_group_join(mygrp2, &mymask);
CU_ASSERT(rc == 0);
rc = odp_schedule_group_thrmask(mygrp2, &testmask);
CU_ASSERT(rc == 0);
CU_ASSERT(odp_thrmask_isset(&testmask, thr_id));
/* Now verify scheduler adherence to groups */
odp_pool_param_init(¶ms);
params.buf.size = 100;
params.buf.align = 0;
params.buf.num = 2;
params.type = ODP_POOL_BUFFER;
p = odp_pool_create("sched_group_pool", ¶ms);
CU_ASSERT_FATAL(p != ODP_POOL_INVALID);
for (i = 0; i < 3; i++) {
odp_queue_param_t qp;
odp_queue_t queue, from;
odp_schedule_group_t mygrp[NUM_GROUPS];
odp_queue_t queue_grp[NUM_GROUPS];
int num = NUM_GROUPS;
odp_queue_param_init(&qp);
qp.type = ODP_QUEUE_TYPE_SCHED;
qp.sched.prio = ODP_SCHED_PRIO_DEFAULT;
qp.sched.sync = sync[i];
qp.sched.group = mygrp1;
/* Create and populate a group in group 1 */
queue_grp1 = odp_queue_create("sched_group_test_queue_1", &qp);
CU_ASSERT_FATAL(queue_grp1 != ODP_QUEUE_INVALID);
CU_ASSERT_FATAL(odp_queue_sched_group(queue_grp1) == mygrp1);
buf = odp_buffer_alloc(p);
CU_ASSERT_FATAL(buf != ODP_BUFFER_INVALID);
u32 = odp_buffer_addr(buf);
u32[0] = MAGIC1;
ev = odp_buffer_to_event(buf);
rc = odp_queue_enq(queue_grp1, ev);
CU_ASSERT(rc == 0);
if (rc)
odp_buffer_free(buf);
/* Now create and populate a queue in group 2 */
qp.sched.group = mygrp2;
queue_grp2 = odp_queue_create("sched_group_test_queue_2", &qp);
CU_ASSERT_FATAL(queue_grp2 != ODP_QUEUE_INVALID);
CU_ASSERT_FATAL(odp_queue_sched_group(queue_grp2) == mygrp2);
buf = odp_buffer_alloc(p);
CU_ASSERT_FATAL(buf != ODP_BUFFER_INVALID);
u32 = odp_buffer_addr(buf);
u32[0] = MAGIC2;
ev = odp_buffer_to_event(buf);
rc = odp_queue_enq(queue_grp2, ev);
CU_ASSERT(rc == 0);
if (rc)
odp_buffer_free(buf);
/* Swap between two groups. Application should serve both
* groups to avoid potential head of line blocking in
* scheduler. */
mygrp[0] = mygrp1;
mygrp[1] = mygrp2;
queue_grp[0] = queue_grp1;
queue_grp[1] = queue_grp2;
j = 0;
/* Ensure that each test run starts from mygrp1 */
odp_schedule_group_leave(mygrp1, &mymask);
odp_schedule_group_leave(mygrp2, &mymask);
odp_schedule_group_join(mygrp1, &mymask);
while (num) {
queue = queue_grp[j];
ev = odp_schedule(&from, ODP_SCHED_NO_WAIT);
if (ev == ODP_EVENT_INVALID) {
/* change group */
rc = odp_schedule_group_leave(mygrp[j],
&mymask);
CU_ASSERT_FATAL(rc == 0);
j = (j + 1) % NUM_GROUPS;
rc = odp_schedule_group_join(mygrp[j],
&mymask);
CU_ASSERT_FATAL(rc == 0);
continue;
}
CU_ASSERT_FATAL(from == queue);
buf = odp_buffer_from_event(ev);
u32 = odp_buffer_addr(buf);
if (from == queue_grp1) {
/* CU_ASSERT_FATAL needs these brackets */
CU_ASSERT_FATAL(u32[0] == MAGIC1);
} else {
CU_ASSERT_FATAL(u32[0] == MAGIC2);
}
odp_buffer_free(buf);
/* Tell scheduler we're about to request an event.
* Not needed, but a convenient place to test this API.
*/
odp_schedule_prefetch(1);
num--;
}
/* Release schduler context and leave groups */
odp_schedule_group_join(mygrp1, &mymask);
odp_schedule_group_join(mygrp2, &mymask);
CU_ASSERT(exit_schedule_loop() == 0);
odp_schedule_group_leave(mygrp1, &mymask);
odp_schedule_group_leave(mygrp2, &mymask);
/* Done with queues for this round */
CU_ASSERT_FATAL(odp_queue_destroy(queue_grp1) == 0);
CU_ASSERT_FATAL(odp_queue_destroy(queue_grp2) == 0);
/* Verify we can no longer find our queues */
CU_ASSERT_FATAL(odp_queue_lookup("sched_group_test_queue_1") ==
ODP_QUEUE_INVALID);
CU_ASSERT_FATAL(odp_queue_lookup("sched_group_test_queue_2") ==
ODP_QUEUE_INVALID);
}
CU_ASSERT_FATAL(odp_schedule_group_destroy(mygrp1) == 0);
CU_ASSERT_FATAL(odp_schedule_group_destroy(mygrp2) == 0);
CU_ASSERT_FATAL(odp_pool_destroy(p) == 0);
}
void scheduler_test_queue_destroy(void)
{
odp_pool_t p;
odp_pool_param_t params;
odp_queue_param_t qp;
odp_queue_t queue, from;
odp_buffer_t buf;
odp_event_t ev;
uint32_t *u32;
int i;
odp_schedule_sync_t sync[] = {ODP_SCHED_SYNC_PARALLEL,
ODP_SCHED_SYNC_ATOMIC,
ODP_SCHED_SYNC_ORDERED};
odp_queue_param_init(&qp);
odp_pool_param_init(¶ms);
params.buf.size = 100;
params.buf.align = 0;
params.buf.num = 1;
params.type = ODP_POOL_BUFFER;
p = odp_pool_create("sched_destroy_pool", ¶ms);
CU_ASSERT_FATAL(p != ODP_POOL_INVALID);
for (i = 0; i < 3; i++) {
qp.type = ODP_QUEUE_TYPE_SCHED;
qp.sched.prio = ODP_SCHED_PRIO_DEFAULT;
qp.sched.sync = sync[i];
qp.sched.group = ODP_SCHED_GROUP_ALL;
queue = odp_queue_create("sched_destroy_queue", &qp);
CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
buf = odp_buffer_alloc(p);
CU_ASSERT_FATAL(buf != ODP_BUFFER_INVALID);
u32 = odp_buffer_addr(buf);
u32[0] = MAGIC;
ev = odp_buffer_to_event(buf);
if (!(CU_ASSERT(odp_queue_enq(queue, ev) == 0)))
odp_buffer_free(buf);
ev = odp_schedule(&from, ODP_SCHED_WAIT);
CU_ASSERT_FATAL(ev != ODP_EVENT_INVALID);
CU_ASSERT_FATAL(from == queue);
buf = odp_buffer_from_event(ev);
u32 = odp_buffer_addr(buf);
CU_ASSERT_FATAL(u32[0] == MAGIC);
odp_buffer_free(buf);
odp_schedule_release_ordered();
CU_ASSERT_FATAL(odp_queue_destroy(queue) == 0);
}
CU_ASSERT_FATAL(odp_pool_destroy(p) == 0);
}
static int create_queues(void)
{
int i, j, prios, rc;
odp_pool_param_t params;
odp_buffer_t queue_ctx_buf;
queue_context *qctx, *pqctx;
uint32_t ndx;
prios = odp_schedule_num_prio();
odp_pool_param_init(¶ms);
params.buf.size = sizeof(queue_context);
params.buf.num = prios * QUEUES_PER_PRIO * 2;
params.type = ODP_POOL_BUFFER;
queue_ctx_pool = odp_pool_create(QUEUE_CTX_POOL_NAME, ¶ms);
if (queue_ctx_pool == ODP_POOL_INVALID) {
printf("Pool creation failed (queue ctx).\n");
return -1;
}
for (i = 0; i < prios; i++) {
odp_queue_param_t p;
odp_queue_param_init(&p);
p.sched.prio = i;
for (j = 0; j < QUEUES_PER_PRIO; j++) {
/* Per sched sync type */
char name[32];
odp_queue_t q, pq;
snprintf(name, sizeof(name), "sched_%d_%d_n", i, j);
p.sched.sync = ODP_SCHED_SYNC_NONE;
q = odp_queue_create(name, ODP_QUEUE_TYPE_SCHED, &p);
if (q == ODP_QUEUE_INVALID) {
printf("Schedule queue create failed.\n");
return -1;
}
snprintf(name, sizeof(name), "sched_%d_%d_a", i, j);
p.sched.sync = ODP_SCHED_SYNC_ATOMIC;
q = odp_queue_create(name, ODP_QUEUE_TYPE_SCHED, &p);
if (q == ODP_QUEUE_INVALID) {
printf("Schedule queue create failed.\n");
return -1;
}
snprintf(name, sizeof(name), "poll_%d_%d_o", i, j);
pq = odp_queue_create(name, ODP_QUEUE_TYPE_POLL, NULL);
if (pq == ODP_QUEUE_INVALID) {
printf("Poll queue create failed.\n");
return -1;
}
queue_ctx_buf = odp_buffer_alloc(queue_ctx_pool);
if (queue_ctx_buf == ODP_BUFFER_INVALID) {
printf("Cannot allocate poll queue ctx buf\n");
return -1;
}
pqctx = odp_buffer_addr(queue_ctx_buf);
pqctx->ctx_handle = queue_ctx_buf;
pqctx->sequence = 0;
rc = odp_queue_context_set(pq, pqctx);
if (rc != 0) {
printf("Cannot set poll queue context\n");
return -1;
}
/* snprintf(name, sizeof(name), "sched_%d_%d_o", i, j); */
/* p.sched.sync = ODP_SCHED_SYNC_ORDERED; */
/* p.sched.lock_count = */
/* ODP_CONFIG_MAX_ORDERED_LOCKS_PER_QUEUE; */
/* q = odp_queue_create(name, ODP_QUEUE_TYPE_SCHED, &p); */
/* if (q == ODP_QUEUE_INVALID) { */
/* printf("Schedule queue create failed.\n"); */
/* return -1; */
/* } */
/* if (odp_queue_lock_count(q) != */
/* ODP_CONFIG_MAX_ORDERED_LOCKS_PER_QUEUE) { */
/* printf("Queue %" PRIu64 " created with " */
/* "%d locks instead of expected %d\n", */
/* odp_queue_to_u64(q), */
/* odp_queue_lock_count(q), */
/* ODP_CONFIG_MAX_ORDERED_LOCKS_PER_QUEUE); */
/* return -1; */
/* } */
queue_ctx_buf = odp_buffer_alloc(queue_ctx_pool);
if (queue_ctx_buf == ODP_BUFFER_INVALID) {
printf("Cannot allocate queue ctx buf\n");
return -1;
}
qctx = odp_buffer_addr(queue_ctx_buf);
qctx->ctx_handle = queue_ctx_buf;
qctx->pq_handle = pq;
qctx->sequence = 0;
for (ndx = 0;
ndx < ODP_CONFIG_MAX_ORDERED_LOCKS_PER_QUEUE;
ndx++) {
qctx->lock_sequence[ndx] = 0;
}
rc = odp_queue_context_set(q, qctx);
if (rc != 0) {
printf("Cannot set queue context\n");
return -1;
}
}
}
return 0;
}
static int create_queues(void)
{
int i, j, prios, rc;
odp_queue_capability_t capa;
odp_pool_param_t params;
odp_buffer_t queue_ctx_buf;
queue_context *qctx, *pqctx;
uint32_t ndx;
odp_queue_param_t p;
if (odp_queue_capability(&capa) < 0) {
printf("Queue capability query failed\n");
return -1;
}
/* Limit to test maximum */
if (capa.max_ordered_locks > MAX_ORDERED_LOCKS) {
capa.max_ordered_locks = MAX_ORDERED_LOCKS;
printf("Testing only %u ordered locks\n",
capa.max_ordered_locks);
}
prios = odp_schedule_num_prio();
odp_pool_param_init(¶ms);
params.buf.size = sizeof(queue_context);
params.buf.num = prios * QUEUES_PER_PRIO * 2;
params.type = ODP_POOL_BUFFER;
queue_ctx_pool = odp_pool_create(QUEUE_CTX_POOL_NAME, ¶ms);
if (queue_ctx_pool == ODP_POOL_INVALID) {
printf("Pool creation failed (queue ctx).\n");
return -1;
}
for (i = 0; i < prios; i++) {
odp_queue_param_init(&p);
p.type = ODP_QUEUE_TYPE_SCHED;
p.sched.prio = i;
for (j = 0; j < QUEUES_PER_PRIO; j++) {
/* Per sched sync type */
char name[32];
odp_queue_t q, pq;
snprintf(name, sizeof(name), "sched_%d_%d_n", i, j);
p.sched.sync = ODP_SCHED_SYNC_PARALLEL;
q = odp_queue_create(name, &p);
if (q == ODP_QUEUE_INVALID) {
printf("Schedule queue create failed.\n");
return -1;
}
snprintf(name, sizeof(name), "sched_%d_%d_a", i, j);
p.sched.sync = ODP_SCHED_SYNC_ATOMIC;
q = odp_queue_create(name, &p);
if (q == ODP_QUEUE_INVALID) {
printf("Schedule queue create failed.\n");
return -1;
}
snprintf(name, sizeof(name), "plain_%d_%d_o", i, j);
pq = odp_queue_create(name, NULL);
if (pq == ODP_QUEUE_INVALID) {
printf("Plain queue create failed.\n");
return -1;
}
queue_ctx_buf = odp_buffer_alloc(queue_ctx_pool);
if (queue_ctx_buf == ODP_BUFFER_INVALID) {
printf("Cannot allocate plain queue ctx buf\n");
return -1;
}
pqctx = odp_buffer_addr(queue_ctx_buf);
pqctx->ctx_handle = queue_ctx_buf;
pqctx->sequence = 0;
rc = odp_queue_context_set(pq, pqctx, 0);
if (rc != 0) {
printf("Cannot set plain queue context\n");
return -1;
}
snprintf(name, sizeof(name), "sched_%d_%d_o", i, j);
p.sched.sync = ODP_SCHED_SYNC_ORDERED;
p.sched.lock_count = capa.max_ordered_locks;
q = odp_queue_create(name, &p);
if (q == ODP_QUEUE_INVALID) {
printf("Schedule queue create failed.\n");
return -1;
}
if (odp_queue_lock_count(q) !=
(int)capa.max_ordered_locks) {
printf("Queue %" PRIu64 " created with "
"%d locks instead of expected %d\n",
odp_queue_to_u64(q),
odp_queue_lock_count(q),
capa.max_ordered_locks);
return -1;
}
queue_ctx_buf = odp_buffer_alloc(queue_ctx_pool);
if (queue_ctx_buf == ODP_BUFFER_INVALID) {
printf("Cannot allocate queue ctx buf\n");
return -1;
}
qctx = odp_buffer_addr(queue_ctx_buf);
qctx->ctx_handle = queue_ctx_buf;
qctx->pq_handle = pq;
qctx->sequence = 0;
for (ndx = 0;
ndx < capa.max_ordered_locks;
ndx++) {
qctx->lock_sequence[ndx] = 0;
}
rc = odp_queue_context_set(q, qctx, 0);
if (rc != 0) {
printf("Cannot set queue context\n");
return -1;
}
}
}
return 0;
}
void scheduler_test_groups(void)
{
odp_pool_t p;
odp_pool_param_t params;
odp_queue_param_t qp;
odp_queue_t queue_grp1, queue_grp2, from;
odp_buffer_t buf;
odp_event_t ev;
uint32_t *u32;
int i, j, rc;
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]));
int thr_id = odp_thread_id();
odp_thrmask_t zeromask, mymask, testmask;
odp_schedule_group_t mygrp1, mygrp2, lookup;
odp_thrmask_zero(&zeromask);
odp_thrmask_zero(&mymask);
odp_thrmask_set(&mymask, thr_id);
/* Can't find a group before we create it */
lookup = odp_schedule_group_lookup("Test Group 1");
CU_ASSERT(lookup == ODP_SCHED_GROUP_INVALID);
/* Now create the group */
mygrp1 = odp_schedule_group_create("Test Group 1", &zeromask);
CU_ASSERT_FATAL(mygrp1 != ODP_SCHED_GROUP_INVALID);
/* Verify we can now find it */
lookup = odp_schedule_group_lookup("Test Group 1");
CU_ASSERT(lookup == mygrp1);
/* Threadmask should be retrievable and be what we expect */
rc = odp_schedule_group_thrmask(mygrp1, &testmask);
CU_ASSERT(rc == 0);
CU_ASSERT(!odp_thrmask_isset(&testmask, thr_id));
/* Now join the group and verify we're part of it */
rc = odp_schedule_group_join(mygrp1, &mymask);
CU_ASSERT(rc == 0);
rc = odp_schedule_group_thrmask(mygrp1, &testmask);
CU_ASSERT(rc == 0);
CU_ASSERT(odp_thrmask_isset(&testmask, thr_id));
/* We can't join or leave an unknown group */
rc = odp_schedule_group_join(ODP_SCHED_GROUP_INVALID, &mymask);
CU_ASSERT(rc != 0);
rc = odp_schedule_group_leave(ODP_SCHED_GROUP_INVALID, &mymask);
CU_ASSERT(rc != 0);
/* But we can leave our group */
rc = odp_schedule_group_leave(mygrp1, &mymask);
CU_ASSERT(rc == 0);
rc = odp_schedule_group_thrmask(mygrp1, &testmask);
CU_ASSERT(rc == 0);
CU_ASSERT(!odp_thrmask_isset(&testmask, thr_id));
/* We shouldn't be able to find our second group before creating it */
lookup = odp_schedule_group_lookup("Test Group 2");
CU_ASSERT(lookup == ODP_SCHED_GROUP_INVALID);
/* Now create it and verify we can find it */
mygrp2 = odp_schedule_group_create("Test Group 2", &zeromask);
CU_ASSERT_FATAL(mygrp2 != ODP_SCHED_GROUP_INVALID);
lookup = odp_schedule_group_lookup("Test Group 2");
CU_ASSERT(lookup == mygrp2);
/* Verify we're not part of it */
rc = odp_schedule_group_thrmask(mygrp2, &testmask);
CU_ASSERT(rc == 0);
CU_ASSERT(!odp_thrmask_isset(&testmask, thr_id));
/* Now join the group and verify we're part of it */
rc = odp_schedule_group_join(mygrp2, &mymask);
CU_ASSERT(rc == 0);
rc = odp_schedule_group_thrmask(mygrp2, &testmask);
CU_ASSERT(rc == 0);
CU_ASSERT(odp_thrmask_isset(&testmask, thr_id));
/* Now verify scheduler adherence to groups */
odp_queue_param_init(&qp);
odp_pool_param_init(¶ms);
params.buf.size = 100;
params.buf.align = 0;
params.buf.num = 2;
params.type = ODP_POOL_BUFFER;
p = odp_pool_create("sched_group_pool", ¶ms);
CU_ASSERT_FATAL(p != ODP_POOL_INVALID);
for (i = 0; i < num_sync; i++) {
qp.sched.prio = ODP_SCHED_PRIO_DEFAULT;
qp.sched.sync = sync[i];
qp.sched.group = mygrp1;
/* Create and populate a group in group 1 */
queue_grp1 = odp_queue_create("sched_group_test_queue_1",
ODP_QUEUE_TYPE_SCHED, &qp);
CU_ASSERT_FATAL(queue_grp1 != ODP_QUEUE_INVALID);
CU_ASSERT_FATAL(odp_queue_sched_group(queue_grp1) == mygrp1);
buf = odp_buffer_alloc(p);
CU_ASSERT_FATAL(buf != ODP_BUFFER_INVALID);
u32 = odp_buffer_addr(buf);
u32[0] = MAGIC1;
ev = odp_buffer_to_event(buf);
if (!(CU_ASSERT(odp_queue_enq(queue_grp1, ev) == 0)))
odp_buffer_free(buf);
/* Now create and populate a queue in group 2 */
qp.sched.group = mygrp2;
queue_grp2 = odp_queue_create("sched_group_test_queue_2",
ODP_QUEUE_TYPE_SCHED, &qp);
CU_ASSERT_FATAL(queue_grp2 != ODP_QUEUE_INVALID);
CU_ASSERT_FATAL(odp_queue_sched_group(queue_grp2) == mygrp2);
buf = odp_buffer_alloc(p);
CU_ASSERT_FATAL(buf != ODP_BUFFER_INVALID);
u32 = odp_buffer_addr(buf);
u32[0] = MAGIC2;
ev = odp_buffer_to_event(buf);
if (!(CU_ASSERT(odp_queue_enq(queue_grp2, ev) == 0)))
odp_buffer_free(buf);
/* Scheduler should give us the event from Group 2 */
ev = odp_schedule(&from, ODP_SCHED_WAIT);
CU_ASSERT_FATAL(ev != ODP_EVENT_INVALID);
CU_ASSERT_FATAL(from == queue_grp2);
buf = odp_buffer_from_event(ev);
u32 = odp_buffer_addr(buf);
CU_ASSERT_FATAL(u32[0] == MAGIC2);
odp_buffer_free(buf);
/* Scheduler should not return anything now since we're
* not in Group 1 and Queue 2 is empty. Do this several
* times to confirm.
*/
for (j = 0; j < 10; j++) {
ev = odp_schedule(&from, ODP_SCHED_NO_WAIT);
CU_ASSERT_FATAL(ev == ODP_EVENT_INVALID)
}
/* Now join group 1 and verify we can get the event */
rc = odp_schedule_group_join(mygrp1, &mymask);
CU_ASSERT_FATAL(rc == 0);
/* Tell scheduler we're about to request an event.
* Not needed, but a convenient place to test this API.
*/
odp_schedule_prefetch(1);
/* Now get the event from Queue 1 */
ev = odp_schedule(&from, ODP_SCHED_WAIT);
CU_ASSERT_FATAL(ev != ODP_EVENT_INVALID);
CU_ASSERT_FATAL(from == queue_grp1);
buf = odp_buffer_from_event(ev);
u32 = odp_buffer_addr(buf);
CU_ASSERT_FATAL(u32[0] == MAGIC1);
odp_buffer_free(buf);
/* Leave group 1 for next pass */
rc = odp_schedule_group_leave(mygrp1, &mymask);
CU_ASSERT_FATAL(rc == 0);
/* We must release order before destroying queues */
odp_schedule_release_ordered();
/* Done with queues for this round */
CU_ASSERT_FATAL(odp_queue_destroy(queue_grp1) == 0);
CU_ASSERT_FATAL(odp_queue_destroy(queue_grp2) == 0);
/* Verify we can no longer find our queues */
CU_ASSERT_FATAL(odp_queue_lookup("sched_group_test_queue_1") ==
ODP_QUEUE_INVALID);
CU_ASSERT_FATAL(odp_queue_lookup("sched_group_test_queue_2") ==
ODP_QUEUE_INVALID);
}
CU_ASSERT_FATAL(odp_schedule_group_destroy(mygrp1) == 0);
CU_ASSERT_FATAL(odp_schedule_group_destroy(mygrp2) == 0);
CU_ASSERT_FATAL(odp_pool_destroy(p) == 0);
}
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");
}
static int test_init(void)
{
odp_pool_param_t params;
odp_queue_param_t qparam;
odp_queue_t inq_def;
const char *iface;
int schedule;
char inq_name[ODP_QUEUE_NAME_LEN];
odp_pool_param_init(¶ms);
params.pkt.len = PKT_HDR_LEN + gbl_args->args.pkt_len;
params.pkt.seg_len = params.pkt.len;
params.pkt.num = PKT_BUF_NUM;
params.type = ODP_POOL_PACKET;
transmit_pkt_pool = odp_pool_create("pkt_pool_transmit", ¶ms);
if (transmit_pkt_pool == ODP_POOL_INVALID)
LOG_ABORT("Failed to create transmit pool\n");
odp_atomic_init_u32(&ip_seq, 0);
odp_atomic_init_u32(&shutdown, 0);
iface = gbl_args->args.ifaces[0];
schedule = gbl_args->args.schedule;
/* create pktios and associate input/output queues */
gbl_args->pktio_tx = create_pktio(iface, schedule);
if (gbl_args->args.num_ifaces > 1) {
iface = gbl_args->args.ifaces[1];
gbl_args->pktio_rx = create_pktio(iface, schedule);
} else {
gbl_args->pktio_rx = gbl_args->pktio_tx;
}
odp_pktio_mac_addr(gbl_args->pktio_tx, gbl_args->src_mac,
ODPH_ETHADDR_LEN);
odp_pktio_mac_addr(gbl_args->pktio_rx, gbl_args->dst_mac,
ODPH_ETHADDR_LEN);
if (gbl_args->pktio_rx == ODP_PKTIO_INVALID ||
gbl_args->pktio_tx == ODP_PKTIO_INVALID) {
LOG_ERR("failed to open pktio\n");
return -1;
}
/* create and associate an input queue for the RX side */
odp_queue_param_init(&qparam);
qparam.sched.prio = ODP_SCHED_PRIO_DEFAULT;
qparam.sched.sync = ODP_SCHED_SYNC_NONE;
qparam.sched.group = ODP_SCHED_GROUP_ALL;
snprintf(inq_name, sizeof(inq_name), "inq-pktio-%" PRIu64,
odp_pktio_to_u64(gbl_args->pktio_rx));
inq_def = odp_queue_lookup(inq_name);
if (inq_def == ODP_QUEUE_INVALID)
inq_def = odp_queue_create(inq_name,
ODP_QUEUE_TYPE_PKTIN, &qparam);
if (inq_def == ODP_QUEUE_INVALID)
return -1;
if (odp_pktio_inq_setdef(gbl_args->pktio_rx, inq_def) != 0)
return -1;
if (odp_pktio_start(gbl_args->pktio_tx) != 0)
return -1;
if (gbl_args->args.num_ifaces > 1 &&
odp_pktio_start(gbl_args->pktio_rx))
return -1;
return 0;
}
static int test_init(void)
{
odp_pool_param_t params;
const char *iface;
int schedule;
odp_pool_param_init(¶ms);
params.pkt.len = PKT_HDR_LEN + gbl_args->args.pkt_len;
params.pkt.seg_len = params.pkt.len;
params.pkt.num = PKT_BUF_NUM;
params.type = ODP_POOL_PACKET;
transmit_pkt_pool = odp_pool_create("pkt_pool_transmit", ¶ms);
if (transmit_pkt_pool == ODP_POOL_INVALID)
LOG_ABORT("Failed to create transmit pool\n");
odp_atomic_init_u32(&ip_seq, 0);
odp_atomic_init_u32(&shutdown, 0);
iface = gbl_args->args.ifaces[0];
schedule = gbl_args->args.schedule;
/* create pktios and associate input/output queues */
gbl_args->pktio_tx = create_pktio(iface, schedule);
if (gbl_args->args.num_ifaces > 1) {
iface = gbl_args->args.ifaces[1];
gbl_args->pktio_rx = create_pktio(iface, schedule);
} else {
gbl_args->pktio_rx = gbl_args->pktio_tx;
}
odp_pktio_mac_addr(gbl_args->pktio_tx, gbl_args->src_mac,
ODPH_ETHADDR_LEN);
odp_pktio_mac_addr(gbl_args->pktio_rx, gbl_args->dst_mac,
ODPH_ETHADDR_LEN);
if (gbl_args->pktio_rx == ODP_PKTIO_INVALID ||
gbl_args->pktio_tx == ODP_PKTIO_INVALID) {
LOG_ERR("failed to open pktio\n");
return -1;
}
/* Create single queue with default parameters */
if (odp_pktout_queue_config(gbl_args->pktio_tx, NULL)) {
LOG_ERR("failed to configure pktio_tx queue\n");
return -1;
}
/* Configure also input side (with defaults) */
if (odp_pktin_queue_config(gbl_args->pktio_tx, NULL)) {
LOG_ERR("failed to configure pktio_tx queue\n");
return -1;
}
if (gbl_args->args.num_ifaces > 1) {
if (odp_pktout_queue_config(gbl_args->pktio_rx, NULL)) {
LOG_ERR("failed to configure pktio_rx queue\n");
return -1;
}
if (odp_pktin_queue_config(gbl_args->pktio_rx, NULL)) {
LOG_ERR("failed to configure pktio_rx queue\n");
return -1;
}
}
if (odp_pktio_start(gbl_args->pktio_tx) != 0)
return -1;
if (gbl_args->args.num_ifaces > 1 &&
odp_pktio_start(gbl_args->pktio_rx))
return -1;
return 0;
}
static void chaos_run(unsigned int qtype)
{
odp_pool_t pool;
odp_pool_param_t params;
odp_queue_param_t qp;
odp_buffer_t buf;
chaos_buf *cbuf;
test_globals_t *globals;
thread_args_t *args;
odp_shm_t shm;
int i, rc;
odp_schedule_sync_t sync[] = {ODP_SCHED_SYNC_PARALLEL,
ODP_SCHED_SYNC_ATOMIC,
ODP_SCHED_SYNC_ORDERED};
const unsigned num_sync = (sizeof(sync) / sizeof(odp_schedule_sync_t));
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(globals);
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.type = ODP_QUEUE_TYPE_SCHED;
qp.sched.prio = ODP_SCHED_PRIO_DEFAULT;
qp.sched.group = ODP_SCHED_GROUP_ALL;
for (i = 0; i < CHAOS_NUM_QUEUES; i++) {
uint32_t ndx = (qtype == num_sync ? i % num_sync : qtype);
qp.sched.sync = sync[ndx];
snprintf(globals->chaos_q[i].name,
sizeof(globals->chaos_q[i].name),
"chaos queue %d - %s", i,
qtypes[ndx]);
globals->chaos_q[i].handle =
odp_queue_create(globals->chaos_q[i].name, &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), 0);
CU_ASSERT_FATAL(rc == 0);
}
/* Now populate the queues with the initial seed elements */
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);
}
/* 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());
drain_queues();
exit_schedule_loop();
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);
}
/**
* ODP packet example main function
*/
int main(int argc, char * argv[])
{
odph_linux_pthread_t thread_tbl[MAX_WORKERS];
odp_pool_t pool;
int num_workers;
int i;
odp_shm_t shm;
odp_cpumask_t cpumask;
char cpumaskstr[ODP_CPUMASK_STR_SIZE];
odp_pool_param_t params;
odp_timer_pool_param_t tparams;
odp_timer_pool_t tp;
odp_pool_t tmop;
/* Init ODP before calling anything else */
if (odp_init_global(NULL, NULL)) {
EXAMPLE_ERR("Error: ODP global init failed.\n");
exit(EXIT_FAILURE);
}
if (odp_init_local(ODP_THREAD_CONTROL)) {
EXAMPLE_ERR("Error: ODP local init failed.\n");
exit(EXIT_FAILURE);
}
my_sleep(1 + __k1_get_cluster_id() / 4);
/* init counters */
odp_atomic_init_u64(&counters.seq, 0);
odp_atomic_init_u64(&counters.ip, 0);
odp_atomic_init_u64(&counters.udp, 0);
odp_atomic_init_u64(&counters.icmp, 0);
odp_atomic_init_u64(&counters.cnt, 0);
/* Reserve memory for args from shared mem */
shm = odp_shm_reserve("shm_args", sizeof(args_t),
ODP_CACHE_LINE_SIZE, 0);
args = odp_shm_addr(shm);
if (args == NULL) {
EXAMPLE_ERR("Error: shared mem alloc failed.\n");
exit(EXIT_FAILURE);
}
memset(args, 0, sizeof(*args));
/* Parse and store the application arguments */
parse_args(argc, argv, &args->appl);
/* Print both system and application information */
print_info(NO_PATH(argv[0]), &args->appl);
/* Default to system CPU count unless user specified */
num_workers = MAX_WORKERS;
if (args->appl.cpu_count)
num_workers = args->appl.cpu_count;
num_workers = odp_cpumask_default_worker(&cpumask, num_workers);
if (args->appl.mask) {
odp_cpumask_from_str(&cpumask, args->appl.mask);
num_workers = odp_cpumask_count(&cpumask);
}
(void)odp_cpumask_to_str(&cpumask, cpumaskstr, sizeof(cpumaskstr));
printf("num worker threads: %i\n", num_workers);
printf("first CPU: %i\n", odp_cpumask_first(&cpumask));
printf("cpu mask: %s\n", cpumaskstr);
/* ping mode need two workers */
if (args->appl.mode == APPL_MODE_PING) {
if (num_workers < 2) {
EXAMPLE_ERR("Need at least two worker threads\n");
exit(EXIT_FAILURE);
} else {
num_workers = 2;
}
}
/* Create packet pool */
odp_pool_param_init(¶ms);
params.pkt.seg_len = SHM_PKT_POOL_BUF_SIZE;
params.pkt.len = SHM_PKT_POOL_BUF_SIZE;
params.pkt.num = SHM_PKT_POOL_SIZE/SHM_PKT_POOL_BUF_SIZE;
params.type = ODP_POOL_PACKET;
pool = odp_pool_create("packet_pool", ¶ms);
if (pool == ODP_POOL_INVALID) {
EXAMPLE_ERR("Error: packet pool create failed.\n");
exit(EXIT_FAILURE);
}
odp_pool_print(pool);
/* Create timer pool */
tparams.res_ns = 1 * ODP_TIME_MSEC_IN_NS;
tparams.min_tmo = 0;
tparams.max_tmo = 10000 * ODP_TIME_SEC_IN_NS;
tparams.num_timers = num_workers; /* One timer per worker */
tparams.priv = 0; /* Shared */
tparams.clk_src = ODP_CLOCK_CPU;
tp = odp_timer_pool_create("timer_pool", &tparams);
if (tp == ODP_TIMER_POOL_INVALID) {
EXAMPLE_ERR("Timer pool create failed.\n");
exit(EXIT_FAILURE);
}
odp_timer_pool_start();
/* Create timeout pool */
memset(¶ms, 0, sizeof(params));
params.tmo.num = tparams.num_timers; /* One timeout per timer */
params.type = ODP_POOL_TIMEOUT;
tmop = odp_pool_create("timeout_pool", ¶ms);
if (pool == ODP_POOL_INVALID) {
EXAMPLE_ERR("Error: packet pool create failed.\n");
exit(EXIT_FAILURE);
}
for (i = 0; i < args->appl.if_count; ++i)
create_pktio(args->appl.if_names[i], pool);
/* Create and init worker threads */
memset(thread_tbl, 0, sizeof(thread_tbl));
if (args->appl.mode == APPL_MODE_PING) {
odp_cpumask_t cpu_mask;
odp_queue_t tq;
int cpu_first, cpu_next;
odp_cpumask_zero(&cpu_mask);
cpu_first = odp_cpumask_first(&cpumask);
odp_cpumask_set(&cpu_mask, cpu_first);
tq = odp_queue_create("", ODP_QUEUE_TYPE_POLL, NULL);
if (tq == ODP_QUEUE_INVALID)
abort();
args->thread[1].pktio_dev = args->appl.if_names[0];
args->thread[1].pool = pool;
args->thread[1].tp = tp;
args->thread[1].tq = tq;
args->thread[1].tim = odp_timer_alloc(tp, tq, NULL);
if (args->thread[1].tim == ODP_TIMER_INVALID)
abort();
args->thread[1].tmo_ev = odp_timeout_alloc(tmop);
if (args->thread[1].tmo_ev == ODP_TIMEOUT_INVALID)
abort();
args->thread[1].mode = args->appl.mode;
odph_linux_pthread_create(&thread_tbl[1], &cpu_mask,
gen_recv_thread, &args->thread[1],
ODP_THREAD_WORKER);
tq = odp_queue_create("", ODP_QUEUE_TYPE_POLL, NULL);
if (tq == ODP_QUEUE_INVALID)
abort();
args->thread[0].pktio_dev = args->appl.if_names[0];
args->thread[0].pool = pool;
args->thread[0].tp = tp;
args->thread[0].tq = tq;
args->thread[0].tim = odp_timer_alloc(tp, tq, NULL);
if (args->thread[0].tim == ODP_TIMER_INVALID)
abort();
args->thread[0].tmo_ev = odp_timeout_alloc(tmop);
if (args->thread[0].tmo_ev == ODP_TIMEOUT_INVALID)
abort();
args->thread[0].mode = args->appl.mode;
cpu_next = odp_cpumask_next(&cpumask, cpu_first);
odp_cpumask_zero(&cpu_mask);
odp_cpumask_set(&cpu_mask, cpu_next);
odph_linux_pthread_create(&thread_tbl[0], &cpu_mask,
gen_send_thread, &args->thread[0],
ODP_THREAD_WORKER);
} else {
int cpu = odp_cpumask_first(&cpumask);
for (i = 0; i < num_workers; ++i) {
odp_cpumask_t thd_mask;
void *(*thr_run_func) (void *);
int if_idx;
odp_queue_t tq;
if_idx = i % args->appl.if_count;
args->thread[i].pktio_dev = args->appl.if_names[if_idx];
tq = odp_queue_create("", ODP_QUEUE_TYPE_POLL, NULL);
if (tq == ODP_QUEUE_INVALID)
abort();
args->thread[i].pool = pool;
args->thread[i].tp = tp;
args->thread[i].tq = tq;
args->thread[i].tim = odp_timer_alloc(tp, tq, NULL);
if (args->thread[i].tim == ODP_TIMER_INVALID)
abort();
args->thread[i].tmo_ev = odp_timeout_alloc(tmop);
if (args->thread[i].tmo_ev == ODP_TIMEOUT_INVALID)
abort();
args->thread[i].mode = args->appl.mode;
if (args->appl.mode == APPL_MODE_UDP) {
thr_run_func = gen_send_thread;
} else if (args->appl.mode == APPL_MODE_RCV) {
thr_run_func = gen_recv_thread;
} else {
EXAMPLE_ERR("ERR MODE\n");
exit(EXIT_FAILURE);
}
/*
* Create threads one-by-one instead of all-at-once,
* because each thread might get different arguments.
* Calls odp_thread_create(cpu) for each thread
*/
odp_cpumask_zero(&thd_mask);
odp_cpumask_set(&thd_mask, cpu);
odph_linux_pthread_create(&thread_tbl[i],
&thd_mask,
thr_run_func,
&args->thread[i],
ODP_THREAD_WORKER);
cpu = odp_cpumask_next(&cpumask, cpu);
}
}
print_global_stats(num_workers);
/* Master thread waits for other threads to exit */
odph_linux_pthread_join(thread_tbl, num_workers);
free(args->appl.if_names);
free(args->appl.if_str);
printf("Exit\n\n");
return 0;
}
/**
* ODP L2 forwarding main function
*/
int main(int argc, char *argv[])
{
odph_linux_pthread_t thread_tbl[MAX_WORKERS];
odp_pool_t pool;
int i;
int cpu;
int num_workers;
odp_shm_t shm;
odp_cpumask_t cpumask;
char cpumaskstr[ODP_CPUMASK_STR_SIZE];
odph_ethaddr_t new_addr;
odp_pktio_t pktio;
odp_pool_param_t params;
int ret;
stats_t *stats;
/* Init ODP before calling anything else */
if (odp_init_global(NULL, NULL)) {
LOG_ERR("Error: ODP global init failed.\n");
exit(EXIT_FAILURE);
}
/* Init this thread */
if (odp_init_local(ODP_THREAD_CONTROL)) {
LOG_ERR("Error: ODP local init failed.\n");
exit(EXIT_FAILURE);
}
/* Reserve memory for args from shared mem */
shm = odp_shm_reserve("shm_args", sizeof(args_t),
ODP_CACHE_LINE_SIZE, 0);
gbl_args = odp_shm_addr(shm);
if (gbl_args == NULL) {
LOG_ERR("Error: shared mem alloc failed.\n");
exit(EXIT_FAILURE);
}
memset(gbl_args, 0, sizeof(*gbl_args));
/* Parse and store the application arguments */
parse_args(argc, argv, &gbl_args->appl);
/* Print both system and application information */
print_info(NO_PATH(argv[0]), &gbl_args->appl);
/* Default to system CPU count unless user specified */
num_workers = MAX_WORKERS;
if (gbl_args->appl.cpu_count)
num_workers = gbl_args->appl.cpu_count;
/* Get default worker cpumask */
num_workers = odp_cpumask_default_worker(&cpumask, num_workers);
(void)odp_cpumask_to_str(&cpumask, cpumaskstr, sizeof(cpumaskstr));
printf("num worker threads: %i\n", num_workers);
printf("first CPU: %i\n", odp_cpumask_first(&cpumask));
printf("cpu mask: %s\n", cpumaskstr);
if (num_workers < gbl_args->appl.if_count) {
LOG_ERR("Error: CPU count %d less than interface count\n",
num_workers);
exit(EXIT_FAILURE);
}
/* Create packet pool */
odp_pool_param_init(¶ms);
params.pkt.seg_len = SHM_PKT_POOL_BUF_SIZE;
params.pkt.len = SHM_PKT_POOL_BUF_SIZE;
params.pkt.num = SHM_PKT_POOL_SIZE/SHM_PKT_POOL_BUF_SIZE;
params.type = ODP_POOL_PACKET;
pool = odp_pool_create("packet pool", ¶ms);
if (pool == ODP_POOL_INVALID) {
LOG_ERR("Error: packet pool create failed.\n");
exit(EXIT_FAILURE);
}
odp_pool_print(pool);
for (i = 0; i < gbl_args->appl.if_count; ++i) {
pktio = create_pktio(gbl_args->appl.if_names[i], pool);
if (pktio == ODP_PKTIO_INVALID)
exit(EXIT_FAILURE);
gbl_args->pktios[i] = pktio;
/* Save interface ethernet address */
if (odp_pktio_mac_addr(pktio, gbl_args->port_eth_addr[i].addr,
ODPH_ETHADDR_LEN) != ODPH_ETHADDR_LEN) {
LOG_ERR("Error: interface ethernet address unknown\n");
exit(EXIT_FAILURE);
}
/* Save destination eth address */
if (gbl_args->appl.dst_change) {
/* 02:00:00:00:00:XX */
memset(&new_addr, 0, sizeof(odph_ethaddr_t));
new_addr.addr[0] = 0x02;
new_addr.addr[5] = i;
gbl_args->dst_eth_addr[i] = new_addr;
}
/* Save interface destination port */
gbl_args->dst_port[i] = find_dest_port(i);
}
gbl_args->pktios[i] = ODP_PKTIO_INVALID;
memset(thread_tbl, 0, sizeof(thread_tbl));
stats = gbl_args->stats;
odp_barrier_init(&barrier, num_workers + 1);
/* Create worker threads */
cpu = odp_cpumask_first(&cpumask);
for (i = 0; i < num_workers; ++i) {
odp_cpumask_t thd_mask;
void *(*thr_run_func) (void *);
if (gbl_args->appl.mode == DIRECT_RECV)
thr_run_func = pktio_direct_recv_thread;
else /* SCHED_NONE / SCHED_ATOMIC / SCHED_ORDERED */
thr_run_func = pktio_queue_thread;
gbl_args->thread[i].src_idx = i % gbl_args->appl.if_count;
gbl_args->thread[i].stats = &stats[i];
odp_cpumask_zero(&thd_mask);
odp_cpumask_set(&thd_mask, cpu);
odph_linux_pthread_create(&thread_tbl[i], &thd_mask,
thr_run_func,
&gbl_args->thread[i],
ODP_THREAD_WORKER);
cpu = odp_cpumask_next(&cpumask, cpu);
}
/* Start packet receive and transmit */
for (i = 0; i < gbl_args->appl.if_count; ++i) {
pktio = gbl_args->pktios[i];
ret = odp_pktio_start(pktio);
if (ret) {
LOG_ERR("Error: unable to start %s\n",
gbl_args->appl.if_names[i]);
exit(EXIT_FAILURE);
}
}
ret = print_speed_stats(num_workers, stats, gbl_args->appl.time,
gbl_args->appl.accuracy);
exit_threads = 1;
/* Master thread waits for other threads to exit */
odph_linux_pthread_join(thread_tbl, num_workers);
free(gbl_args->appl.if_names);
free(gbl_args->appl.if_str);
printf("Exit\n\n");
return ret;
}
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);
}
int main(int argc, char **argv)
{
odph_odpthread_t thread_tbl[MAX_WORKERS];
int i, j;
int cpu;
int num_workers;
odp_shm_t shm;
odp_cpumask_t cpumask;
char cpumaskstr[ODP_CPUMASK_STR_SIZE];
odp_pool_param_t params;
int ret;
stats_t (*stats)[MAX_PKTIOS];
int if_count;
odp_instance_t instance;
odph_odpthread_params_t thr_params;
/* Init ODP before calling anything else */
if (odp_init_global(&instance, NULL, NULL)) {
printf("Error: ODP global init failed.\n");
exit(EXIT_FAILURE);
}
/* Init this thread */
if (odp_init_local(instance, ODP_THREAD_CONTROL)) {
printf("Error: ODP local init failed.\n");
exit(EXIT_FAILURE);
}
/* Reserve memory for args from shared mem */
shm = odp_shm_reserve("shm_args", sizeof(args_t),
ODP_CACHE_LINE_SIZE, 0);
gbl_args = odp_shm_addr(shm);
if (gbl_args == NULL) {
printf("Error: shared mem alloc failed.\n");
exit(EXIT_FAILURE);
}
gbl_args_init(gbl_args);
for (i = 0; (unsigned)i < MAC_TBL_SIZE; i++)
odp_atomic_init_u64(&gbl_args->mac_tbl[i], 0);
/* Parse and store the application arguments */
parse_args(argc, argv, &gbl_args->appl);
/* Print both system and application information */
print_info(NO_PATH(argv[0]), &gbl_args->appl);
/* Default to system CPU count unless user specified */
num_workers = MAX_WORKERS;
if (gbl_args->appl.cpu_count)
num_workers = gbl_args->appl.cpu_count;
/* Get default worker cpumask */
num_workers = odp_cpumask_default_worker(&cpumask, num_workers);
(void)odp_cpumask_to_str(&cpumask, cpumaskstr, sizeof(cpumaskstr));
gbl_args->appl.num_workers = num_workers;
if_count = gbl_args->appl.if_count;
printf("num worker threads: %i\n", num_workers);
printf("first CPU: %i\n", odp_cpumask_first(&cpumask));
printf("cpu mask: %s\n", cpumaskstr);
/* Create packet pool */
odp_pool_param_init(¶ms);
params.pkt.seg_len = SHM_PKT_POOL_BUF_SIZE;
params.pkt.len = SHM_PKT_POOL_BUF_SIZE;
params.pkt.num = SHM_PKT_POOL_SIZE;
params.type = ODP_POOL_PACKET;
gbl_args->pool = odp_pool_create("packet pool", ¶ms);
if (gbl_args->pool == ODP_POOL_INVALID) {
printf("Error: packet pool create failed.\n");
exit(EXIT_FAILURE);
}
odp_pool_print(gbl_args->pool);
bind_workers();
for (i = 0; i < if_count; ++i) {
const char *dev = gbl_args->appl.if_names[i];
int num_rx;
/* An RX queue per assigned worker and a private TX queue for
* each worker */
num_rx = gbl_args->pktios[i].num_rx_thr;
if (create_pktio(dev, i, num_rx, num_workers, gbl_args->pool))
exit(EXIT_FAILURE);
ret = odp_pktio_promisc_mode_set(gbl_args->pktios[i].pktio, 1);
if (ret != 0) {
printf("Error: failed to set port to promiscuous mode.\n");
exit(EXIT_FAILURE);
}
}
gbl_args->pktios[i].pktio = ODP_PKTIO_INVALID;
bind_queues();
print_port_mapping();
memset(thread_tbl, 0, sizeof(thread_tbl));
odp_barrier_init(&barrier, num_workers + 1);
stats = gbl_args->stats;
memset(&thr_params, 0, sizeof(thr_params));
thr_params.thr_type = ODP_THREAD_WORKER;
thr_params.instance = instance;
thr_params.start = run_worker;
/* Create worker threads */
cpu = odp_cpumask_first(&cpumask);
for (i = 0; i < num_workers; ++i) {
odp_cpumask_t thd_mask;
for (j = 0; j < MAX_PKTIOS; j++)
gbl_args->thread[i].stats[j] = &stats[i][j];
thr_params.arg = &gbl_args->thread[i];
odp_cpumask_zero(&thd_mask);
odp_cpumask_set(&thd_mask, cpu);
odph_odpthreads_create(&thread_tbl[i], &thd_mask, &thr_params);
cpu = odp_cpumask_next(&cpumask, cpu);
}
/* Start packet receive and transmit */
for (i = 0; i < if_count; ++i) {
odp_pktio_t pktio;
pktio = gbl_args->pktios[i].pktio;
ret = odp_pktio_start(pktio);
if (ret) {
printf("Error: unable to start %s\n",
gbl_args->appl.if_names[i]);
exit(EXIT_FAILURE);
}
}
ret = print_speed_stats(num_workers, gbl_args->stats,
gbl_args->appl.time, gbl_args->appl.accuracy);
exit_threads = 1;
/* Master thread waits for other threads to exit */
for (i = 0; i < num_workers; ++i)
odph_odpthreads_join(&thread_tbl[i]);
free(gbl_args->appl.if_names);
free(gbl_args->appl.if_str);
if (odp_pool_destroy(gbl_args->pool)) {
printf("Error: pool destroy\n");
exit(EXIT_FAILURE);
}
if (odp_term_local()) {
printf("Error: term local\n");
exit(EXIT_FAILURE);
}
if (odp_term_global(instance)) {
printf("Error: term global\n");
exit(EXIT_FAILURE);
}
printf("Exit: %d\n\n", ret);
return ret;
}
static int run_test(void)
{
int ret;
int i;
odp_cpumask_t txmask, rxmask;
test_status_t status = {
.pps_curr = gbl_args->args.pps,
.pps_pass = 0,
.pps_fail = 0,
.warmup = 1,
};
ret = setup_txrx_masks(&txmask, &rxmask);
if (ret)
return ret;
printf("Starting test with params:\n");
printf("\tTransmit workers: \t%d\n", odp_cpumask_count(&txmask));
printf("\tReceive workers: \t%d\n", odp_cpumask_count(&rxmask));
printf("\tDuration (seconds): \t%d\n", gbl_args->args.duration);
printf("\tTransmit batch length:\t%" PRIu32 "\n",
gbl_args->args.tx_batch_len);
printf("\tReceive batch length: \t%" PRIu32 "\n",
gbl_args->args.rx_batch_len);
printf("\tPacket receive method:\t%s\n",
gbl_args->args.schedule ? "schedule" : "plain");
printf("\tInterface(s): \t");
for (i = 0; i < gbl_args->args.num_ifaces; ++i)
printf("%s ", gbl_args->args.ifaces[i]);
printf("\n");
/* first time just run the test but throw away the results */
run_test_single(&txmask, &rxmask, &status);
status.warmup = 0;
while (1) {
ret = run_test_single(&txmask, &rxmask, &status);
if (ret <= 0)
break;
}
return ret;
}
static odp_pktio_t create_pktio(const char *iface, int schedule)
{
odp_pool_t pool;
odp_pktio_t pktio;
char pool_name[ODP_POOL_NAME_LEN];
odp_pool_param_t params;
odp_pktio_param_t pktio_param;
odp_pool_param_init(¶ms);
params.pkt.len = PKT_HDR_LEN + gbl_args->args.pkt_len;
params.pkt.seg_len = params.pkt.len;
params.pkt.num = PKT_BUF_NUM;
params.type = ODP_POOL_PACKET;
snprintf(pool_name, sizeof(pool_name), "pkt_pool_%s", iface);
pool = odp_pool_create(pool_name, ¶ms);
if (pool == ODP_POOL_INVALID)
return ODP_PKTIO_INVALID;
odp_pktio_param_init(&pktio_param);
if (schedule)
pktio_param.in_mode = ODP_PKTIN_MODE_SCHED;
else
pktio_param.in_mode = ODP_PKTIN_MODE_QUEUE;
pktio = odp_pktio_open(iface, pool, &pktio_param);
return pktio;
}
/**
* Test main function
*/
int main(int argc, char *argv[])
{
odph_linux_pthread_t thread_tbl[MAX_WORKERS];
int num_workers;
odp_queue_t queue;
uint64_t tick, ns;
odp_queue_param_t param;
odp_pool_param_t params;
odp_timer_pool_param_t tparams;
odp_timer_pool_info_t tpinfo;
odp_cpumask_t cpumask;
char cpumaskstr[ODP_CPUMASK_STR_SIZE];
odp_shm_t shm = ODP_SHM_INVALID;
test_globals_t *gbls = NULL;
int err = 0;
printf("\nODP timer example starts\n");
if (odp_init_global(NULL, NULL)) {
err = 1;
printf("ODP global init failed.\n");
goto err_global;
}
/* Init this thread. */
if (odp_init_local(ODP_THREAD_CONTROL)) {
err = 1;
printf("ODP local init failed.\n");
goto err_local;
}
printf("\n");
printf("ODP system info\n");
printf("---------------\n");
printf("ODP API version: %s\n", odp_version_api_str());
printf("CPU model: %s\n", odp_cpu_model_str());
printf("CPU freq (hz): %"PRIu64"\n", odp_cpu_hz_max());
printf("Cache line size: %i\n", odp_sys_cache_line_size());
printf("Max CPU count: %i\n", odp_cpu_count());
printf("\n");
/* Reserve memory for test_globals_t from shared mem */
shm = odp_shm_reserve("shm_test_globals", sizeof(test_globals_t),
ODP_CACHE_LINE_SIZE, 0);
if (ODP_SHM_INVALID == shm) {
err = 1;
EXAMPLE_ERR("Error: shared mem reserve failed.\n");
goto err;
}
gbls = odp_shm_addr(shm);
if (NULL == gbls) {
err = 1;
EXAMPLE_ERR("Error: shared mem alloc failed.\n");
goto err;
}
memset(gbls, 0, sizeof(test_globals_t));
gbls->pool = ODP_POOL_INVALID;
gbls->tp = ODP_TIMER_POOL_INVALID;
parse_args(argc, argv, &gbls->args);
memset(thread_tbl, 0, sizeof(thread_tbl));
/* Default to system CPU count unless user specified */
num_workers = MAX_WORKERS;
if (gbls->args.cpu_count)
num_workers = gbls->args.cpu_count;
/* Get default worker cpumask */
num_workers = odp_cpumask_default_worker(&cpumask, num_workers);
(void)odp_cpumask_to_str(&cpumask, cpumaskstr, sizeof(cpumaskstr));
printf("num worker threads: %i\n", num_workers);
printf("first CPU: %i\n", odp_cpumask_first(&cpumask));
printf("cpu mask: %s\n", cpumaskstr);
printf("resolution: %i usec\n", gbls->args.resolution_us);
printf("min timeout: %i usec\n", gbls->args.min_us);
printf("max timeout: %i usec\n", gbls->args.max_us);
printf("period: %i usec\n", gbls->args.period_us);
printf("timeouts: %i\n", gbls->args.tmo_count);
/*
* Create pool for timeouts
*/
odp_pool_param_init(¶ms);
params.tmo.num = NUM_TMOS;
params.type = ODP_POOL_TIMEOUT;
gbls->pool = odp_pool_create("msg_pool", ¶ms);
if (gbls->pool == ODP_POOL_INVALID) {
err = 1;
EXAMPLE_ERR("Pool create failed.\n");
goto err;
}
tparams.res_ns = gbls->args.resolution_us * ODP_TIME_USEC_IN_NS;
tparams.min_tmo = gbls->args.min_us * ODP_TIME_USEC_IN_NS;
tparams.max_tmo = gbls->args.max_us * ODP_TIME_USEC_IN_NS;
tparams.num_timers = num_workers; /* One timer per worker */
tparams.priv = 0; /* Shared */
tparams.clk_src = ODP_CLOCK_CPU;
gbls->tp = odp_timer_pool_create("timer_pool", &tparams);
if (gbls->tp == ODP_TIMER_POOL_INVALID) {
err = 1;
EXAMPLE_ERR("Timer pool create failed.\n");
goto err;
}
odp_timer_pool_start();
odp_shm_print_all();
(void)odp_timer_pool_info(gbls->tp, &tpinfo);
printf("Timer pool\n");
printf("----------\n");
printf(" name: %s\n", tpinfo.name);
printf(" resolution: %"PRIu64" ns\n", tpinfo.param.res_ns);
printf(" min tmo: %"PRIu64" ticks\n", tpinfo.param.min_tmo);
printf(" max tmo: %"PRIu64" ticks\n", tpinfo.param.max_tmo);
printf("\n");
/*
* Create a queue for timer test
*/
odp_queue_param_init(¶m);
param.type = ODP_QUEUE_TYPE_SCHED;
param.sched.prio = ODP_SCHED_PRIO_DEFAULT;
param.sched.sync = ODP_SCHED_SYNC_PARALLEL;
param.sched.group = ODP_SCHED_GROUP_ALL;
queue = odp_queue_create("timer_queue", ¶m);
if (queue == ODP_QUEUE_INVALID) {
err = 1;
EXAMPLE_ERR("Timer queue create failed.\n");
goto err;
}
printf("CPU freq %"PRIu64" Hz\n", odp_cpu_hz_max());
printf("Timer ticks vs nanoseconds:\n");
ns = 0;
tick = odp_timer_ns_to_tick(gbls->tp, ns);
printf(" %12" PRIu64 " ns -> %12" PRIu64 " ticks\n", ns, tick);
printf(" %12" PRIu64 " ticks -> %12" PRIu64 " ns\n", tick,
odp_timer_tick_to_ns(gbls->tp, tick));
for (ns = 1; ns <= 100 * ODP_TIME_SEC_IN_NS; ns *= 10) {
tick = odp_timer_ns_to_tick(gbls->tp, ns);
printf(" %12" PRIu64 " ns -> %12" PRIu64 " ticks\n", ns,
tick);
printf(" %12" PRIu64 " ticks -> %12" PRIu64 " ns\n", tick,
odp_timer_tick_to_ns(gbls->tp, tick));
}
printf("\n");
gbls->num_workers = num_workers;
/* Initialize number of timeouts to receive */
odp_atomic_init_u32(&gbls->remain, gbls->args.tmo_count * num_workers);
/* Barrier to sync test case execution */
odp_barrier_init(&gbls->test_barrier, num_workers);
/* Create and launch worker threads */
odph_linux_pthread_create(thread_tbl, &cpumask,
run_thread, gbls, ODP_THREAD_WORKER);
/* Wait for worker threads to exit */
odph_linux_pthread_join(thread_tbl, num_workers);
/* free resources */
if (odp_queue_destroy(queue))
err = 1;
err:
if (gbls != NULL && gbls->tp != ODP_TIMER_POOL_INVALID)
odp_timer_pool_destroy(gbls->tp);
if (gbls != NULL && gbls->pool != ODP_TIMER_POOL_INVALID)
if (odp_pool_destroy(gbls->pool))
err = 1;
if (shm != ODP_SHM_INVALID)
if (odp_shm_free(shm))
err = 1;
if (odp_term_local())
err = 1;
err_local:
if (odp_term_global())
err = 1;
err_global:
if (err) {
printf("Err: ODP timer test failed\n\n");
return -1;
}
printf("ODP timer test complete\n\n");
return 0;
}
