void queue_test_info(void)
{
odp_queue_t q_plain, q_order;
const char *const nq_plain = "test_q_plain";
const char *const nq_order = "test_q_order";
odp_queue_info_t info;
odp_queue_param_t param;
char q_plain_ctx[] = "test_q_plain context data";
char q_order_ctx[] = "test_q_order context data";
unsigned lock_count;
char *ctx;
int ret;
/* Create a plain queue and set context */
q_plain = odp_queue_create(nq_plain, NULL);
CU_ASSERT(ODP_QUEUE_INVALID != q_plain);
CU_ASSERT(odp_queue_context_set(q_plain, q_plain_ctx,
sizeof(q_plain_ctx)) == 0);
/* Create a scheduled ordered queue with explicitly set params */
odp_queue_param_init(¶m);
param.type = ODP_QUEUE_TYPE_SCHED;
param.sched.prio = ODP_SCHED_PRIO_NORMAL;
param.sched.sync = ODP_SCHED_SYNC_ORDERED;
param.sched.group = ODP_SCHED_GROUP_ALL;
param.sched.lock_count = 1;
param.context = q_order_ctx;
q_order = odp_queue_create(nq_order, ¶m);
CU_ASSERT(ODP_QUEUE_INVALID != q_order);
/* Check info for the plain queue */
CU_ASSERT(odp_queue_info(q_plain, &info) == 0);
CU_ASSERT(strcmp(nq_plain, info.name) == 0);
CU_ASSERT(info.param.type == ODP_QUEUE_TYPE_PLAIN);
CU_ASSERT(info.param.type == odp_queue_type(q_plain));
ctx = info.param.context; /* 'char' context ptr */
CU_ASSERT(ctx == q_plain_ctx);
CU_ASSERT(info.param.context == odp_queue_context(q_plain));
/* Check info for the scheduled ordered queue */
CU_ASSERT(odp_queue_info(q_order, &info) == 0);
CU_ASSERT(strcmp(nq_order, info.name) == 0);
CU_ASSERT(info.param.type == ODP_QUEUE_TYPE_SCHED);
CU_ASSERT(info.param.type == odp_queue_type(q_order));
ctx = info.param.context; /* 'char' context ptr */
CU_ASSERT(ctx == q_order_ctx);
CU_ASSERT(info.param.context == odp_queue_context(q_order));
CU_ASSERT(info.param.sched.prio == odp_queue_sched_prio(q_order));
CU_ASSERT(info.param.sched.sync == odp_queue_sched_type(q_order));
CU_ASSERT(info.param.sched.group == odp_queue_sched_group(q_order));
ret = odp_queue_lock_count(q_order);
CU_ASSERT(ret >= 0);
lock_count = (unsigned)ret;
CU_ASSERT(info.param.sched.lock_count == lock_count);
CU_ASSERT(odp_queue_destroy(q_plain) == 0);
CU_ASSERT(odp_queue_destroy(q_order) == 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);
}
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 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);
}
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);
}
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);
}
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;
}
