1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2017 Cavium, Inc
5 #include <rte_atomic.h>
6 #include <rte_common.h>
7 #include <rte_cycles.h>
10 #include <rte_ethdev.h>
11 #include <rte_eventdev.h>
12 #include <rte_hexdump.h>
14 #include <rte_malloc.h>
15 #include <rte_memcpy.h>
16 #include <rte_launch.h>
17 #include <rte_lcore.h>
18 #include <rte_per_lcore.h>
19 #include <rte_random.h>
20 #include <rte_bus_vdev.h>
23 #include "ssovf_evdev.h"
25 #define NUM_PACKETS (1 << 18)
26 #define MAX_EVENTS (16 * 1024)
28 #define OCTEONTX_TEST_RUN(setup, teardown, test) \
29 octeontx_test_run(setup, teardown, test, #test)
34 static int unsupported;
37 static struct rte_mempool *eventdev_test_mempool;
42 uint8_t sub_event_type;
48 static uint32_t seqn_list_index;
49 static int seqn_list[NUM_PACKETS];
54 RTE_BUILD_BUG_ON(NUM_PACKETS < MAX_EVENTS);
55 memset(seqn_list, 0, sizeof(seqn_list));
60 seqn_list_update(int val)
62 if (seqn_list_index >= NUM_PACKETS)
65 seqn_list[seqn_list_index++] = val;
71 seqn_list_check(int limit)
75 for (i = 0; i < limit; i++) {
76 if (seqn_list[i] != i) {
77 ssovf_log_dbg("Seqn mismatch %d %d", seqn_list[i], i);
84 struct test_core_param {
85 rte_atomic32_t *total_events;
86 uint64_t dequeue_tmo_ticks;
94 const char *eventdev_name = "event_octeontx";
96 evdev = rte_event_dev_get_dev_id(eventdev_name);
98 ssovf_log_dbg("%d: Eventdev %s not found - creating.",
99 __LINE__, eventdev_name);
100 if (rte_vdev_init(eventdev_name, NULL) < 0) {
101 ssovf_log_dbg("Error creating eventdev %s",
105 evdev = rte_event_dev_get_dev_id(eventdev_name);
107 ssovf_log_dbg("Error finding newly created eventdev");
116 testsuite_teardown(void)
118 rte_event_dev_close(evdev);
122 devconf_set_default_sane_values(struct rte_event_dev_config *dev_conf,
123 struct rte_event_dev_info *info)
125 memset(dev_conf, 0, sizeof(struct rte_event_dev_config));
126 dev_conf->dequeue_timeout_ns = info->min_dequeue_timeout_ns;
127 dev_conf->nb_event_ports = info->max_event_ports;
128 dev_conf->nb_event_queues = info->max_event_queues;
129 dev_conf->nb_event_queue_flows = info->max_event_queue_flows;
130 dev_conf->nb_event_port_dequeue_depth =
131 info->max_event_port_dequeue_depth;
132 dev_conf->nb_event_port_enqueue_depth =
133 info->max_event_port_enqueue_depth;
134 dev_conf->nb_event_port_enqueue_depth =
135 info->max_event_port_enqueue_depth;
136 dev_conf->nb_events_limit =
137 info->max_num_events;
141 TEST_EVENTDEV_SETUP_DEFAULT,
142 TEST_EVENTDEV_SETUP_PRIORITY,
143 TEST_EVENTDEV_SETUP_DEQUEUE_TIMEOUT,
147 _eventdev_setup(int mode)
150 struct rte_event_dev_config dev_conf;
151 struct rte_event_dev_info info;
152 const char *pool_name = "evdev_octeontx_test_pool";
154 /* Create and destrory pool for each test case to make it standalone */
155 eventdev_test_mempool = rte_pktmbuf_pool_create(pool_name,
157 0 /*MBUF_CACHE_SIZE*/,
159 512, /* Use very small mbufs */
161 if (!eventdev_test_mempool) {
162 ssovf_log_dbg("ERROR creating mempool");
166 ret = rte_event_dev_info_get(evdev, &info);
167 RTE_TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
168 RTE_TEST_ASSERT(info.max_num_events >= (int32_t)MAX_EVENTS,
169 "ERROR max_num_events=%d < max_events=%d",
170 info.max_num_events, MAX_EVENTS);
172 devconf_set_default_sane_values(&dev_conf, &info);
173 if (mode == TEST_EVENTDEV_SETUP_DEQUEUE_TIMEOUT)
174 dev_conf.event_dev_cfg |= RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
176 ret = rte_event_dev_configure(evdev, &dev_conf);
177 RTE_TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
179 uint32_t queue_count;
180 RTE_TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
181 RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
182 &queue_count), "Queue count get failed");
184 if (mode == TEST_EVENTDEV_SETUP_PRIORITY) {
185 if (queue_count > 8) {
187 "test expects the unique priority per queue");
191 /* Configure event queues(0 to n) with
192 * RTE_EVENT_DEV_PRIORITY_HIGHEST to
193 * RTE_EVENT_DEV_PRIORITY_LOWEST
195 uint8_t step = (RTE_EVENT_DEV_PRIORITY_LOWEST + 1) /
197 for (i = 0; i < (int)queue_count; i++) {
198 struct rte_event_queue_conf queue_conf;
200 ret = rte_event_queue_default_conf_get(evdev, i,
202 RTE_TEST_ASSERT_SUCCESS(ret, "Failed to get def_conf%d",
204 queue_conf.priority = i * step;
205 ret = rte_event_queue_setup(evdev, i, &queue_conf);
206 RTE_TEST_ASSERT_SUCCESS(ret, "Failed to setup queue=%d",
211 /* Configure event queues with default priority */
212 for (i = 0; i < (int)queue_count; i++) {
213 ret = rte_event_queue_setup(evdev, i, NULL);
214 RTE_TEST_ASSERT_SUCCESS(ret, "Failed to setup queue=%d",
218 /* Configure event ports */
220 RTE_TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
221 RTE_EVENT_DEV_ATTR_PORT_COUNT,
222 &port_count), "Port count get failed");
223 for (i = 0; i < (int)port_count; i++) {
224 ret = rte_event_port_setup(evdev, i, NULL);
225 RTE_TEST_ASSERT_SUCCESS(ret, "Failed to setup port=%d", i);
226 ret = rte_event_port_link(evdev, i, NULL, NULL, 0);
227 RTE_TEST_ASSERT(ret >= 0, "Failed to link all queues port=%d",
231 ret = rte_event_dev_start(evdev);
232 RTE_TEST_ASSERT_SUCCESS(ret, "Failed to start device");
240 return _eventdev_setup(TEST_EVENTDEV_SETUP_DEFAULT);
244 eventdev_setup_priority(void)
246 return _eventdev_setup(TEST_EVENTDEV_SETUP_PRIORITY);
250 eventdev_setup_dequeue_timeout(void)
252 return _eventdev_setup(TEST_EVENTDEV_SETUP_DEQUEUE_TIMEOUT);
256 eventdev_teardown(void)
258 rte_event_dev_stop(evdev);
259 rte_mempool_free(eventdev_test_mempool);
263 update_event_and_validation_attr(struct rte_mbuf *m, struct rte_event *ev,
264 uint32_t flow_id, uint8_t event_type,
265 uint8_t sub_event_type, uint8_t sched_type,
266 uint8_t queue, uint8_t port)
268 struct event_attr *attr;
270 /* Store the event attributes in mbuf for future reference */
271 attr = rte_pktmbuf_mtod(m, struct event_attr *);
272 attr->flow_id = flow_id;
273 attr->event_type = event_type;
274 attr->sub_event_type = sub_event_type;
275 attr->sched_type = sched_type;
279 ev->flow_id = flow_id;
280 ev->sub_event_type = sub_event_type;
281 ev->event_type = event_type;
282 /* Inject the new event */
283 ev->op = RTE_EVENT_OP_NEW;
284 ev->sched_type = sched_type;
285 ev->queue_id = queue;
290 inject_events(uint32_t flow_id, uint8_t event_type, uint8_t sub_event_type,
291 uint8_t sched_type, uint8_t queue, uint8_t port,
297 for (i = 0; i < events; i++) {
298 struct rte_event ev = {.event = 0, .u64 = 0};
300 m = rte_pktmbuf_alloc(eventdev_test_mempool);
301 RTE_TEST_ASSERT_NOT_NULL(m, "mempool alloc failed");
304 update_event_and_validation_attr(m, &ev, flow_id, event_type,
305 sub_event_type, sched_type, queue, port);
306 rte_event_enqueue_burst(evdev, port, &ev, 1);
312 check_excess_events(uint8_t port)
315 uint16_t valid_event;
318 /* Check for excess events, try for a few times and exit */
319 for (i = 0; i < 32; i++) {
320 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1, 0);
322 RTE_TEST_ASSERT_SUCCESS(valid_event,
323 "Unexpected valid event=%d", ev.mbuf->seqn);
329 generate_random_events(const unsigned int total_events)
331 struct rte_event_dev_info info;
335 uint32_t queue_count;
336 RTE_TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
337 RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
338 &queue_count), "Queue count get failed");
340 ret = rte_event_dev_info_get(evdev, &info);
341 RTE_TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
342 for (i = 0; i < total_events; i++) {
344 rte_rand() % info.max_event_queue_flows /*flow_id */,
345 RTE_EVENT_TYPE_CPU /* event_type */,
346 rte_rand() % 256 /* sub_event_type */,
347 rte_rand() % (RTE_SCHED_TYPE_PARALLEL + 1),
348 rte_rand() % queue_count /* queue */,
359 validate_event(struct rte_event *ev)
361 struct event_attr *attr;
363 attr = rte_pktmbuf_mtod(ev->mbuf, struct event_attr *);
364 RTE_TEST_ASSERT_EQUAL(attr->flow_id, ev->flow_id,
365 "flow_id mismatch enq=%d deq =%d",
366 attr->flow_id, ev->flow_id);
367 RTE_TEST_ASSERT_EQUAL(attr->event_type, ev->event_type,
368 "event_type mismatch enq=%d deq =%d",
369 attr->event_type, ev->event_type);
370 RTE_TEST_ASSERT_EQUAL(attr->sub_event_type, ev->sub_event_type,
371 "sub_event_type mismatch enq=%d deq =%d",
372 attr->sub_event_type, ev->sub_event_type);
373 RTE_TEST_ASSERT_EQUAL(attr->sched_type, ev->sched_type,
374 "sched_type mismatch enq=%d deq =%d",
375 attr->sched_type, ev->sched_type);
376 RTE_TEST_ASSERT_EQUAL(attr->queue, ev->queue_id,
377 "queue mismatch enq=%d deq =%d",
378 attr->queue, ev->queue_id);
382 typedef int (*validate_event_cb)(uint32_t index, uint8_t port,
383 struct rte_event *ev);
386 consume_events(uint8_t port, const uint32_t total_events, validate_event_cb fn)
389 uint16_t valid_event;
390 uint32_t events = 0, forward_progress_cnt = 0, index = 0;
394 if (++forward_progress_cnt > UINT16_MAX) {
395 ssovf_log_dbg("Detected deadlock");
399 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1, 0);
403 forward_progress_cnt = 0;
404 ret = validate_event(&ev);
409 ret = fn(index, port, &ev);
410 RTE_TEST_ASSERT_SUCCESS(ret,
411 "Failed to validate test specific event");
416 rte_pktmbuf_free(ev.mbuf);
417 if (++events >= total_events)
421 return check_excess_events(port);
425 validate_simple_enqdeq(uint32_t index, uint8_t port, struct rte_event *ev)
428 RTE_TEST_ASSERT_EQUAL(index, ev->mbuf->seqn, "index=%d != seqn=%d",
429 index, ev->mbuf->seqn);
434 test_simple_enqdeq(uint8_t sched_type)
438 ret = inject_events(0 /*flow_id */,
439 RTE_EVENT_TYPE_CPU /* event_type */,
440 0 /* sub_event_type */,
448 return consume_events(0 /* port */, MAX_EVENTS, validate_simple_enqdeq);
452 test_simple_enqdeq_ordered(void)
454 return test_simple_enqdeq(RTE_SCHED_TYPE_ORDERED);
458 test_simple_enqdeq_atomic(void)
460 return test_simple_enqdeq(RTE_SCHED_TYPE_ATOMIC);
464 test_simple_enqdeq_parallel(void)
466 return test_simple_enqdeq(RTE_SCHED_TYPE_PARALLEL);
470 * Generate a prescribed number of events and spread them across available
471 * queues. On dequeue, using single event port(port 0) verify the enqueued
475 test_multi_queue_enq_single_port_deq(void)
479 ret = generate_random_events(MAX_EVENTS);
483 return consume_events(0 /* port */, MAX_EVENTS, NULL);
487 * Inject 0..MAX_EVENTS events over 0..queue_count with modulus
490 * For example, Inject 32 events over 0..7 queues
491 * enqueue events 0, 8, 16, 24 in queue 0
492 * enqueue events 1, 9, 17, 25 in queue 1
495 * enqueue events 7, 15, 23, 31 in queue 7
497 * On dequeue, Validate the events comes in 0,8,16,24,1,9,17,25..,7,15,23,31
498 * order from queue0(highest priority) to queue7(lowest_priority)
501 validate_queue_priority(uint32_t index, uint8_t port, struct rte_event *ev)
503 uint32_t queue_count;
504 RTE_TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
505 RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
506 &queue_count), "Queue count get failed");
507 uint32_t range = MAX_EVENTS / queue_count;
508 uint32_t expected_val = (index % range) * queue_count;
510 expected_val += ev->queue_id;
512 RTE_TEST_ASSERT_EQUAL(ev->mbuf->seqn, expected_val,
513 "seqn=%d index=%d expected=%d range=%d nb_queues=%d max_event=%d",
514 ev->mbuf->seqn, index, expected_val, range,
515 queue_count, MAX_EVENTS);
520 test_multi_queue_priority(void)
524 int i, max_evts_roundoff;
526 /* See validate_queue_priority() comments for priority validate logic */
527 uint32_t queue_count;
528 RTE_TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
529 RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
530 &queue_count), "Queue count get failed");
531 max_evts_roundoff = MAX_EVENTS / queue_count;
532 max_evts_roundoff *= queue_count;
534 for (i = 0; i < max_evts_roundoff; i++) {
535 struct rte_event ev = {.event = 0, .u64 = 0};
537 m = rte_pktmbuf_alloc(eventdev_test_mempool);
538 RTE_TEST_ASSERT_NOT_NULL(m, "mempool alloc failed");
541 queue = i % queue_count;
542 update_event_and_validation_attr(m, &ev, 0, RTE_EVENT_TYPE_CPU,
543 0, RTE_SCHED_TYPE_PARALLEL, queue, 0);
544 rte_event_enqueue_burst(evdev, 0, &ev, 1);
547 return consume_events(0, max_evts_roundoff, validate_queue_priority);
551 worker_multi_port_fn(void *arg)
553 struct test_core_param *param = arg;
555 uint16_t valid_event;
556 uint8_t port = param->port;
557 rte_atomic32_t *total_events = param->total_events;
560 while (rte_atomic32_read(total_events) > 0) {
561 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1, 0);
565 ret = validate_event(&ev);
566 RTE_TEST_ASSERT_SUCCESS(ret, "Failed to validate event");
567 rte_pktmbuf_free(ev.mbuf);
568 rte_atomic32_sub(total_events, 1);
574 wait_workers_to_join(int lcore, const rte_atomic32_t *count)
576 uint64_t cycles, print_cycles;
579 print_cycles = cycles = rte_get_timer_cycles();
580 while (rte_eal_get_lcore_state(lcore) != FINISHED) {
581 uint64_t new_cycles = rte_get_timer_cycles();
583 if (new_cycles - print_cycles > rte_get_timer_hz()) {
584 ssovf_log_dbg("\r%s: events %d", __func__,
585 rte_atomic32_read(count));
586 print_cycles = new_cycles;
588 if (new_cycles - cycles > rte_get_timer_hz() * 10) {
590 "%s: No schedules for seconds, deadlock (%d)",
592 rte_atomic32_read(count));
593 rte_event_dev_dump(evdev, stdout);
598 rte_eal_mp_wait_lcore();
604 launch_workers_and_wait(int (*master_worker)(void *),
605 int (*slave_workers)(void *), uint32_t total_events,
606 uint8_t nb_workers, uint8_t sched_type)
611 struct test_core_param *param;
612 rte_atomic32_t atomic_total_events;
613 uint64_t dequeue_tmo_ticks;
618 rte_atomic32_set(&atomic_total_events, total_events);
621 param = malloc(sizeof(struct test_core_param) * nb_workers);
625 ret = rte_event_dequeue_timeout_ticks(evdev,
626 rte_rand() % 10000000/* 10ms */, &dequeue_tmo_ticks);
632 param[0].total_events = &atomic_total_events;
633 param[0].sched_type = sched_type;
635 param[0].dequeue_tmo_ticks = dequeue_tmo_ticks;
638 w_lcore = rte_get_next_lcore(
642 rte_eal_remote_launch(master_worker, ¶m[0], w_lcore);
644 for (port = 1; port < nb_workers; port++) {
645 param[port].total_events = &atomic_total_events;
646 param[port].sched_type = sched_type;
647 param[port].port = port;
648 param[port].dequeue_tmo_ticks = dequeue_tmo_ticks;
650 w_lcore = rte_get_next_lcore(w_lcore, 1, 0);
651 rte_eal_remote_launch(slave_workers, ¶m[port], w_lcore);
654 ret = wait_workers_to_join(w_lcore, &atomic_total_events);
660 * Generate a prescribed number of events and spread them across available
661 * queues. Dequeue the events through multiple ports and verify the enqueued
665 test_multi_queue_enq_multi_port_deq(void)
667 const unsigned int total_events = MAX_EVENTS;
671 ret = generate_random_events(total_events);
675 RTE_TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
676 RTE_EVENT_DEV_ATTR_PORT_COUNT,
677 &nr_ports), "Port count get failed");
678 nr_ports = RTE_MIN(nr_ports, rte_lcore_count() - 1);
681 ssovf_log_dbg("%s: Not enough ports=%d or workers=%d", __func__,
682 nr_ports, rte_lcore_count() - 1);
686 return launch_workers_and_wait(worker_multi_port_fn,
687 worker_multi_port_fn, total_events,
688 nr_ports, 0xff /* invalid */);
692 validate_queue_to_port_single_link(uint32_t index, uint8_t port,
693 struct rte_event *ev)
696 RTE_TEST_ASSERT_EQUAL(port, ev->queue_id,
697 "queue mismatch enq=%d deq =%d",
703 * Link queue x to port x and check correctness of link by checking
704 * queue_id == x on dequeue on the specific port x
707 test_queue_to_port_single_link(void)
709 int i, nr_links, ret;
712 RTE_TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
713 RTE_EVENT_DEV_ATTR_PORT_COUNT,
714 &port_count), "Port count get failed");
716 /* Unlink all connections that created in eventdev_setup */
717 for (i = 0; i < (int)port_count; i++) {
718 ret = rte_event_port_unlink(evdev, i, NULL, 0);
719 RTE_TEST_ASSERT(ret >= 0,
720 "Failed to unlink all queues port=%d", i);
723 uint32_t queue_count;
724 RTE_TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
725 RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
726 &queue_count), "Queue count get failed");
728 nr_links = RTE_MIN(port_count, queue_count);
729 const unsigned int total_events = MAX_EVENTS / nr_links;
731 /* Link queue x to port x and inject events to queue x through port x */
732 for (i = 0; i < nr_links; i++) {
733 uint8_t queue = (uint8_t)i;
735 ret = rte_event_port_link(evdev, i, &queue, NULL, 1);
736 RTE_TEST_ASSERT(ret == 1, "Failed to link queue to port %d", i);
740 RTE_EVENT_TYPE_CPU /* event_type */,
741 rte_rand() % 256 /* sub_event_type */,
742 rte_rand() % (RTE_SCHED_TYPE_PARALLEL + 1),
745 total_events /* events */);
750 /* Verify the events generated from correct queue */
751 for (i = 0; i < nr_links; i++) {
752 ret = consume_events(i /* port */, total_events,
753 validate_queue_to_port_single_link);
762 validate_queue_to_port_multi_link(uint32_t index, uint8_t port,
763 struct rte_event *ev)
766 RTE_TEST_ASSERT_EQUAL(port, (ev->queue_id & 0x1),
767 "queue mismatch enq=%d deq =%d",
773 * Link all even number of queues to port 0 and all odd number of queues to
774 * port 1 and verify the link connection on dequeue
777 test_queue_to_port_multi_link(void)
779 int ret, port0_events = 0, port1_events = 0;
781 uint32_t nr_queues = 0;
782 uint32_t nr_ports = 0;
784 RTE_TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
785 RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
786 &nr_queues), "Queue count get failed");
788 RTE_TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
789 RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
790 &nr_queues), "Queue count get failed");
791 RTE_TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
792 RTE_EVENT_DEV_ATTR_PORT_COUNT,
793 &nr_ports), "Port count get failed");
796 ssovf_log_dbg("%s: Not enough ports to test ports=%d",
801 /* Unlink all connections that created in eventdev_setup */
802 for (port = 0; port < nr_ports; port++) {
803 ret = rte_event_port_unlink(evdev, port, NULL, 0);
804 RTE_TEST_ASSERT(ret >= 0, "Failed to unlink all queues port=%d",
808 const unsigned int total_events = MAX_EVENTS / nr_queues;
810 /* Link all even number of queues to port0 and odd numbers to port 1*/
811 for (queue = 0; queue < nr_queues; queue++) {
813 ret = rte_event_port_link(evdev, port, &queue, NULL, 1);
814 RTE_TEST_ASSERT(ret == 1, "Failed to link queue=%d to port=%d",
819 RTE_EVENT_TYPE_CPU /* event_type */,
820 rte_rand() % 256 /* sub_event_type */,
821 rte_rand() % (RTE_SCHED_TYPE_PARALLEL + 1),
824 total_events /* events */);
829 port0_events += total_events;
831 port1_events += total_events;
834 ret = consume_events(0 /* port */, port0_events,
835 validate_queue_to_port_multi_link);
838 ret = consume_events(1 /* port */, port1_events,
839 validate_queue_to_port_multi_link);
847 worker_flow_based_pipeline(void *arg)
849 struct test_core_param *param = arg;
851 uint16_t valid_event;
852 uint8_t port = param->port;
853 uint8_t new_sched_type = param->sched_type;
854 rte_atomic32_t *total_events = param->total_events;
855 uint64_t dequeue_tmo_ticks = param->dequeue_tmo_ticks;
857 while (rte_atomic32_read(total_events) > 0) {
858 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1,
863 /* Events from stage 0 */
864 if (ev.sub_event_type == 0) {
865 /* Move to atomic flow to maintain the ordering */
867 ev.event_type = RTE_EVENT_TYPE_CPU;
868 ev.sub_event_type = 1; /* stage 1 */
869 ev.sched_type = new_sched_type;
870 ev.op = RTE_EVENT_OP_FORWARD;
871 rte_event_enqueue_burst(evdev, port, &ev, 1);
872 } else if (ev.sub_event_type == 1) { /* Events from stage 1*/
873 if (seqn_list_update(ev.mbuf->seqn) == 0) {
874 rte_pktmbuf_free(ev.mbuf);
875 rte_atomic32_sub(total_events, 1);
877 ssovf_log_dbg("Failed to update seqn_list");
881 ssovf_log_dbg("Invalid ev.sub_event_type = %d",
890 test_multiport_flow_sched_type_test(uint8_t in_sched_type,
891 uint8_t out_sched_type)
893 const unsigned int total_events = MAX_EVENTS;
897 RTE_TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
898 RTE_EVENT_DEV_ATTR_PORT_COUNT,
899 &nr_ports), "Port count get failed");
900 nr_ports = RTE_MIN(nr_ports, rte_lcore_count() - 1);
903 ssovf_log_dbg("%s: Not enough ports=%d or workers=%d", __func__,
904 nr_ports, rte_lcore_count() - 1);
908 /* Injects events with m->seqn=0 to total_events */
911 RTE_EVENT_TYPE_CPU /* event_type */,
912 0 /* sub_event_type (stage 0) */,
916 total_events /* events */);
920 ret = launch_workers_and_wait(worker_flow_based_pipeline,
921 worker_flow_based_pipeline,
922 total_events, nr_ports, out_sched_type);
926 if (in_sched_type != RTE_SCHED_TYPE_PARALLEL &&
927 out_sched_type == RTE_SCHED_TYPE_ATOMIC) {
928 /* Check the events order maintained or not */
929 return seqn_list_check(total_events);
935 /* Multi port ordered to atomic transaction */
937 test_multi_port_flow_ordered_to_atomic(void)
939 /* Ingress event order test */
940 return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_ORDERED,
941 RTE_SCHED_TYPE_ATOMIC);
945 test_multi_port_flow_ordered_to_ordered(void)
947 return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_ORDERED,
948 RTE_SCHED_TYPE_ORDERED);
952 test_multi_port_flow_ordered_to_parallel(void)
954 return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_ORDERED,
955 RTE_SCHED_TYPE_PARALLEL);
959 test_multi_port_flow_atomic_to_atomic(void)
961 /* Ingress event order test */
962 return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_ATOMIC,
963 RTE_SCHED_TYPE_ATOMIC);
967 test_multi_port_flow_atomic_to_ordered(void)
969 return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_ATOMIC,
970 RTE_SCHED_TYPE_ORDERED);
974 test_multi_port_flow_atomic_to_parallel(void)
976 return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_ATOMIC,
977 RTE_SCHED_TYPE_PARALLEL);
981 test_multi_port_flow_parallel_to_atomic(void)
983 return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_PARALLEL,
984 RTE_SCHED_TYPE_ATOMIC);
988 test_multi_port_flow_parallel_to_ordered(void)
990 return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_PARALLEL,
991 RTE_SCHED_TYPE_ORDERED);
995 test_multi_port_flow_parallel_to_parallel(void)
997 return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_PARALLEL,
998 RTE_SCHED_TYPE_PARALLEL);
1002 worker_group_based_pipeline(void *arg)
1004 struct test_core_param *param = arg;
1005 struct rte_event ev;
1006 uint16_t valid_event;
1007 uint8_t port = param->port;
1008 uint8_t new_sched_type = param->sched_type;
1009 rte_atomic32_t *total_events = param->total_events;
1010 uint64_t dequeue_tmo_ticks = param->dequeue_tmo_ticks;
1012 while (rte_atomic32_read(total_events) > 0) {
1013 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1,
1018 /* Events from stage 0(group 0) */
1019 if (ev.queue_id == 0) {
1020 /* Move to atomic flow to maintain the ordering */
1022 ev.event_type = RTE_EVENT_TYPE_CPU;
1023 ev.sched_type = new_sched_type;
1024 ev.queue_id = 1; /* Stage 1*/
1025 ev.op = RTE_EVENT_OP_FORWARD;
1026 rte_event_enqueue_burst(evdev, port, &ev, 1);
1027 } else if (ev.queue_id == 1) { /* Events from stage 1(group 1)*/
1028 if (seqn_list_update(ev.mbuf->seqn) == 0) {
1029 rte_pktmbuf_free(ev.mbuf);
1030 rte_atomic32_sub(total_events, 1);
1032 ssovf_log_dbg("Failed to update seqn_list");
1036 ssovf_log_dbg("Invalid ev.queue_id = %d", ev.queue_id);
1046 test_multiport_queue_sched_type_test(uint8_t in_sched_type,
1047 uint8_t out_sched_type)
1049 const unsigned int total_events = MAX_EVENTS;
1053 RTE_TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
1054 RTE_EVENT_DEV_ATTR_PORT_COUNT,
1055 &nr_ports), "Port count get failed");
1057 nr_ports = RTE_MIN(nr_ports, rte_lcore_count() - 1);
1059 uint32_t queue_count;
1060 RTE_TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
1061 RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
1062 &queue_count), "Queue count get failed");
1063 if (queue_count < 2 || !nr_ports) {
1064 ssovf_log_dbg("%s: Not enough queues=%d ports=%d or workers=%d",
1065 __func__, queue_count, nr_ports,
1066 rte_lcore_count() - 1);
1070 /* Injects events with m->seqn=0 to total_events */
1071 ret = inject_events(
1073 RTE_EVENT_TYPE_CPU /* event_type */,
1074 0 /* sub_event_type (stage 0) */,
1078 total_events /* events */);
1082 ret = launch_workers_and_wait(worker_group_based_pipeline,
1083 worker_group_based_pipeline,
1084 total_events, nr_ports, out_sched_type);
1088 if (in_sched_type != RTE_SCHED_TYPE_PARALLEL &&
1089 out_sched_type == RTE_SCHED_TYPE_ATOMIC) {
1090 /* Check the events order maintained or not */
1091 return seqn_list_check(total_events);
1097 test_multi_port_queue_ordered_to_atomic(void)
1099 /* Ingress event order test */
1100 return test_multiport_queue_sched_type_test(RTE_SCHED_TYPE_ORDERED,
1101 RTE_SCHED_TYPE_ATOMIC);
1105 test_multi_port_queue_ordered_to_ordered(void)
1107 return test_multiport_queue_sched_type_test(RTE_SCHED_TYPE_ORDERED,
1108 RTE_SCHED_TYPE_ORDERED);
1112 test_multi_port_queue_ordered_to_parallel(void)
1114 return test_multiport_queue_sched_type_test(RTE_SCHED_TYPE_ORDERED,
1115 RTE_SCHED_TYPE_PARALLEL);
1119 test_multi_port_queue_atomic_to_atomic(void)
1121 /* Ingress event order test */
1122 return test_multiport_queue_sched_type_test(RTE_SCHED_TYPE_ATOMIC,
1123 RTE_SCHED_TYPE_ATOMIC);
1127 test_multi_port_queue_atomic_to_ordered(void)
1129 return test_multiport_queue_sched_type_test(RTE_SCHED_TYPE_ATOMIC,
1130 RTE_SCHED_TYPE_ORDERED);
1134 test_multi_port_queue_atomic_to_parallel(void)
1136 return test_multiport_queue_sched_type_test(RTE_SCHED_TYPE_ATOMIC,
1137 RTE_SCHED_TYPE_PARALLEL);
1141 test_multi_port_queue_parallel_to_atomic(void)
1143 return test_multiport_queue_sched_type_test(RTE_SCHED_TYPE_PARALLEL,
1144 RTE_SCHED_TYPE_ATOMIC);
1148 test_multi_port_queue_parallel_to_ordered(void)
1150 return test_multiport_queue_sched_type_test(RTE_SCHED_TYPE_PARALLEL,
1151 RTE_SCHED_TYPE_ORDERED);
1155 test_multi_port_queue_parallel_to_parallel(void)
1157 return test_multiport_queue_sched_type_test(RTE_SCHED_TYPE_PARALLEL,
1158 RTE_SCHED_TYPE_PARALLEL);
1162 worker_flow_based_pipeline_max_stages_rand_sched_type(void *arg)
1164 struct test_core_param *param = arg;
1165 struct rte_event ev;
1166 uint16_t valid_event;
1167 uint8_t port = param->port;
1168 rte_atomic32_t *total_events = param->total_events;
1170 while (rte_atomic32_read(total_events) > 0) {
1171 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1, 0);
1175 if (ev.sub_event_type == 255) { /* last stage */
1176 rte_pktmbuf_free(ev.mbuf);
1177 rte_atomic32_sub(total_events, 1);
1179 ev.event_type = RTE_EVENT_TYPE_CPU;
1180 ev.sub_event_type++;
1182 rte_rand() % (RTE_SCHED_TYPE_PARALLEL + 1);
1183 ev.op = RTE_EVENT_OP_FORWARD;
1184 rte_event_enqueue_burst(evdev, port, &ev, 1);
1191 launch_multi_port_max_stages_random_sched_type(int (*fn)(void *))
1196 RTE_TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
1197 RTE_EVENT_DEV_ATTR_PORT_COUNT,
1198 &nr_ports), "Port count get failed");
1199 nr_ports = RTE_MIN(nr_ports, rte_lcore_count() - 1);
1202 ssovf_log_dbg("%s: Not enough ports=%d or workers=%d", __func__,
1203 nr_ports, rte_lcore_count() - 1);
1207 /* Injects events with m->seqn=0 to total_events */
1208 ret = inject_events(
1210 RTE_EVENT_TYPE_CPU /* event_type */,
1211 0 /* sub_event_type (stage 0) */,
1212 rte_rand() % (RTE_SCHED_TYPE_PARALLEL + 1) /* sched_type */,
1215 MAX_EVENTS /* events */);
1219 return launch_workers_and_wait(fn, fn, MAX_EVENTS, nr_ports,
1220 0xff /* invalid */);
1223 /* Flow based pipeline with maximum stages with random sched type */
1225 test_multi_port_flow_max_stages_random_sched_type(void)
1227 return launch_multi_port_max_stages_random_sched_type(
1228 worker_flow_based_pipeline_max_stages_rand_sched_type);
1232 worker_queue_based_pipeline_max_stages_rand_sched_type(void *arg)
1234 struct test_core_param *param = arg;
1235 struct rte_event ev;
1236 uint16_t valid_event;
1237 uint8_t port = param->port;
1238 uint32_t queue_count;
1239 RTE_TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
1240 RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
1241 &queue_count), "Queue count get failed");
1242 uint8_t nr_queues = queue_count;
1243 rte_atomic32_t *total_events = param->total_events;
1245 while (rte_atomic32_read(total_events) > 0) {
1246 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1, 0);
1250 if (ev.queue_id == nr_queues - 1) { /* last stage */
1251 rte_pktmbuf_free(ev.mbuf);
1252 rte_atomic32_sub(total_events, 1);
1254 ev.event_type = RTE_EVENT_TYPE_CPU;
1257 rte_rand() % (RTE_SCHED_TYPE_PARALLEL + 1);
1258 ev.op = RTE_EVENT_OP_FORWARD;
1259 rte_event_enqueue_burst(evdev, port, &ev, 1);
1265 /* Queue based pipeline with maximum stages with random sched type */
1267 test_multi_port_queue_max_stages_random_sched_type(void)
1269 return launch_multi_port_max_stages_random_sched_type(
1270 worker_queue_based_pipeline_max_stages_rand_sched_type);
1274 worker_mixed_pipeline_max_stages_rand_sched_type(void *arg)
1276 struct test_core_param *param = arg;
1277 struct rte_event ev;
1278 uint16_t valid_event;
1279 uint8_t port = param->port;
1280 uint32_t queue_count;
1281 RTE_TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
1282 RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
1283 &queue_count), "Queue count get failed");
1284 uint8_t nr_queues = queue_count;
1285 rte_atomic32_t *total_events = param->total_events;
1287 while (rte_atomic32_read(total_events) > 0) {
1288 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1, 0);
1292 if (ev.queue_id == nr_queues - 1) { /* Last stage */
1293 rte_pktmbuf_free(ev.mbuf);
1294 rte_atomic32_sub(total_events, 1);
1296 ev.event_type = RTE_EVENT_TYPE_CPU;
1298 ev.sub_event_type = rte_rand() % 256;
1300 rte_rand() % (RTE_SCHED_TYPE_PARALLEL + 1);
1301 ev.op = RTE_EVENT_OP_FORWARD;
1302 rte_event_enqueue_burst(evdev, port, &ev, 1);
1308 /* Queue and flow based pipeline with maximum stages with random sched type */
1310 test_multi_port_mixed_max_stages_random_sched_type(void)
1312 return launch_multi_port_max_stages_random_sched_type(
1313 worker_mixed_pipeline_max_stages_rand_sched_type);
1317 worker_ordered_flow_producer(void *arg)
1319 struct test_core_param *param = arg;
1320 uint8_t port = param->port;
1324 while (counter < NUM_PACKETS) {
1325 m = rte_pktmbuf_alloc(eventdev_test_mempool);
1329 m->seqn = counter++;
1331 struct rte_event ev = {.event = 0, .u64 = 0};
1333 ev.flow_id = 0x1; /* Generate a fat flow */
1334 ev.sub_event_type = 0;
1335 /* Inject the new event */
1336 ev.op = RTE_EVENT_OP_NEW;
1337 ev.event_type = RTE_EVENT_TYPE_CPU;
1338 ev.sched_type = RTE_SCHED_TYPE_ORDERED;
1341 rte_event_enqueue_burst(evdev, port, &ev, 1);
1348 test_producer_consumer_ingress_order_test(int (*fn)(void *))
1352 RTE_TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
1353 RTE_EVENT_DEV_ATTR_PORT_COUNT,
1354 &nr_ports), "Port count get failed");
1355 nr_ports = RTE_MIN(nr_ports, rte_lcore_count() - 1);
1357 if (rte_lcore_count() < 3 || nr_ports < 2) {
1358 ssovf_log_dbg("### Not enough cores for %s test.", __func__);
1362 launch_workers_and_wait(worker_ordered_flow_producer, fn,
1363 NUM_PACKETS, nr_ports, RTE_SCHED_TYPE_ATOMIC);
1364 /* Check the events order maintained or not */
1365 return seqn_list_check(NUM_PACKETS);
1368 /* Flow based producer consumer ingress order test */
1370 test_flow_producer_consumer_ingress_order_test(void)
1372 return test_producer_consumer_ingress_order_test(
1373 worker_flow_based_pipeline);
1376 /* Queue based producer consumer ingress order test */
1378 test_queue_producer_consumer_ingress_order_test(void)
1380 return test_producer_consumer_ingress_order_test(
1381 worker_group_based_pipeline);
1384 static void octeontx_test_run(int (*setup)(void), void (*tdown)(void),
1385 int (*test)(void), const char *name)
1388 ssovf_log_selftest("Error setting up test %s", name);
1393 ssovf_log_selftest("%s Failed", name);
1396 ssovf_log_selftest("%s Passed", name);
1405 test_eventdev_octeontx(void)
1409 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1410 test_simple_enqdeq_ordered);
1411 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1412 test_simple_enqdeq_atomic);
1413 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1414 test_simple_enqdeq_parallel);
1415 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1416 test_multi_queue_enq_single_port_deq);
1417 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1418 test_multi_queue_enq_multi_port_deq);
1419 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1420 test_queue_to_port_single_link);
1421 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1422 test_queue_to_port_multi_link);
1423 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1424 test_multi_port_flow_ordered_to_atomic);
1425 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1426 test_multi_port_flow_ordered_to_ordered);
1427 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1428 test_multi_port_flow_ordered_to_parallel);
1429 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1430 test_multi_port_flow_atomic_to_atomic);
1431 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1432 test_multi_port_flow_atomic_to_ordered);
1433 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1434 test_multi_port_flow_atomic_to_parallel);
1435 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1436 test_multi_port_flow_parallel_to_atomic);
1437 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1438 test_multi_port_flow_parallel_to_ordered);
1439 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1440 test_multi_port_flow_parallel_to_parallel);
1441 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1442 test_multi_port_queue_ordered_to_atomic);
1443 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1444 test_multi_port_queue_ordered_to_ordered);
1445 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1446 test_multi_port_queue_ordered_to_parallel);
1447 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1448 test_multi_port_queue_atomic_to_atomic);
1449 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1450 test_multi_port_queue_atomic_to_ordered);
1451 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1452 test_multi_port_queue_atomic_to_parallel);
1453 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1454 test_multi_port_queue_parallel_to_atomic);
1455 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1456 test_multi_port_queue_parallel_to_ordered);
1457 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1458 test_multi_port_queue_parallel_to_parallel);
1459 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1460 test_multi_port_flow_max_stages_random_sched_type);
1461 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1462 test_multi_port_queue_max_stages_random_sched_type);
1463 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1464 test_multi_port_mixed_max_stages_random_sched_type);
1465 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1466 test_flow_producer_consumer_ingress_order_test);
1467 OCTEONTX_TEST_RUN(eventdev_setup, eventdev_teardown,
1468 test_queue_producer_consumer_ingress_order_test);
1469 OCTEONTX_TEST_RUN(eventdev_setup_priority, eventdev_teardown,
1470 test_multi_queue_priority);
1471 OCTEONTX_TEST_RUN(eventdev_setup_dequeue_timeout, eventdev_teardown,
1472 test_multi_port_flow_ordered_to_atomic);
1473 OCTEONTX_TEST_RUN(eventdev_setup_dequeue_timeout, eventdev_teardown,
1474 test_multi_port_queue_ordered_to_atomic);
1476 ssovf_log_selftest("Total tests : %d", total);
1477 ssovf_log_selftest("Passed : %d", passed);
1478 ssovf_log_selftest("Failed : %d", failed);
1479 ssovf_log_selftest("Not supported : %d", unsupported);
1481 testsuite_teardown();