4 * Copyright(c) 2017 Cavium networks. 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 networks 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_atomic.h>
34 #include <rte_common.h>
35 #include <rte_cycles.h>
36 #include <rte_debug.h>
38 #include <rte_ethdev.h>
39 #include <rte_eventdev.h>
40 #include <rte_hexdump.h>
42 #include <rte_malloc.h>
43 #include <rte_memcpy.h>
44 #include <rte_launch.h>
45 #include <rte_lcore.h>
46 #include <rte_per_lcore.h>
47 #include <rte_random.h>
51 #define NUM_PACKETS (1 << 18)
52 #define MAX_EVENTS (16 * 1024)
55 static struct rte_mempool *eventdev_test_mempool;
60 uint8_t sub_event_type;
66 static uint32_t seqn_list_index;
67 static int seqn_list[NUM_PACKETS];
72 RTE_BUILD_BUG_ON(NUM_PACKETS < MAX_EVENTS);
73 memset(seqn_list, 0, sizeof(seqn_list));
78 seqn_list_update(int val)
80 if (seqn_list_index >= NUM_PACKETS)
83 seqn_list[seqn_list_index++] = val;
89 seqn_list_check(int limit)
93 for (i = 0; i < limit; i++) {
94 if (seqn_list[i] != i) {
95 printf("Seqn mismatch %d %d\n", seqn_list[i], i);
102 struct test_core_param {
103 rte_atomic32_t *total_events;
104 uint64_t dequeue_tmo_ticks;
110 testsuite_setup(void)
112 const char *eventdev_name = "event_octeontx";
114 evdev = rte_event_dev_get_dev_id(eventdev_name);
116 printf("%d: Eventdev %s not found - creating.\n",
117 __LINE__, eventdev_name);
118 if (rte_eal_vdev_init(eventdev_name, NULL) < 0) {
119 printf("Error creating eventdev %s\n", eventdev_name);
122 evdev = rte_event_dev_get_dev_id(eventdev_name);
124 printf("Error finding newly created eventdev\n");
133 testsuite_teardown(void)
135 rte_event_dev_close(evdev);
139 devconf_set_default_sane_values(struct rte_event_dev_config *dev_conf,
140 struct rte_event_dev_info *info)
142 memset(dev_conf, 0, sizeof(struct rte_event_dev_config));
143 dev_conf->dequeue_timeout_ns = info->min_dequeue_timeout_ns;
144 dev_conf->nb_event_ports = info->max_event_ports;
145 dev_conf->nb_event_queues = info->max_event_queues;
146 dev_conf->nb_event_queue_flows = info->max_event_queue_flows;
147 dev_conf->nb_event_port_dequeue_depth =
148 info->max_event_port_dequeue_depth;
149 dev_conf->nb_event_port_enqueue_depth =
150 info->max_event_port_enqueue_depth;
151 dev_conf->nb_event_port_enqueue_depth =
152 info->max_event_port_enqueue_depth;
153 dev_conf->nb_events_limit =
154 info->max_num_events;
158 TEST_EVENTDEV_SETUP_DEFAULT,
159 TEST_EVENTDEV_SETUP_PRIORITY,
160 TEST_EVENTDEV_SETUP_DEQUEUE_TIMEOUT,
164 _eventdev_setup(int mode)
167 struct rte_event_dev_config dev_conf;
168 struct rte_event_dev_info info;
169 const char *pool_name = "evdev_octeontx_test_pool";
171 /* Create and destrory pool for each test case to make it standalone */
172 eventdev_test_mempool = rte_pktmbuf_pool_create(pool_name,
174 0 /*MBUF_CACHE_SIZE*/,
176 512, /* Use very small mbufs */
178 if (!eventdev_test_mempool) {
179 printf("ERROR creating mempool\n");
183 ret = rte_event_dev_info_get(evdev, &info);
184 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
185 TEST_ASSERT(info.max_num_events >= (int32_t)MAX_EVENTS,
186 "max_num_events=%d < max_events=%d",
187 info.max_num_events, MAX_EVENTS);
189 devconf_set_default_sane_values(&dev_conf, &info);
190 if (mode == TEST_EVENTDEV_SETUP_DEQUEUE_TIMEOUT)
191 dev_conf.event_dev_cfg |= RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
193 ret = rte_event_dev_configure(evdev, &dev_conf);
194 TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
196 if (mode == TEST_EVENTDEV_SETUP_PRIORITY) {
197 /* Configure event queues(0 to n) with
198 * RTE_EVENT_DEV_PRIORITY_HIGHEST to
199 * RTE_EVENT_DEV_PRIORITY_LOWEST
201 uint8_t step = (RTE_EVENT_DEV_PRIORITY_LOWEST + 1) /
202 rte_event_queue_count(evdev);
203 for (i = 0; i < rte_event_queue_count(evdev); i++) {
204 struct rte_event_queue_conf queue_conf;
206 ret = rte_event_queue_default_conf_get(evdev, i,
208 TEST_ASSERT_SUCCESS(ret, "Failed to get def_conf%d", i);
209 queue_conf.priority = i * step;
210 ret = rte_event_queue_setup(evdev, i, &queue_conf);
211 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue=%d", i);
215 /* Configure event queues with default priority */
216 for (i = 0; i < rte_event_queue_count(evdev); i++) {
217 ret = rte_event_queue_setup(evdev, i, NULL);
218 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue=%d", i);
221 /* Configure event ports */
222 for (i = 0; i < rte_event_port_count(evdev); i++) {
223 ret = rte_event_port_setup(evdev, i, NULL);
224 TEST_ASSERT_SUCCESS(ret, "Failed to setup port=%d", i);
225 ret = rte_event_port_link(evdev, i, NULL, NULL, 0);
226 TEST_ASSERT(ret >= 0, "Failed to link all queues port=%d", i);
229 ret = rte_event_dev_start(evdev);
230 TEST_ASSERT_SUCCESS(ret, "Failed to start device");
238 return _eventdev_setup(TEST_EVENTDEV_SETUP_DEFAULT);
242 eventdev_setup_priority(void)
244 return _eventdev_setup(TEST_EVENTDEV_SETUP_PRIORITY);
248 eventdev_teardown(void)
250 rte_event_dev_stop(evdev);
251 rte_mempool_free(eventdev_test_mempool);
255 update_event_and_validation_attr(struct rte_mbuf *m, struct rte_event *ev,
256 uint32_t flow_id, uint8_t event_type,
257 uint8_t sub_event_type, uint8_t sched_type,
258 uint8_t queue, uint8_t port)
260 struct event_attr *attr;
262 /* Store the event attributes in mbuf for future reference */
263 attr = rte_pktmbuf_mtod(m, struct event_attr *);
264 attr->flow_id = flow_id;
265 attr->event_type = event_type;
266 attr->sub_event_type = sub_event_type;
267 attr->sched_type = sched_type;
271 ev->flow_id = flow_id;
272 ev->sub_event_type = sub_event_type;
273 ev->event_type = event_type;
274 /* Inject the new event */
275 ev->op = RTE_EVENT_OP_NEW;
276 ev->sched_type = sched_type;
277 ev->queue_id = queue;
282 inject_events(uint32_t flow_id, uint8_t event_type, uint8_t sub_event_type,
283 uint8_t sched_type, uint8_t queue, uint8_t port,
289 for (i = 0; i < events; i++) {
290 struct rte_event ev = {.event = 0, .u64 = 0};
292 m = rte_pktmbuf_alloc(eventdev_test_mempool);
293 TEST_ASSERT_NOT_NULL(m, "mempool alloc failed");
296 update_event_and_validation_attr(m, &ev, flow_id, event_type,
297 sub_event_type, sched_type, queue, port);
298 rte_event_enqueue_burst(evdev, port, &ev, 1);
304 check_excess_events(uint8_t port)
307 uint16_t valid_event;
310 /* Check for excess events, try for a few times and exit */
311 for (i = 0; i < 32; i++) {
312 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1, 0);
314 TEST_ASSERT_SUCCESS(valid_event, "Unexpected valid event=%d",
321 generate_random_events(const unsigned int total_events)
323 struct rte_event_dev_info info;
327 ret = rte_event_dev_info_get(evdev, &info);
328 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
329 for (i = 0; i < total_events; i++) {
331 rte_rand() % info.max_event_queue_flows /*flow_id */,
332 rte_rand() % (RTE_EVENT_TYPE_CPU + 1) /* event_type */,
333 rte_rand() % 256 /* sub_event_type */,
334 rte_rand() % (RTE_SCHED_TYPE_PARALLEL + 1),
335 rte_rand() % rte_event_queue_count(evdev) /* queue */,
346 validate_event(struct rte_event *ev)
348 struct event_attr *attr;
350 attr = rte_pktmbuf_mtod(ev->mbuf, struct event_attr *);
351 TEST_ASSERT_EQUAL(attr->flow_id, ev->flow_id,
352 "flow_id mismatch enq=%d deq =%d",
353 attr->flow_id, ev->flow_id);
354 TEST_ASSERT_EQUAL(attr->event_type, ev->event_type,
355 "event_type mismatch enq=%d deq =%d",
356 attr->event_type, ev->event_type);
357 TEST_ASSERT_EQUAL(attr->sub_event_type, ev->sub_event_type,
358 "sub_event_type mismatch enq=%d deq =%d",
359 attr->sub_event_type, ev->sub_event_type);
360 TEST_ASSERT_EQUAL(attr->sched_type, ev->sched_type,
361 "sched_type mismatch enq=%d deq =%d",
362 attr->sched_type, ev->sched_type);
363 TEST_ASSERT_EQUAL(attr->queue, ev->queue_id,
364 "queue mismatch enq=%d deq =%d",
365 attr->queue, ev->queue_id);
369 typedef int (*validate_event_cb)(uint32_t index, uint8_t port,
370 struct rte_event *ev);
373 consume_events(uint8_t port, const uint32_t total_events, validate_event_cb fn)
376 uint16_t valid_event;
377 uint32_t events = 0, forward_progress_cnt = 0, index = 0;
381 if (++forward_progress_cnt > UINT16_MAX) {
382 printf("Detected deadlock\n");
386 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1, 0);
390 forward_progress_cnt = 0;
391 ret = validate_event(&ev);
396 ret = fn(index, port, &ev);
397 TEST_ASSERT_SUCCESS(ret,
398 "Failed to validate test specific event");
403 rte_pktmbuf_free(ev.mbuf);
404 if (++events >= total_events)
408 return check_excess_events(port);
412 validate_simple_enqdeq(uint32_t index, uint8_t port, struct rte_event *ev)
415 TEST_ASSERT_EQUAL(index, ev->mbuf->seqn, "index=%d != seqn=%d", index,
421 test_simple_enqdeq(uint8_t sched_type)
425 ret = inject_events(0 /*flow_id */,
426 RTE_EVENT_TYPE_CPU /* event_type */,
427 0 /* sub_event_type */,
435 return consume_events(0 /* port */, MAX_EVENTS, validate_simple_enqdeq);
439 test_simple_enqdeq_ordered(void)
441 return test_simple_enqdeq(RTE_SCHED_TYPE_ORDERED);
445 test_simple_enqdeq_atomic(void)
447 return test_simple_enqdeq(RTE_SCHED_TYPE_ATOMIC);
451 test_simple_enqdeq_parallel(void)
453 return test_simple_enqdeq(RTE_SCHED_TYPE_PARALLEL);
457 * Generate a prescribed number of events and spread them across available
458 * queues. On dequeue, using single event port(port 0) verify the enqueued
462 test_multi_queue_enq_single_port_deq(void)
466 ret = generate_random_events(MAX_EVENTS);
470 return consume_events(0 /* port */, MAX_EVENTS, NULL);
474 * Inject 0..MAX_EVENTS events over 0..rte_event_queue_count() with modulus
477 * For example, Inject 32 events over 0..7 queues
478 * enqueue events 0, 8, 16, 24 in queue 0
479 * enqueue events 1, 9, 17, 25 in queue 1
482 * enqueue events 7, 15, 23, 31 in queue 7
484 * On dequeue, Validate the events comes in 0,8,16,24,1,9,17,25..,7,15,23,31
485 * order from queue0(highest priority) to queue7(lowest_priority)
488 validate_queue_priority(uint32_t index, uint8_t port, struct rte_event *ev)
490 uint32_t range = MAX_EVENTS / rte_event_queue_count(evdev);
491 uint32_t expected_val = (index % range) * rte_event_queue_count(evdev);
493 expected_val += ev->queue_id;
495 TEST_ASSERT_EQUAL(ev->mbuf->seqn, expected_val,
496 "seqn=%d index=%d expected=%d range=%d nb_queues=%d max_event=%d",
497 ev->mbuf->seqn, index, expected_val, range,
498 rte_event_queue_count(evdev), MAX_EVENTS);
503 test_multi_queue_priority(void)
507 int i, max_evts_roundoff;
509 /* See validate_queue_priority() comments for priority validate logic */
510 max_evts_roundoff = MAX_EVENTS / rte_event_queue_count(evdev);
511 max_evts_roundoff *= rte_event_queue_count(evdev);
513 for (i = 0; i < max_evts_roundoff; i++) {
514 struct rte_event ev = {.event = 0, .u64 = 0};
516 m = rte_pktmbuf_alloc(eventdev_test_mempool);
517 TEST_ASSERT_NOT_NULL(m, "mempool alloc failed");
520 queue = i % rte_event_queue_count(evdev);
521 update_event_and_validation_attr(m, &ev, 0, RTE_EVENT_TYPE_CPU,
522 0, RTE_SCHED_TYPE_PARALLEL, queue, 0);
523 rte_event_enqueue_burst(evdev, 0, &ev, 1);
526 return consume_events(0, max_evts_roundoff, validate_queue_priority);
530 worker_multi_port_fn(void *arg)
532 struct test_core_param *param = arg;
534 uint16_t valid_event;
535 uint8_t port = param->port;
536 rte_atomic32_t *total_events = param->total_events;
539 while (rte_atomic32_read(total_events) > 0) {
540 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1, 0);
544 ret = validate_event(&ev);
545 TEST_ASSERT_SUCCESS(ret, "Failed to validate event");
546 rte_pktmbuf_free(ev.mbuf);
547 rte_atomic32_sub(total_events, 1);
553 wait_workers_to_join(int lcore, const rte_atomic32_t *count)
555 uint64_t cycles, print_cycles;
557 print_cycles = cycles = rte_get_timer_cycles();
558 while (rte_eal_get_lcore_state(lcore) != FINISHED) {
559 uint64_t new_cycles = rte_get_timer_cycles();
561 if (new_cycles - print_cycles > rte_get_timer_hz()) {
562 printf("\r%s: events %d\n", __func__,
563 rte_atomic32_read(count));
564 print_cycles = new_cycles;
566 if (new_cycles - cycles > rte_get_timer_hz() * 10) {
567 printf("%s: No schedules for seconds, deadlock (%d)\n",
569 rte_atomic32_read(count));
570 rte_event_dev_dump(evdev, stdout);
575 rte_eal_mp_wait_lcore();
581 launch_workers_and_wait(int (*master_worker)(void *),
582 int (*slave_workers)(void *), uint32_t total_events,
583 uint8_t nb_workers, uint8_t sched_type)
588 struct test_core_param *param;
589 rte_atomic32_t atomic_total_events;
590 uint64_t dequeue_tmo_ticks;
595 rte_atomic32_set(&atomic_total_events, total_events);
598 param = malloc(sizeof(struct test_core_param) * nb_workers);
602 ret = rte_event_dequeue_timeout_ticks(evdev,
603 rte_rand() % 10000000/* 10ms */, &dequeue_tmo_ticks);
607 param[0].total_events = &atomic_total_events;
608 param[0].sched_type = sched_type;
610 param[0].dequeue_tmo_ticks = dequeue_tmo_ticks;
613 w_lcore = rte_get_next_lcore(
617 rte_eal_remote_launch(master_worker, ¶m[0], w_lcore);
619 for (port = 1; port < nb_workers; port++) {
620 param[port].total_events = &atomic_total_events;
621 param[port].sched_type = sched_type;
622 param[port].port = port;
623 param[port].dequeue_tmo_ticks = dequeue_tmo_ticks;
625 w_lcore = rte_get_next_lcore(w_lcore, 1, 0);
626 rte_eal_remote_launch(slave_workers, ¶m[port], w_lcore);
629 ret = wait_workers_to_join(w_lcore, &atomic_total_events);
635 * Generate a prescribed number of events and spread them across available
636 * queues. Dequeue the events through multiple ports and verify the enqueued
640 test_multi_queue_enq_multi_port_deq(void)
642 const unsigned int total_events = MAX_EVENTS;
646 ret = generate_random_events(total_events);
650 nr_ports = RTE_MIN(rte_event_port_count(evdev), rte_lcore_count() - 1);
653 printf("%s: Not enough ports=%d or workers=%d\n", __func__,
654 rte_event_port_count(evdev), rte_lcore_count() - 1);
658 return launch_workers_and_wait(worker_multi_port_fn,
659 worker_multi_port_fn, total_events,
660 nr_ports, 0xff /* invalid */);
664 validate_queue_to_port_single_link(uint32_t index, uint8_t port,
665 struct rte_event *ev)
668 TEST_ASSERT_EQUAL(port, ev->queue_id,
669 "queue mismatch enq=%d deq =%d",
675 * Link queue x to port x and check correctness of link by checking
676 * queue_id == x on dequeue on the specific port x
679 test_queue_to_port_single_link(void)
681 int i, nr_links, ret;
683 /* Unlink all connections that created in eventdev_setup */
684 for (i = 0; i < rte_event_port_count(evdev); i++) {
685 ret = rte_event_port_unlink(evdev, i, NULL, 0);
686 TEST_ASSERT(ret >= 0, "Failed to unlink all queues port=%d", i);
689 nr_links = RTE_MIN(rte_event_port_count(evdev),
690 rte_event_queue_count(evdev));
691 const unsigned int total_events = MAX_EVENTS / nr_links;
693 /* Link queue x to port x and inject events to queue x through port x */
694 for (i = 0; i < nr_links; i++) {
695 uint8_t queue = (uint8_t)i;
697 ret = rte_event_port_link(evdev, i, &queue, NULL, 1);
698 TEST_ASSERT(ret == 1, "Failed to link queue to port %d", i);
702 rte_rand() % (RTE_EVENT_TYPE_CPU + 1) /* event_type */,
703 rte_rand() % 256 /* sub_event_type */,
704 rte_rand() % (RTE_SCHED_TYPE_PARALLEL + 1),
707 total_events /* events */);
712 /* Verify the events generated from correct queue */
713 for (i = 0; i < nr_links; i++) {
714 ret = consume_events(i /* port */, total_events,
715 validate_queue_to_port_single_link);
724 validate_queue_to_port_multi_link(uint32_t index, uint8_t port,
725 struct rte_event *ev)
728 TEST_ASSERT_EQUAL(port, (ev->queue_id & 0x1),
729 "queue mismatch enq=%d deq =%d",
735 * Link all even number of queues to port 0 and all odd number of queues to
736 * port 1 and verify the link connection on dequeue
739 test_queue_to_port_multi_link(void)
741 int ret, port0_events = 0, port1_events = 0;
742 uint8_t nr_queues, nr_ports, queue, port;
744 nr_queues = rte_event_queue_count(evdev);
745 nr_ports = rte_event_port_count(evdev);
748 printf("%s: Not enough ports to test ports=%d\n",
753 /* Unlink all connections that created in eventdev_setup */
754 for (port = 0; port < nr_ports; port++) {
755 ret = rte_event_port_unlink(evdev, port, NULL, 0);
756 TEST_ASSERT(ret >= 0, "Failed to unlink all queues port=%d",
760 const unsigned int total_events = MAX_EVENTS / nr_queues;
762 /* Link all even number of queues to port0 and odd numbers to port 1*/
763 for (queue = 0; queue < nr_queues; queue++) {
765 ret = rte_event_port_link(evdev, port, &queue, NULL, 1);
766 TEST_ASSERT(ret == 1, "Failed to link queue=%d to port=%d",
771 rte_rand() % (RTE_EVENT_TYPE_CPU + 1) /* event_type */,
772 rte_rand() % 256 /* sub_event_type */,
773 rte_rand() % (RTE_SCHED_TYPE_PARALLEL + 1),
776 total_events /* events */);
781 port0_events += total_events;
783 port1_events += total_events;
786 ret = consume_events(0 /* port */, port0_events,
787 validate_queue_to_port_multi_link);
790 ret = consume_events(1 /* port */, port1_events,
791 validate_queue_to_port_multi_link);
799 worker_flow_based_pipeline(void *arg)
801 struct test_core_param *param = arg;
803 uint16_t valid_event;
804 uint8_t port = param->port;
805 uint8_t new_sched_type = param->sched_type;
806 rte_atomic32_t *total_events = param->total_events;
807 uint64_t dequeue_tmo_ticks = param->dequeue_tmo_ticks;
809 while (rte_atomic32_read(total_events) > 0) {
810 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1,
815 /* Events from stage 0 */
816 if (ev.sub_event_type == 0) {
817 /* Move to atomic flow to maintain the ordering */
819 ev.event_type = RTE_EVENT_TYPE_CPU;
820 ev.sub_event_type = 1; /* stage 1 */
821 ev.sched_type = new_sched_type;
822 ev.op = RTE_EVENT_OP_FORWARD;
823 rte_event_enqueue_burst(evdev, port, &ev, 1);
824 } else if (ev.sub_event_type == 1) { /* Events from stage 1*/
825 if (seqn_list_update(ev.mbuf->seqn) == TEST_SUCCESS) {
826 rte_pktmbuf_free(ev.mbuf);
827 rte_atomic32_sub(total_events, 1);
829 printf("Failed to update seqn_list\n");
833 printf("Invalid ev.sub_event_type = %d\n",
842 test_multiport_flow_sched_type_test(uint8_t in_sched_type,
843 uint8_t out_sched_type)
845 const unsigned int total_events = MAX_EVENTS;
849 nr_ports = RTE_MIN(rte_event_port_count(evdev), rte_lcore_count() - 1);
852 printf("%s: Not enough ports=%d or workers=%d\n", __func__,
853 rte_event_port_count(evdev), rte_lcore_count() - 1);
857 /* Injects events with m->seqn=0 to total_events */
860 RTE_EVENT_TYPE_CPU /* event_type */,
861 0 /* sub_event_type (stage 0) */,
865 total_events /* events */);
869 ret = launch_workers_and_wait(worker_flow_based_pipeline,
870 worker_flow_based_pipeline,
871 total_events, nr_ports, out_sched_type);
875 if (in_sched_type != RTE_SCHED_TYPE_PARALLEL &&
876 out_sched_type == RTE_SCHED_TYPE_ATOMIC) {
877 /* Check the events order maintained or not */
878 return seqn_list_check(total_events);
884 /* Multi port ordered to atomic transaction */
886 test_multi_port_flow_ordered_to_atomic(void)
888 /* Ingress event order test */
889 return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_ORDERED,
890 RTE_SCHED_TYPE_ATOMIC);
894 test_multi_port_flow_ordered_to_ordered(void)
896 return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_ORDERED,
897 RTE_SCHED_TYPE_ORDERED);
901 test_multi_port_flow_ordered_to_parallel(void)
903 return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_ORDERED,
904 RTE_SCHED_TYPE_PARALLEL);
908 test_multi_port_flow_atomic_to_atomic(void)
910 /* Ingress event order test */
911 return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_ATOMIC,
912 RTE_SCHED_TYPE_ATOMIC);
916 test_multi_port_flow_atomic_to_ordered(void)
918 return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_ATOMIC,
919 RTE_SCHED_TYPE_ORDERED);
923 test_multi_port_flow_atomic_to_parallel(void)
925 return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_ATOMIC,
926 RTE_SCHED_TYPE_PARALLEL);
930 test_multi_port_flow_parallel_to_atomic(void)
932 return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_PARALLEL,
933 RTE_SCHED_TYPE_ATOMIC);
937 test_multi_port_flow_parallel_to_ordered(void)
939 return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_PARALLEL,
940 RTE_SCHED_TYPE_ORDERED);
944 test_multi_port_flow_parallel_to_parallel(void)
946 return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_PARALLEL,
947 RTE_SCHED_TYPE_PARALLEL);
950 static struct unit_test_suite eventdev_octeontx_testsuite = {
951 .suite_name = "eventdev octeontx unit test suite",
952 .setup = testsuite_setup,
953 .teardown = testsuite_teardown,
955 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
956 test_simple_enqdeq_ordered),
957 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
958 test_simple_enqdeq_atomic),
959 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
960 test_simple_enqdeq_parallel),
961 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
962 test_multi_queue_enq_single_port_deq),
963 TEST_CASE_ST(eventdev_setup_priority, eventdev_teardown,
964 test_multi_queue_priority),
965 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
966 test_multi_queue_enq_multi_port_deq),
967 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
968 test_queue_to_port_single_link),
969 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
970 test_queue_to_port_multi_link),
971 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
972 test_multi_port_flow_ordered_to_atomic),
973 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
974 test_multi_port_flow_ordered_to_ordered),
975 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
976 test_multi_port_flow_ordered_to_parallel),
977 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
978 test_multi_port_flow_atomic_to_atomic),
979 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
980 test_multi_port_flow_atomic_to_ordered),
981 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
982 test_multi_port_flow_atomic_to_parallel),
983 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
984 test_multi_port_flow_parallel_to_atomic),
985 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
986 test_multi_port_flow_parallel_to_ordered),
987 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
988 test_multi_port_flow_parallel_to_parallel),
989 TEST_CASES_END() /**< NULL terminate unit test array */
994 test_eventdev_octeontx(void)
996 return unit_test_suite_runner(&eventdev_octeontx_testsuite);
999 REGISTER_TEST_COMMAND(eventdev_octeontx_autotest, test_eventdev_octeontx);