4 * Copyright(c) 2016 Cavium, Inc. All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * * Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in
14 * the documentation and/or other materials provided with the
16 * * Neither the name of Cavium, Inc nor the names of its
17 * contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 #include <rte_common.h>
34 #include <rte_hexdump.h>
36 #include <rte_malloc.h>
37 #include <rte_memcpy.h>
38 #include <rte_eventdev.h>
48 RTE_BUILD_BUG_ON(sizeof(struct rte_event) != 16);
50 count = rte_event_dev_count();
52 printf("Failed to find a valid event device,"
53 " testing with event_skeleton device\n");
54 return rte_vdev_init("event_skeleton", NULL);
60 testsuite_teardown(void)
65 test_eventdev_count(void)
68 count = rte_event_dev_count();
69 TEST_ASSERT(count > 0, "Invalid eventdev count %" PRIu8, count);
74 test_eventdev_get_dev_id(void)
77 ret = rte_event_dev_get_dev_id("not_a_valid_eventdev_driver");
78 TEST_ASSERT_FAIL(ret, "Expected <0 for invalid dev name ret=%d", ret);
83 test_eventdev_socket_id(void)
86 socket_id = rte_event_dev_socket_id(TEST_DEV_ID);
87 TEST_ASSERT(socket_id != -EINVAL, "Failed to get socket_id %d",
89 socket_id = rte_event_dev_socket_id(RTE_EVENT_MAX_DEVS);
90 TEST_ASSERT(socket_id == -EINVAL, "Expected -EINVAL %d", socket_id);
96 test_eventdev_info_get(void)
99 struct rte_event_dev_info info;
100 ret = rte_event_dev_info_get(TEST_DEV_ID, NULL);
101 TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
102 ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
103 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
104 TEST_ASSERT(info.max_event_ports > 0,
105 "Not enough event ports %d", info.max_event_ports);
106 TEST_ASSERT(info.max_event_queues > 0,
107 "Not enough event queues %d", info.max_event_queues);
112 devconf_set_default_sane_values(struct rte_event_dev_config *dev_conf,
113 struct rte_event_dev_info *info)
115 memset(dev_conf, 0, sizeof(struct rte_event_dev_config));
116 dev_conf->dequeue_timeout_ns = info->min_dequeue_timeout_ns;
117 dev_conf->nb_event_ports = info->max_event_ports;
118 dev_conf->nb_event_queues = info->max_event_queues;
119 dev_conf->nb_event_queue_flows = info->max_event_queue_flows;
120 dev_conf->nb_event_port_dequeue_depth =
121 info->max_event_port_dequeue_depth;
122 dev_conf->nb_event_port_enqueue_depth =
123 info->max_event_port_enqueue_depth;
124 dev_conf->nb_event_port_enqueue_depth =
125 info->max_event_port_enqueue_depth;
126 dev_conf->nb_events_limit =
127 info->max_num_events;
131 test_ethdev_config_run(struct rte_event_dev_config *dev_conf,
132 struct rte_event_dev_info *info,
133 void (*fn)(struct rte_event_dev_config *dev_conf,
134 struct rte_event_dev_info *info))
136 devconf_set_default_sane_values(dev_conf, info);
138 return rte_event_dev_configure(TEST_DEV_ID, dev_conf);
142 max_dequeue_limit(struct rte_event_dev_config *dev_conf,
143 struct rte_event_dev_info *info)
145 dev_conf->dequeue_timeout_ns = info->max_dequeue_timeout_ns + 1;
149 max_events_limit(struct rte_event_dev_config *dev_conf,
150 struct rte_event_dev_info *info)
152 dev_conf->nb_events_limit = info->max_num_events + 1;
156 max_event_ports(struct rte_event_dev_config *dev_conf,
157 struct rte_event_dev_info *info)
159 dev_conf->nb_event_ports = info->max_event_ports + 1;
163 max_event_queues(struct rte_event_dev_config *dev_conf,
164 struct rte_event_dev_info *info)
166 dev_conf->nb_event_queues = info->max_event_queues + 1;
170 max_event_queue_flows(struct rte_event_dev_config *dev_conf,
171 struct rte_event_dev_info *info)
173 dev_conf->nb_event_queue_flows = info->max_event_queue_flows + 1;
177 max_event_port_dequeue_depth(struct rte_event_dev_config *dev_conf,
178 struct rte_event_dev_info *info)
180 dev_conf->nb_event_port_dequeue_depth =
181 info->max_event_port_dequeue_depth + 1;
185 max_event_port_enqueue_depth(struct rte_event_dev_config *dev_conf,
186 struct rte_event_dev_info *info)
188 dev_conf->nb_event_port_enqueue_depth =
189 info->max_event_port_enqueue_depth + 1;
194 test_eventdev_configure(void)
197 struct rte_event_dev_config dev_conf;
198 struct rte_event_dev_info info;
199 ret = rte_event_dev_configure(TEST_DEV_ID, NULL);
200 TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
202 ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
203 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
206 TEST_ASSERT_EQUAL(-EINVAL,
207 test_ethdev_config_run(&dev_conf, &info, max_dequeue_limit),
208 "Config negative test failed");
209 TEST_ASSERT_EQUAL(-EINVAL,
210 test_ethdev_config_run(&dev_conf, &info, max_events_limit),
211 "Config negative test failed");
212 TEST_ASSERT_EQUAL(-EINVAL,
213 test_ethdev_config_run(&dev_conf, &info, max_event_ports),
214 "Config negative test failed");
215 TEST_ASSERT_EQUAL(-EINVAL,
216 test_ethdev_config_run(&dev_conf, &info, max_event_queues),
217 "Config negative test failed");
218 TEST_ASSERT_EQUAL(-EINVAL,
219 test_ethdev_config_run(&dev_conf, &info, max_event_queue_flows),
220 "Config negative test failed");
221 TEST_ASSERT_EQUAL(-EINVAL,
222 test_ethdev_config_run(&dev_conf, &info,
223 max_event_port_dequeue_depth),
224 "Config negative test failed");
225 TEST_ASSERT_EQUAL(-EINVAL,
226 test_ethdev_config_run(&dev_conf, &info,
227 max_event_port_enqueue_depth),
228 "Config negative test failed");
231 devconf_set_default_sane_values(&dev_conf, &info);
232 ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
233 TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
236 devconf_set_default_sane_values(&dev_conf, &info);
237 dev_conf.nb_event_ports = RTE_MAX(info.max_event_ports/2, 1);
238 dev_conf.nb_event_queues = RTE_MAX(info.max_event_queues/2, 1);
239 ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
240 TEST_ASSERT_SUCCESS(ret, "Failed to re configure eventdev");
242 /* re-configure back to max_event_queues and max_event_ports */
243 devconf_set_default_sane_values(&dev_conf, &info);
244 ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
245 TEST_ASSERT_SUCCESS(ret, "Failed to re-configure eventdev");
252 eventdev_configure_setup(void)
255 struct rte_event_dev_config dev_conf;
256 struct rte_event_dev_info info;
258 ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
259 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
260 devconf_set_default_sane_values(&dev_conf, &info);
261 ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
262 TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
268 test_eventdev_queue_default_conf_get(void)
271 struct rte_event_queue_conf qconf;
273 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, NULL);
274 TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
276 uint32_t queue_count;
277 TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
278 RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
279 "Queue count get failed");
281 for (i = 0; i < (int)queue_count; i++) {
282 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i,
284 TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d info", i);
291 test_eventdev_queue_setup(void)
294 struct rte_event_dev_info info;
295 struct rte_event_queue_conf qconf;
297 ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
298 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
301 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
302 TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 info");
303 qconf.event_queue_cfg = (RTE_EVENT_QUEUE_CFG_ALL_TYPES &
304 RTE_EVENT_QUEUE_CFG_TYPE_MASK);
305 qconf.nb_atomic_flows = info.max_event_queue_flows + 1;
306 ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
307 TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
309 qconf.nb_atomic_flows = info.max_event_queue_flows;
310 qconf.event_queue_cfg = (RTE_EVENT_QUEUE_CFG_ORDERED_ONLY &
311 RTE_EVENT_QUEUE_CFG_TYPE_MASK);
312 qconf.nb_atomic_order_sequences = info.max_event_queue_flows + 1;
313 ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
314 TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
316 ret = rte_event_queue_setup(TEST_DEV_ID, info.max_event_queues,
318 TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
321 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
322 TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 info");
323 ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
324 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue0");
326 uint32_t queue_count;
327 TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
328 RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
329 "Queue count get failed");
331 for (i = 0; i < (int)queue_count; i++) {
332 ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
333 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
340 test_eventdev_queue_count(void)
343 struct rte_event_dev_info info;
345 ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
346 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
348 uint32_t queue_count;
349 TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
350 RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
351 "Queue count get failed");
352 TEST_ASSERT_EQUAL(queue_count, info.max_event_queues,
353 "Wrong queue count");
359 test_eventdev_queue_attr_priority(void)
362 struct rte_event_dev_info info;
363 struct rte_event_queue_conf qconf;
366 ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
367 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
369 uint32_t queue_count;
370 TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
371 RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
372 "Queue count get failed");
374 for (i = 0; i < (int)queue_count; i++) {
375 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i,
377 TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d def conf", i);
378 qconf.priority = i % RTE_EVENT_DEV_PRIORITY_LOWEST;
379 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
380 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
383 for (i = 0; i < (int)queue_count; i++) {
385 TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
386 RTE_EVENT_QUEUE_ATTR_PRIORITY, &tmp),
387 "Queue priority get failed");
390 if (info.event_dev_cap & RTE_EVENT_DEV_CAP_QUEUE_QOS)
391 TEST_ASSERT_EQUAL(priority,
392 i % RTE_EVENT_DEV_PRIORITY_LOWEST,
393 "Wrong priority value for queue%d", i);
395 TEST_ASSERT_EQUAL(priority,
396 RTE_EVENT_DEV_PRIORITY_NORMAL,
397 "Wrong priority value for queue%d", i);
404 test_eventdev_queue_attr_nb_atomic_flows(void)
407 struct rte_event_dev_info info;
408 struct rte_event_queue_conf qconf;
409 uint32_t nb_atomic_flows;
411 ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
412 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
414 uint32_t queue_count;
415 TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
416 RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
417 "Queue count get failed");
419 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
420 TEST_ASSERT_SUCCESS(ret, "Failed to get queue 0's def conf");
422 if (qconf.nb_atomic_flows == 0)
423 /* Assume PMD doesn't support atomic flows, return early */
426 qconf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_ATOMIC_ONLY;
428 for (i = 0; i < (int)queue_count; i++) {
429 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
430 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
433 for (i = 0; i < (int)queue_count; i++) {
434 TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
435 RTE_EVENT_QUEUE_ATTR_NB_ATOMIC_FLOWS,
437 "Queue nb_atomic_flows get failed");
439 TEST_ASSERT_EQUAL(nb_atomic_flows, qconf.nb_atomic_flows,
440 "Wrong atomic flows value for queue%d", i);
447 test_eventdev_queue_attr_nb_atomic_order_sequences(void)
450 struct rte_event_dev_info info;
451 struct rte_event_queue_conf qconf;
452 uint32_t nb_atomic_order_sequences;
454 ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
455 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
457 uint32_t queue_count;
458 TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
459 RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
460 "Queue count get failed");
462 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
463 TEST_ASSERT_SUCCESS(ret, "Failed to get queue 0's def conf");
465 if (qconf.nb_atomic_order_sequences == 0)
466 /* Assume PMD doesn't support reordering */
469 qconf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_ORDERED_ONLY;
471 for (i = 0; i < (int)queue_count; i++) {
472 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
473 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
476 for (i = 0; i < (int)queue_count; i++) {
477 TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
478 RTE_EVENT_QUEUE_ATTR_NB_ATOMIC_ORDER_SEQUENCES,
479 &nb_atomic_order_sequences),
480 "Queue nb_atomic_order_sequencess get failed");
482 TEST_ASSERT_EQUAL(nb_atomic_order_sequences,
483 qconf.nb_atomic_order_sequences,
484 "Wrong atomic order sequences value for queue%d",
492 test_eventdev_queue_attr_event_queue_cfg(void)
495 struct rte_event_dev_info info;
496 struct rte_event_queue_conf qconf;
497 uint32_t event_queue_cfg;
499 ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
500 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
502 uint32_t queue_count;
503 TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
504 RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
505 "Queue count get failed");
507 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
508 TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 def conf");
510 qconf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_PARALLEL_ONLY;
512 for (i = 0; i < (int)queue_count; i++) {
513 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
514 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
517 for (i = 0; i < (int)queue_count; i++) {
518 TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
519 RTE_EVENT_QUEUE_ATTR_EVENT_QUEUE_CFG,
521 "Queue event_queue_cfg get failed");
523 TEST_ASSERT_EQUAL(event_queue_cfg, qconf.event_queue_cfg,
524 "Wrong event_queue_cfg value for queue%d",
532 test_eventdev_port_default_conf_get(void)
535 struct rte_event_port_conf pconf;
537 ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, NULL);
538 TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
541 TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
542 RTE_EVENT_DEV_ATTR_PORT_COUNT,
543 &port_count), "Port count get failed");
545 ret = rte_event_port_default_conf_get(TEST_DEV_ID,
546 port_count + 1, NULL);
547 TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
549 for (i = 0; i < (int)port_count; i++) {
550 ret = rte_event_port_default_conf_get(TEST_DEV_ID, i,
552 TEST_ASSERT_SUCCESS(ret, "Failed to get port%d info", i);
559 test_eventdev_port_setup(void)
562 struct rte_event_dev_info info;
563 struct rte_event_port_conf pconf;
565 ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
566 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
569 ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
570 TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
571 pconf.new_event_threshold = info.max_num_events + 1;
572 ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
573 TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
575 pconf.new_event_threshold = info.max_num_events;
576 pconf.dequeue_depth = info.max_event_port_dequeue_depth + 1;
577 ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
578 TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
580 pconf.dequeue_depth = info.max_event_port_dequeue_depth;
581 pconf.enqueue_depth = info.max_event_port_enqueue_depth + 1;
582 ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
583 TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
585 ret = rte_event_port_setup(TEST_DEV_ID, info.max_event_ports,
587 TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
590 ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
591 TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
592 ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
593 TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
596 TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
597 RTE_EVENT_DEV_ATTR_PORT_COUNT,
598 &port_count), "Port count get failed");
600 for (i = 0; i < (int)port_count; i++) {
601 ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
602 TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
609 test_eventdev_port_attr_dequeue_depth(void)
612 struct rte_event_dev_info info;
613 struct rte_event_port_conf pconf;
615 ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
616 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
618 ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
619 TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
620 ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
621 TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
624 TEST_ASSERT_EQUAL(rte_event_port_attr_get(TEST_DEV_ID, 0,
625 RTE_EVENT_PORT_ATTR_DEQ_DEPTH, &value),
626 0, "Call to get port dequeue depth failed");
627 TEST_ASSERT_EQUAL(value, pconf.dequeue_depth,
628 "Wrong port dequeue depth");
634 test_eventdev_port_attr_enqueue_depth(void)
637 struct rte_event_dev_info info;
638 struct rte_event_port_conf pconf;
640 ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
641 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
643 ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
644 TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
645 ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
646 TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
649 TEST_ASSERT_EQUAL(rte_event_port_attr_get(TEST_DEV_ID, 0,
650 RTE_EVENT_PORT_ATTR_ENQ_DEPTH, &value),
651 0, "Call to get port enqueue depth failed");
652 TEST_ASSERT_EQUAL(value, pconf.enqueue_depth,
653 "Wrong port enqueue depth");
659 test_eventdev_port_attr_new_event_threshold(void)
662 struct rte_event_dev_info info;
663 struct rte_event_port_conf pconf;
665 ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
666 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
668 ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
669 TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
670 ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
671 TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
674 TEST_ASSERT_EQUAL(rte_event_port_attr_get(TEST_DEV_ID, 0,
675 RTE_EVENT_PORT_ATTR_NEW_EVENT_THRESHOLD, &value),
676 0, "Call to get port new event threshold failed");
677 TEST_ASSERT_EQUAL((int32_t) value, pconf.new_event_threshold,
678 "Wrong port new event threshold");
684 test_eventdev_port_count(void)
687 struct rte_event_dev_info info;
689 ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
690 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
693 TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
694 RTE_EVENT_DEV_ATTR_PORT_COUNT,
695 &port_count), "Port count get failed");
696 TEST_ASSERT_EQUAL(port_count, info.max_event_ports, "Wrong port count");
702 test_eventdev_timeout_ticks(void)
705 uint64_t timeout_ticks;
707 ret = rte_event_dequeue_timeout_ticks(TEST_DEV_ID, 100, &timeout_ticks);
709 TEST_ASSERT_SUCCESS(ret, "Fail to get timeout_ticks");
716 test_eventdev_start_stop(void)
720 ret = eventdev_configure_setup();
721 TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
723 uint32_t queue_count;
724 TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
725 RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
726 "Queue count get failed");
727 for (i = 0; i < (int)queue_count; i++) {
728 ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
729 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
733 TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
734 RTE_EVENT_DEV_ATTR_PORT_COUNT,
735 &port_count), "Port count get failed");
737 for (i = 0; i < (int)port_count; i++) {
738 ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
739 TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
742 ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
743 TEST_ASSERT(ret == (int)queue_count, "Failed to link port, device %d",
746 ret = rte_event_dev_start(TEST_DEV_ID);
747 TEST_ASSERT_SUCCESS(ret, "Failed to start device%d", TEST_DEV_ID);
749 rte_event_dev_stop(TEST_DEV_ID);
755 eventdev_setup_device(void)
759 ret = eventdev_configure_setup();
760 TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
762 uint32_t queue_count;
763 TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
764 RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
765 "Queue count get failed");
766 for (i = 0; i < (int)queue_count; i++) {
767 ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
768 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
772 TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
773 RTE_EVENT_DEV_ATTR_PORT_COUNT,
774 &port_count), "Port count get failed");
776 for (i = 0; i < (int)port_count; i++) {
777 ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
778 TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
781 ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
782 TEST_ASSERT(ret == (int)queue_count, "Failed to link port, device %d",
785 ret = rte_event_dev_start(TEST_DEV_ID);
786 TEST_ASSERT_SUCCESS(ret, "Failed to start device%d", TEST_DEV_ID);
792 eventdev_stop_device(void)
794 rte_event_dev_stop(TEST_DEV_ID);
798 test_eventdev_link(void)
800 int ret, nb_queues, i;
801 uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
802 uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV];
804 ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
805 TEST_ASSERT(ret >= 0, "Failed to link with NULL device%d",
808 uint32_t queue_count;
809 TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
810 RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
811 "Queue count get failed");
812 nb_queues = queue_count;
813 for (i = 0; i < nb_queues; i++) {
815 priorities[i] = RTE_EVENT_DEV_PRIORITY_NORMAL;
818 ret = rte_event_port_link(TEST_DEV_ID, 0, queues,
819 priorities, nb_queues);
820 TEST_ASSERT(ret == nb_queues, "Failed to link(device%d) ret=%d",
826 test_eventdev_unlink(void)
828 int ret, nb_queues, i;
829 uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
831 ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
832 TEST_ASSERT(ret >= 0, "Failed to unlink with NULL device%d",
835 uint32_t queue_count;
836 TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
837 RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
838 "Queue count get failed");
839 nb_queues = queue_count;
840 for (i = 0; i < nb_queues; i++)
844 ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, nb_queues);
845 TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
851 test_eventdev_link_get(void)
854 uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
855 uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV];
857 /* link all queues */
858 ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
859 TEST_ASSERT(ret >= 0, "Failed to link with NULL device%d",
862 uint32_t queue_count;
863 TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
864 RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
865 "Queue count get failed");
866 const int nb_queues = queue_count;
867 for (i = 0; i < nb_queues; i++)
870 ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, nb_queues);
871 TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
874 ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
875 TEST_ASSERT(ret == 0, "(%d)Wrong link get=%d", TEST_DEV_ID, ret);
877 /* link all queues and get the links */
878 for (i = 0; i < nb_queues; i++) {
880 priorities[i] = RTE_EVENT_DEV_PRIORITY_NORMAL;
882 ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities,
884 TEST_ASSERT(ret == nb_queues, "Failed to link(device%d) ret=%d",
886 ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
887 TEST_ASSERT(ret == nb_queues, "(%d)Wrong link get ret=%d expected=%d",
888 TEST_DEV_ID, ret, nb_queues);
890 ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
891 TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
893 /* link just one queue */
895 priorities[0] = RTE_EVENT_DEV_PRIORITY_NORMAL;
897 ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities, 1);
898 TEST_ASSERT(ret == 1, "Failed to link(device%d) ret=%d",
900 ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
901 TEST_ASSERT(ret == 1, "(%d)Wrong link get ret=%d expected=%d",
902 TEST_DEV_ID, ret, 1);
904 ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
905 TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
908 /* 4links and 2 unlinks */
909 if (nb_queues >= 4) {
910 for (i = 0; i < 4; i++) {
912 priorities[i] = 0x40;
914 ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities,
916 TEST_ASSERT(ret == 4, "Failed to link(device%d) ret=%d",
919 for (i = 0; i < 2; i++)
922 ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, 2);
923 TEST_ASSERT(ret == 2, "Failed to unlink(device%d) ret=%d",
925 ret = rte_event_port_links_get(TEST_DEV_ID, 0,
927 TEST_ASSERT(ret == 2, "(%d)Wrong link get ret=%d expected=%d",
928 TEST_DEV_ID, ret, 2);
929 TEST_ASSERT(queues[0] == 2, "ret=%d expected=%d", ret, 2);
930 TEST_ASSERT(priorities[0] == 0x40, "ret=%d expected=%d",
932 TEST_ASSERT(queues[1] == 3, "ret=%d expected=%d", ret, 3);
933 TEST_ASSERT(priorities[1] == 0x40, "ret=%d expected=%d",
941 test_eventdev_close(void)
943 rte_event_dev_stop(TEST_DEV_ID);
944 return rte_event_dev_close(TEST_DEV_ID);
947 static struct unit_test_suite eventdev_common_testsuite = {
948 .suite_name = "eventdev common code unit test suite",
949 .setup = testsuite_setup,
950 .teardown = testsuite_teardown,
952 TEST_CASE_ST(NULL, NULL,
953 test_eventdev_count),
954 TEST_CASE_ST(NULL, NULL,
955 test_eventdev_get_dev_id),
956 TEST_CASE_ST(NULL, NULL,
957 test_eventdev_socket_id),
958 TEST_CASE_ST(NULL, NULL,
959 test_eventdev_info_get),
960 TEST_CASE_ST(NULL, NULL,
961 test_eventdev_configure),
962 TEST_CASE_ST(eventdev_configure_setup, NULL,
963 test_eventdev_queue_default_conf_get),
964 TEST_CASE_ST(eventdev_configure_setup, NULL,
965 test_eventdev_queue_setup),
966 TEST_CASE_ST(eventdev_configure_setup, NULL,
967 test_eventdev_queue_count),
968 TEST_CASE_ST(eventdev_configure_setup, NULL,
969 test_eventdev_queue_attr_priority),
970 TEST_CASE_ST(eventdev_configure_setup, NULL,
971 test_eventdev_queue_attr_nb_atomic_flows),
972 TEST_CASE_ST(eventdev_configure_setup, NULL,
973 test_eventdev_queue_attr_nb_atomic_order_sequences),
974 TEST_CASE_ST(eventdev_configure_setup, NULL,
975 test_eventdev_queue_attr_event_queue_cfg),
976 TEST_CASE_ST(eventdev_configure_setup, NULL,
977 test_eventdev_port_default_conf_get),
978 TEST_CASE_ST(eventdev_configure_setup, NULL,
979 test_eventdev_port_setup),
980 TEST_CASE_ST(eventdev_configure_setup, NULL,
981 test_eventdev_port_attr_dequeue_depth),
982 TEST_CASE_ST(eventdev_configure_setup, NULL,
983 test_eventdev_port_attr_enqueue_depth),
984 TEST_CASE_ST(eventdev_configure_setup, NULL,
985 test_eventdev_port_attr_new_event_threshold),
986 TEST_CASE_ST(eventdev_configure_setup, NULL,
987 test_eventdev_port_count),
988 TEST_CASE_ST(eventdev_configure_setup, NULL,
989 test_eventdev_timeout_ticks),
990 TEST_CASE_ST(NULL, NULL,
991 test_eventdev_start_stop),
992 TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
994 TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
995 test_eventdev_unlink),
996 TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
997 test_eventdev_link_get),
998 TEST_CASE_ST(eventdev_setup_device, NULL,
999 test_eventdev_close),
1000 TEST_CASES_END() /**< NULL terminate unit test array */
1005 test_eventdev_common(void)
1007 return unit_test_suite_runner(&eventdev_common_testsuite);
1010 REGISTER_TEST_COMMAND(eventdev_common_autotest, test_eventdev_common);