test/test/test_eventdev_octeontx.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017 Cavium, Inc
   3  */
   4
   5 #include <rte_atomic.h>
   6 #include <rte_common.h>
   7 #include <rte_cycles.h>
   8 #include <rte_debug.h>
   9 #include <rte_eal.h>
  10 #include <rte_ethdev.h>
  11 #include <rte_eventdev.h>
  12 #include <rte_hexdump.h>
  13 #include <rte_mbuf.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>
  21
  22 #include "test.h"
  23
  24 #define NUM_PACKETS (1 << 18)
  25 #define MAX_EVENTS  (16 * 1024)
  26
  27 static int evdev;
  28 static struct rte_mempool *eventdev_test_mempool;
  29
  30 struct event_attr {
  31         uint32_t flow_id;
  32         uint8_t event_type;
  33         uint8_t sub_event_type;
  34         uint8_t sched_type;
  35         uint8_t queue;
  36         uint8_t port;
  37 };
  38
  39 static uint32_t seqn_list_index;
  40 static int seqn_list[NUM_PACKETS];
  41
  42 static inline void
  43 seqn_list_init(void)
  44 {
  45         RTE_BUILD_BUG_ON(NUM_PACKETS < MAX_EVENTS);
  46         memset(seqn_list, 0, sizeof(seqn_list));
  47         seqn_list_index = 0;
  48 }
  49
  50 static inline int
  51 seqn_list_update(int val)
  52 {
  53         if (seqn_list_index >= NUM_PACKETS)
  54                 return TEST_FAILED;
  55
  56         seqn_list[seqn_list_index++] = val;
  57         rte_smp_wmb();
  58         return TEST_SUCCESS;
  59 }
  60
  61 static inline int
  62 seqn_list_check(int limit)
  63 {
  64         int i;
  65
  66         for (i = 0; i < limit; i++) {
  67                 if (seqn_list[i] != i) {
  68                         printf("Seqn mismatch %d %d\n", seqn_list[i], i);
  69                         return TEST_FAILED;
  70                 }
  71         }
  72         return TEST_SUCCESS;
  73 }
  74
  75 struct test_core_param {
  76         rte_atomic32_t *total_events;
  77         uint64_t dequeue_tmo_ticks;
  78         uint8_t port;
  79         uint8_t sched_type;
  80 };
  81
  82 static int
  83 testsuite_setup(void)
  84 {
  85         const char *eventdev_name = "event_octeontx";
  86
  87         evdev = rte_event_dev_get_dev_id(eventdev_name);
  88         if (evdev < 0) {
  89                 printf("%d: Eventdev %s not found - creating.\n",
  90                                 __LINE__, eventdev_name);
  91                 if (rte_vdev_init(eventdev_name, NULL) < 0) {
  92                         printf("Error creating eventdev %s\n", eventdev_name);
  93                         return TEST_FAILED;
  94                 }
  95                 evdev = rte_event_dev_get_dev_id(eventdev_name);
  96                 if (evdev < 0) {
  97                         printf("Error finding newly created eventdev\n");
  98                         return TEST_FAILED;
  99                 }
 100         }
 101
 102         return TEST_SUCCESS;
 103 }
 104
 105 static void
 106 testsuite_teardown(void)
 107 {
 108         rte_event_dev_close(evdev);
 109 }
 110
 111 static inline void
 112 devconf_set_default_sane_values(struct rte_event_dev_config *dev_conf,
 113                         struct rte_event_dev_info *info)
 114 {
 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;
 128 }
 129
 130 enum {
 131         TEST_EVENTDEV_SETUP_DEFAULT,
 132         TEST_EVENTDEV_SETUP_PRIORITY,
 133         TEST_EVENTDEV_SETUP_DEQUEUE_TIMEOUT,
 134 };
 135
 136 static inline int
 137 _eventdev_setup(int mode)
 138 {
 139         int i, ret;
 140         struct rte_event_dev_config dev_conf;
 141         struct rte_event_dev_info info;
 142         const char *pool_name = "evdev_octeontx_test_pool";
 143
 144         /* Create and destrory pool for each test case to make it standalone */
 145         eventdev_test_mempool = rte_pktmbuf_pool_create(pool_name,
 146                                         MAX_EVENTS,
 147                                         0 /*MBUF_CACHE_SIZE*/,
 148                                         0,
 149                                         512, /* Use very small mbufs */
 150                                         rte_socket_id());
 151         if (!eventdev_test_mempool) {
 152                 printf("ERROR creating mempool\n");
 153                 return TEST_FAILED;
 154         }
 155
 156         ret = rte_event_dev_info_get(evdev, &info);
 157         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 158         TEST_ASSERT(info.max_num_events >= (int32_t)MAX_EVENTS,
 159                         "max_num_events=%d < max_events=%d",
 160                         info.max_num_events, MAX_EVENTS);
 161
 162         devconf_set_default_sane_values(&dev_conf, &info);
 163         if (mode == TEST_EVENTDEV_SETUP_DEQUEUE_TIMEOUT)
 164                 dev_conf.event_dev_cfg |= RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
 165
 166         ret = rte_event_dev_configure(evdev, &dev_conf);
 167         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
 168
 169         uint32_t queue_count;
 170         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
 171                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
 172                             &queue_count), "Queue count get failed");
 173
 174         if (mode == TEST_EVENTDEV_SETUP_PRIORITY) {
 175                 if (queue_count > 8) {
 176                         printf("test expects the unique priority per queue\n");
 177                         return -ENOTSUP;
 178                 }
 179
 180                 /* Configure event queues(0 to n) with
 181                  * RTE_EVENT_DEV_PRIORITY_HIGHEST to
 182                  * RTE_EVENT_DEV_PRIORITY_LOWEST
 183                  */
 184                 uint8_t step = (RTE_EVENT_DEV_PRIORITY_LOWEST + 1) /
 185                                 queue_count;
 186                 for (i = 0; i < (int)queue_count; i++) {
 187                         struct rte_event_queue_conf queue_conf;
 188
 189                         ret = rte_event_queue_default_conf_get(evdev, i,
 190                                                 &queue_conf);
 191                         TEST_ASSERT_SUCCESS(ret, "Failed to get def_conf%d", i);
 192                         queue_conf.priority = i * step;
 193                         ret = rte_event_queue_setup(evdev, i, &queue_conf);
 194                         TEST_ASSERT_SUCCESS(ret, "Failed to setup queue=%d", i);
 195                 }
 196
 197         } else {
 198                 /* Configure event queues with default priority */
 199                 for (i = 0; i < (int)queue_count; i++) {
 200                         ret = rte_event_queue_setup(evdev, i, NULL);
 201                         TEST_ASSERT_SUCCESS(ret, "Failed to setup queue=%d", i);
 202                 }
 203         }
 204         /* Configure event ports */
 205         uint32_t port_count;
 206         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
 207                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 208                                 &port_count), "Port count get failed");
 209         for (i = 0; i < (int)port_count; i++) {
 210                 ret = rte_event_port_setup(evdev, i, NULL);
 211                 TEST_ASSERT_SUCCESS(ret, "Failed to setup port=%d", i);
 212                 ret = rte_event_port_link(evdev, i, NULL, NULL, 0);
 213                 TEST_ASSERT(ret >= 0, "Failed to link all queues port=%d", i);
 214         }
 215
 216         ret = rte_event_dev_start(evdev);
 217         TEST_ASSERT_SUCCESS(ret, "Failed to start device");
 218
 219         return TEST_SUCCESS;
 220 }
 221
 222 static inline int
 223 eventdev_setup(void)
 224 {
 225         return _eventdev_setup(TEST_EVENTDEV_SETUP_DEFAULT);
 226 }
 227
 228 static inline int
 229 eventdev_setup_priority(void)
 230 {
 231         return _eventdev_setup(TEST_EVENTDEV_SETUP_PRIORITY);
 232 }
 233
 234 static inline int
 235 eventdev_setup_dequeue_timeout(void)
 236 {
 237         return _eventdev_setup(TEST_EVENTDEV_SETUP_DEQUEUE_TIMEOUT);
 238 }
 239
 240 static inline void
 241 eventdev_teardown(void)
 242 {
 243         rte_event_dev_stop(evdev);
 244         rte_mempool_free(eventdev_test_mempool);
 245 }
 246
 247 static inline void
 248 update_event_and_validation_attr(struct rte_mbuf *m, struct rte_event *ev,
 249                         uint32_t flow_id, uint8_t event_type,
 250                         uint8_t sub_event_type, uint8_t sched_type,
 251                         uint8_t queue, uint8_t port)
 252 {
 253         struct event_attr *attr;
 254
 255         /* Store the event attributes in mbuf for future reference */
 256         attr = rte_pktmbuf_mtod(m, struct event_attr *);
 257         attr->flow_id = flow_id;
 258         attr->event_type = event_type;
 259         attr->sub_event_type = sub_event_type;
 260         attr->sched_type = sched_type;
 261         attr->queue = queue;
 262         attr->port = port;
 263
 264         ev->flow_id = flow_id;
 265         ev->sub_event_type = sub_event_type;
 266         ev->event_type = event_type;
 267         /* Inject the new event */
 268         ev->op = RTE_EVENT_OP_NEW;
 269         ev->sched_type = sched_type;
 270         ev->queue_id = queue;
 271         ev->mbuf = m;
 272 }
 273
 274 static inline int
 275 inject_events(uint32_t flow_id, uint8_t event_type, uint8_t sub_event_type,
 276                 uint8_t sched_type, uint8_t queue, uint8_t port,
 277                 unsigned int events)
 278 {
 279         struct rte_mbuf *m;
 280         unsigned int i;
 281
 282         for (i = 0; i < events; i++) {
 283                 struct rte_event ev = {.event = 0, .u64 = 0};
 284
 285                 m = rte_pktmbuf_alloc(eventdev_test_mempool);
 286                 TEST_ASSERT_NOT_NULL(m, "mempool alloc failed");
 287
 288                 m->seqn = i;
 289                 update_event_and_validation_attr(m, &ev, flow_id, event_type,
 290                         sub_event_type, sched_type, queue, port);
 291                 rte_event_enqueue_burst(evdev, port, &ev, 1);
 292         }
 293         return 0;
 294 }
 295
 296 static inline int
 297 check_excess_events(uint8_t port)
 298 {
 299         int i;
 300         uint16_t valid_event;
 301         struct rte_event ev;
 302
 303         /* Check for excess events, try for a few times and exit */
 304         for (i = 0; i < 32; i++) {
 305                 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1, 0);
 306
 307                 TEST_ASSERT_SUCCESS(valid_event, "Unexpected valid event=%d",
 308                                         ev.mbuf->seqn);
 309         }
 310         return 0;
 311 }
 312
 313 static inline int
 314 generate_random_events(const unsigned int total_events)
 315 {
 316         struct rte_event_dev_info info;
 317         unsigned int i;
 318         int ret;
 319
 320         uint32_t queue_count;
 321         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
 322                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
 323                             &queue_count), "Queue count get failed");
 324
 325         ret = rte_event_dev_info_get(evdev, &info);
 326         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 327         for (i = 0; i < total_events; i++) {
 328                 ret = inject_events(
 329                         rte_rand() % info.max_event_queue_flows /*flow_id */,
 330                         RTE_EVENT_TYPE_CPU /* event_type */,
 331                         rte_rand() % 256 /* sub_event_type */,
 332                         rte_rand() % (RTE_SCHED_TYPE_PARALLEL + 1),
 333                         rte_rand() % queue_count /* queue */,
 334                         0 /* port */,
 335                         1 /* events */);
 336                 if (ret)
 337                         return TEST_FAILED;
 338         }
 339         return ret;
 340 }
 341
 342
 343 static inline int
 344 validate_event(struct rte_event *ev)
 345 {
 346         struct event_attr *attr;
 347
 348         attr = rte_pktmbuf_mtod(ev->mbuf, struct event_attr *);
 349         TEST_ASSERT_EQUAL(attr->flow_id, ev->flow_id,
 350                         "flow_id mismatch enq=%d deq =%d",
 351                         attr->flow_id, ev->flow_id);
 352         TEST_ASSERT_EQUAL(attr->event_type, ev->event_type,
 353                         "event_type mismatch enq=%d deq =%d",
 354                         attr->event_type, ev->event_type);
 355         TEST_ASSERT_EQUAL(attr->sub_event_type, ev->sub_event_type,
 356                         "sub_event_type mismatch enq=%d deq =%d",
 357                         attr->sub_event_type, ev->sub_event_type);
 358         TEST_ASSERT_EQUAL(attr->sched_type, ev->sched_type,
 359                         "sched_type mismatch enq=%d deq =%d",
 360                         attr->sched_type, ev->sched_type);
 361         TEST_ASSERT_EQUAL(attr->queue, ev->queue_id,
 362                         "queue mismatch enq=%d deq =%d",
 363                         attr->queue, ev->queue_id);
 364         return 0;
 365 }
 366
 367 typedef int (*validate_event_cb)(uint32_t index, uint8_t port,
 368                                  struct rte_event *ev);
 369
 370 static inline int
 371 consume_events(uint8_t port, const uint32_t total_events, validate_event_cb fn)
 372 {
 373         int ret;
 374         uint16_t valid_event;
 375         uint32_t events = 0, forward_progress_cnt = 0, index = 0;
 376         struct rte_event ev;
 377
 378         while (1) {
 379                 if (++forward_progress_cnt > UINT16_MAX) {
 380                         printf("Detected deadlock\n");
 381                         return TEST_FAILED;
 382                 }
 383
 384                 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1, 0);
 385                 if (!valid_event)
 386                         continue;
 387
 388                 forward_progress_cnt = 0;
 389                 ret = validate_event(&ev);
 390                 if (ret)
 391                         return TEST_FAILED;
 392
 393                 if (fn != NULL) {
 394                         ret = fn(index, port, &ev);
 395                         TEST_ASSERT_SUCCESS(ret,
 396                                 "Failed to validate test specific event");
 397                 }
 398
 399                 ++index;
 400
 401                 rte_pktmbuf_free(ev.mbuf);
 402                 if (++events >= total_events)
 403                         break;
 404         }
 405
 406         return check_excess_events(port);
 407 }
 408
 409 static int
 410 validate_simple_enqdeq(uint32_t index, uint8_t port, struct rte_event *ev)
 411 {
 412         RTE_SET_USED(port);
 413         TEST_ASSERT_EQUAL(index, ev->mbuf->seqn, "index=%d != seqn=%d", index,
 414                                         ev->mbuf->seqn);
 415         return 0;
 416 }
 417
 418 static inline int
 419 test_simple_enqdeq(uint8_t sched_type)
 420 {
 421         int ret;
 422
 423         ret = inject_events(0 /*flow_id */,
 424                                 RTE_EVENT_TYPE_CPU /* event_type */,
 425                                 0 /* sub_event_type */,
 426                                 sched_type,
 427                                 0 /* queue */,
 428                                 0 /* port */,
 429                                 MAX_EVENTS);
 430         if (ret)
 431                 return TEST_FAILED;
 432
 433         return consume_events(0 /* port */, MAX_EVENTS, validate_simple_enqdeq);
 434 }
 435
 436 static int
 437 test_simple_enqdeq_ordered(void)
 438 {
 439         return test_simple_enqdeq(RTE_SCHED_TYPE_ORDERED);
 440 }
 441
 442 static int
 443 test_simple_enqdeq_atomic(void)
 444 {
 445         return test_simple_enqdeq(RTE_SCHED_TYPE_ATOMIC);
 446 }
 447
 448 static int
 449 test_simple_enqdeq_parallel(void)
 450 {
 451         return test_simple_enqdeq(RTE_SCHED_TYPE_PARALLEL);
 452 }
 453
 454 /*
 455  * Generate a prescribed number of events and spread them across available
 456  * queues. On dequeue, using single event port(port 0) verify the enqueued
 457  * event attributes
 458  */
 459 static int
 460 test_multi_queue_enq_single_port_deq(void)
 461 {
 462         int ret;
 463
 464         ret = generate_random_events(MAX_EVENTS);
 465         if (ret)
 466                 return TEST_FAILED;
 467
 468         return consume_events(0 /* port */, MAX_EVENTS, NULL);
 469 }
 470
 471 /*
 472  * Inject 0..MAX_EVENTS events over 0..queue_count with modulus
 473  * operation
 474  *
 475  * For example, Inject 32 events over 0..7 queues
 476  * enqueue events 0, 8, 16, 24 in queue 0
 477  * enqueue events 1, 9, 17, 25 in queue 1
 478  * ..
 479  * ..
 480  * enqueue events 7, 15, 23, 31 in queue 7
 481  *
 482  * On dequeue, Validate the events comes in 0,8,16,24,1,9,17,25..,7,15,23,31
 483  * order from queue0(highest priority) to queue7(lowest_priority)
 484  */
 485 static int
 486 validate_queue_priority(uint32_t index, uint8_t port, struct rte_event *ev)
 487 {
 488         uint32_t queue_count;
 489         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
 490                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
 491                             &queue_count), "Queue count get failed");
 492         uint32_t range = MAX_EVENTS / queue_count;
 493         uint32_t expected_val = (index % range) * queue_count;
 494
 495         expected_val += ev->queue_id;
 496         RTE_SET_USED(port);
 497         TEST_ASSERT_EQUAL(ev->mbuf->seqn, expected_val,
 498         "seqn=%d index=%d expected=%d range=%d nb_queues=%d max_event=%d",
 499                         ev->mbuf->seqn, index, expected_val, range,
 500                         queue_count, MAX_EVENTS);
 501         return 0;
 502 }
 503
 504 static int
 505 test_multi_queue_priority(void)
 506 {
 507         uint8_t queue;
 508         struct rte_mbuf *m;
 509         int i, max_evts_roundoff;
 510
 511         /* See validate_queue_priority() comments for priority validate logic */
 512         uint32_t queue_count;
 513         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
 514                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
 515                             &queue_count), "Queue count get failed");
 516         max_evts_roundoff  = MAX_EVENTS / queue_count;
 517         max_evts_roundoff *= queue_count;
 518
 519         for (i = 0; i < max_evts_roundoff; i++) {
 520                 struct rte_event ev = {.event = 0, .u64 = 0};
 521
 522                 m = rte_pktmbuf_alloc(eventdev_test_mempool);
 523                 TEST_ASSERT_NOT_NULL(m, "mempool alloc failed");
 524
 525                 m->seqn = i;
 526                 queue = i % queue_count;
 527                 update_event_and_validation_attr(m, &ev, 0, RTE_EVENT_TYPE_CPU,
 528                         0, RTE_SCHED_TYPE_PARALLEL, queue, 0);
 529                 rte_event_enqueue_burst(evdev, 0, &ev, 1);
 530         }
 531
 532         return consume_events(0, max_evts_roundoff, validate_queue_priority);
 533 }
 534
 535 static int
 536 worker_multi_port_fn(void *arg)
 537 {
 538         struct test_core_param *param = arg;
 539         struct rte_event ev;
 540         uint16_t valid_event;
 541         uint8_t port = param->port;
 542         rte_atomic32_t *total_events = param->total_events;
 543         int ret;
 544
 545         while (rte_atomic32_read(total_events) > 0) {
 546                 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1, 0);
 547                 if (!valid_event)
 548                         continue;
 549
 550                 ret = validate_event(&ev);
 551                 TEST_ASSERT_SUCCESS(ret, "Failed to validate event");
 552                 rte_pktmbuf_free(ev.mbuf);
 553                 rte_atomic32_sub(total_events, 1);
 554         }
 555         return 0;
 556 }
 557
 558 static inline int
 559 wait_workers_to_join(int lcore, const rte_atomic32_t *count)
 560 {
 561         uint64_t cycles, print_cycles;
 562
 563         print_cycles = cycles = rte_get_timer_cycles();
 564         while (rte_eal_get_lcore_state(lcore) != FINISHED) {
 565                 uint64_t new_cycles = rte_get_timer_cycles();
 566
 567                 if (new_cycles - print_cycles > rte_get_timer_hz()) {
 568                         printf("\r%s: events %d\n", __func__,
 569                                 rte_atomic32_read(count));
 570                         print_cycles = new_cycles;
 571                 }
 572                 if (new_cycles - cycles > rte_get_timer_hz() * 10) {
 573                         printf("%s: No schedules for seconds, deadlock (%d)\n",
 574                                 __func__,
 575                                 rte_atomic32_read(count));
 576                         rte_event_dev_dump(evdev, stdout);
 577                         cycles = new_cycles;
 578                         return TEST_FAILED;
 579                 }
 580         }
 581         rte_eal_mp_wait_lcore();
 582         return TEST_SUCCESS;
 583 }
 584
 585
 586 static inline int
 587 launch_workers_and_wait(int (*master_worker)(void *),
 588                         int (*slave_workers)(void *), uint32_t total_events,
 589                         uint8_t nb_workers, uint8_t sched_type)
 590 {
 591         uint8_t port = 0;
 592         int w_lcore;
 593         int ret;
 594         struct test_core_param *param;
 595         rte_atomic32_t atomic_total_events;
 596         uint64_t dequeue_tmo_ticks;
 597
 598         if (!nb_workers)
 599                 return 0;
 600
 601         rte_atomic32_set(&atomic_total_events, total_events);
 602         seqn_list_init();
 603
 604         param = malloc(sizeof(struct test_core_param) * nb_workers);
 605         if (!param)
 606                 return TEST_FAILED;
 607
 608         ret = rte_event_dequeue_timeout_ticks(evdev,
 609                 rte_rand() % 10000000/* 10ms */, &dequeue_tmo_ticks);
 610         if (ret)
 611                 return TEST_FAILED;
 612
 613         param[0].total_events = &atomic_total_events;
 614         param[0].sched_type = sched_type;
 615         param[0].port = 0;
 616         param[0].dequeue_tmo_ticks = dequeue_tmo_ticks;
 617         rte_smp_wmb();
 618
 619         w_lcore = rte_get_next_lcore(
 620                         /* start core */ -1,
 621                         /* skip master */ 1,
 622                         /* wrap */ 0);
 623         rte_eal_remote_launch(master_worker, &param[0], w_lcore);
 624
 625         for (port = 1; port < nb_workers; port++) {
 626                 param[port].total_events = &atomic_total_events;
 627                 param[port].sched_type = sched_type;
 628                 param[port].port = port;
 629                 param[port].dequeue_tmo_ticks = dequeue_tmo_ticks;
 630                 rte_smp_wmb();
 631                 w_lcore = rte_get_next_lcore(w_lcore, 1, 0);
 632                 rte_eal_remote_launch(slave_workers, &param[port], w_lcore);
 633         }
 634
 635         ret = wait_workers_to_join(w_lcore, &atomic_total_events);
 636         free(param);
 637         return ret;
 638 }
 639
 640 /*
 641  * Generate a prescribed number of events and spread them across available
 642  * queues. Dequeue the events through multiple ports and verify the enqueued
 643  * event attributes
 644  */
 645 static int
 646 test_multi_queue_enq_multi_port_deq(void)
 647 {
 648         const unsigned int total_events = MAX_EVENTS;
 649         uint32_t nr_ports;
 650         int ret;
 651
 652         ret = generate_random_events(total_events);
 653         if (ret)
 654                 return TEST_FAILED;
 655
 656         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
 657                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 658                                 &nr_ports), "Port count get failed");
 659         nr_ports = RTE_MIN(nr_ports, rte_lcore_count() - 1);
 660
 661         if (!nr_ports) {
 662                 printf("%s: Not enough ports=%d or workers=%d\n", __func__,
 663                         nr_ports, rte_lcore_count() - 1);
 664                 return TEST_SUCCESS;
 665         }
 666
 667         return launch_workers_and_wait(worker_multi_port_fn,
 668                                         worker_multi_port_fn, total_events,
 669                                         nr_ports, 0xff /* invalid */);
 670 }
 671
 672 static int
 673 validate_queue_to_port_single_link(uint32_t index, uint8_t port,
 674                         struct rte_event *ev)
 675 {
 676         RTE_SET_USED(index);
 677         TEST_ASSERT_EQUAL(port, ev->queue_id,
 678                                 "queue mismatch enq=%d deq =%d",
 679                                 port, ev->queue_id);
 680         return 0;
 681 }
 682
 683 /*
 684  * Link queue x to port x and check correctness of link by checking
 685  * queue_id == x on dequeue on the specific port x
 686  */
 687 static int
 688 test_queue_to_port_single_link(void)
 689 {
 690         int i, nr_links, ret;
 691
 692         uint32_t port_count;
 693         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
 694                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 695                                 &port_count), "Port count get failed");
 696
 697         /* Unlink all connections that created in eventdev_setup */
 698         for (i = 0; i < (int)port_count; i++) {
 699                 ret = rte_event_port_unlink(evdev, i, NULL, 0);
 700                 TEST_ASSERT(ret >= 0, "Failed to unlink all queues port=%d", i);
 701         }
 702
 703         uint32_t queue_count;
 704         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
 705                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
 706                             &queue_count), "Queue count get failed");
 707
 708         nr_links = RTE_MIN(port_count, queue_count);
 709         const unsigned int total_events = MAX_EVENTS / nr_links;
 710
 711         /* Link queue x to port x and inject events to queue x through port x */
 712         for (i = 0; i < nr_links; i++) {
 713                 uint8_t queue = (uint8_t)i;
 714
 715                 ret = rte_event_port_link(evdev, i, &queue, NULL, 1);
 716                 TEST_ASSERT(ret == 1, "Failed to link queue to port %d", i);
 717
 718                 ret = inject_events(
 719                         0x100 /*flow_id */,
 720                         RTE_EVENT_TYPE_CPU /* event_type */,
 721                         rte_rand() % 256 /* sub_event_type */,
 722                         rte_rand() % (RTE_SCHED_TYPE_PARALLEL + 1),
 723                         queue /* queue */,
 724                         i /* port */,
 725                         total_events /* events */);
 726                 if (ret)
 727                         return TEST_FAILED;
 728         }
 729
 730         /* Verify the events generated from correct queue */
 731         for (i = 0; i < nr_links; i++) {
 732                 ret = consume_events(i /* port */, total_events,
 733                                 validate_queue_to_port_single_link);
 734                 if (ret)
 735                         return TEST_FAILED;
 736         }
 737
 738         return TEST_SUCCESS;
 739 }
 740
 741 static int
 742 validate_queue_to_port_multi_link(uint32_t index, uint8_t port,
 743                         struct rte_event *ev)
 744 {
 745         RTE_SET_USED(index);
 746         TEST_ASSERT_EQUAL(port, (ev->queue_id & 0x1),
 747                                 "queue mismatch enq=%d deq =%d",
 748                                 port, ev->queue_id);
 749         return 0;
 750 }
 751
 752 /*
 753  * Link all even number of queues to port 0 and all odd number of queues to
 754  * port 1 and verify the link connection on dequeue
 755  */
 756 static int
 757 test_queue_to_port_multi_link(void)
 758 {
 759         int ret, port0_events = 0, port1_events = 0;
 760         uint8_t queue, port;
 761         uint32_t nr_queues = 0;
 762         uint32_t nr_ports = 0;
 763
 764         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
 765                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
 766                             &nr_queues), "Queue count get failed");
 767
 768         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
 769                                 RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
 770                                 &nr_queues), "Queue count get failed");
 771         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
 772                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 773                                 &nr_ports), "Port count get failed");
 774
 775         if (nr_ports < 2) {
 776                 printf("%s: Not enough ports to test ports=%d\n",
 777                                 __func__, nr_ports);
 778                 return TEST_SUCCESS;
 779         }
 780
 781         /* Unlink all connections that created in eventdev_setup */
 782         for (port = 0; port < nr_ports; port++) {
 783                 ret = rte_event_port_unlink(evdev, port, NULL, 0);
 784                 TEST_ASSERT(ret >= 0, "Failed to unlink all queues port=%d",
 785                                         port);
 786         }
 787
 788         const unsigned int total_events = MAX_EVENTS / nr_queues;
 789
 790         /* Link all even number of queues to port0 and odd numbers to port 1*/
 791         for (queue = 0; queue < nr_queues; queue++) {
 792                 port = queue & 0x1;
 793                 ret = rte_event_port_link(evdev, port, &queue, NULL, 1);
 794                 TEST_ASSERT(ret == 1, "Failed to link queue=%d to port=%d",
 795                                         queue, port);
 796
 797                 ret = inject_events(
 798                         0x100 /*flow_id */,
 799                         RTE_EVENT_TYPE_CPU /* event_type */,
 800                         rte_rand() % 256 /* sub_event_type */,
 801                         rte_rand() % (RTE_SCHED_TYPE_PARALLEL + 1),
 802                         queue /* queue */,
 803                         port /* port */,
 804                         total_events /* events */);
 805                 if (ret)
 806                         return TEST_FAILED;
 807
 808                 if (port == 0)
 809                         port0_events += total_events;
 810                 else
 811                         port1_events += total_events;
 812         }
 813
 814         ret = consume_events(0 /* port */, port0_events,
 815                                 validate_queue_to_port_multi_link);
 816         if (ret)
 817                 return TEST_FAILED;
 818         ret = consume_events(1 /* port */, port1_events,
 819                                 validate_queue_to_port_multi_link);
 820         if (ret)
 821                 return TEST_FAILED;
 822
 823         return TEST_SUCCESS;
 824 }
 825
 826 static int
 827 worker_flow_based_pipeline(void *arg)
 828 {
 829         struct test_core_param *param = arg;
 830         struct rte_event ev;
 831         uint16_t valid_event;
 832         uint8_t port = param->port;
 833         uint8_t new_sched_type = param->sched_type;
 834         rte_atomic32_t *total_events = param->total_events;
 835         uint64_t dequeue_tmo_ticks = param->dequeue_tmo_ticks;
 836
 837         while (rte_atomic32_read(total_events) > 0) {
 838                 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1,
 839                                         dequeue_tmo_ticks);
 840                 if (!valid_event)
 841                         continue;
 842
 843                 /* Events from stage 0 */
 844                 if (ev.sub_event_type == 0) {
 845                         /* Move to atomic flow to maintain the ordering */
 846                         ev.flow_id = 0x2;
 847                         ev.event_type = RTE_EVENT_TYPE_CPU;
 848                         ev.sub_event_type = 1; /* stage 1 */
 849                         ev.sched_type = new_sched_type;
 850                         ev.op = RTE_EVENT_OP_FORWARD;
 851                         rte_event_enqueue_burst(evdev, port, &ev, 1);
 852                 } else if (ev.sub_event_type == 1) { /* Events from stage 1*/
 853                         if (seqn_list_update(ev.mbuf->seqn) == TEST_SUCCESS) {
 854                                 rte_pktmbuf_free(ev.mbuf);
 855                                 rte_atomic32_sub(total_events, 1);
 856                         } else {
 857                                 printf("Failed to update seqn_list\n");
 858                                 return TEST_FAILED;
 859                         }
 860                 } else {
 861                         printf("Invalid ev.sub_event_type = %d\n",
 862                                         ev.sub_event_type);
 863                         return TEST_FAILED;
 864                 }
 865         }
 866         return 0;
 867 }
 868
 869 static int
 870 test_multiport_flow_sched_type_test(uint8_t in_sched_type,
 871                         uint8_t out_sched_type)
 872 {
 873         const unsigned int total_events = MAX_EVENTS;
 874         uint32_t nr_ports;
 875         int ret;
 876
 877         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
 878                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 879                                 &nr_ports), "Port count get failed");
 880         nr_ports = RTE_MIN(nr_ports, rte_lcore_count() - 1);
 881
 882         if (!nr_ports) {
 883                 printf("%s: Not enough ports=%d or workers=%d\n", __func__,
 884                         nr_ports, rte_lcore_count() - 1);
 885                 return TEST_SUCCESS;
 886         }
 887
 888         /* Injects events with m->seqn=0 to total_events */
 889         ret = inject_events(
 890                 0x1 /*flow_id */,
 891                 RTE_EVENT_TYPE_CPU /* event_type */,
 892                 0 /* sub_event_type (stage 0) */,
 893                 in_sched_type,
 894                 0 /* queue */,
 895                 0 /* port */,
 896                 total_events /* events */);
 897         if (ret)
 898                 return TEST_FAILED;
 899
 900         ret = launch_workers_and_wait(worker_flow_based_pipeline,
 901                                         worker_flow_based_pipeline,
 902                                         total_events, nr_ports, out_sched_type);
 903         if (ret)
 904                 return TEST_FAILED;
 905
 906         if (in_sched_type != RTE_SCHED_TYPE_PARALLEL &&
 907                         out_sched_type == RTE_SCHED_TYPE_ATOMIC) {
 908                 /* Check the events order maintained or not */
 909                 return seqn_list_check(total_events);
 910         }
 911         return TEST_SUCCESS;
 912 }
 913
 914
 915 /* Multi port ordered to atomic transaction */
 916 static int
 917 test_multi_port_flow_ordered_to_atomic(void)
 918 {
 919         /* Ingress event order test */
 920         return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_ORDERED,
 921                                 RTE_SCHED_TYPE_ATOMIC);
 922 }
 923
 924 static int
 925 test_multi_port_flow_ordered_to_ordered(void)
 926 {
 927         return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_ORDERED,
 928                                 RTE_SCHED_TYPE_ORDERED);
 929 }
 930
 931 static int
 932 test_multi_port_flow_ordered_to_parallel(void)
 933 {
 934         return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_ORDERED,
 935                                 RTE_SCHED_TYPE_PARALLEL);
 936 }
 937
 938 static int
 939 test_multi_port_flow_atomic_to_atomic(void)
 940 {
 941         /* Ingress event order test */
 942         return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_ATOMIC,
 943                                 RTE_SCHED_TYPE_ATOMIC);
 944 }
 945
 946 static int
 947 test_multi_port_flow_atomic_to_ordered(void)
 948 {
 949         return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_ATOMIC,
 950                                 RTE_SCHED_TYPE_ORDERED);
 951 }
 952
 953 static int
 954 test_multi_port_flow_atomic_to_parallel(void)
 955 {
 956         return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_ATOMIC,
 957                                 RTE_SCHED_TYPE_PARALLEL);
 958 }
 959
 960 static int
 961 test_multi_port_flow_parallel_to_atomic(void)
 962 {
 963         return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_PARALLEL,
 964                                 RTE_SCHED_TYPE_ATOMIC);
 965 }
 966
 967 static int
 968 test_multi_port_flow_parallel_to_ordered(void)
 969 {
 970         return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_PARALLEL,
 971                                 RTE_SCHED_TYPE_ORDERED);
 972 }
 973
 974 static int
 975 test_multi_port_flow_parallel_to_parallel(void)
 976 {
 977         return test_multiport_flow_sched_type_test(RTE_SCHED_TYPE_PARALLEL,
 978                                 RTE_SCHED_TYPE_PARALLEL);
 979 }
 980
 981 static int
 982 worker_group_based_pipeline(void *arg)
 983 {
 984         struct test_core_param *param = arg;
 985         struct rte_event ev;
 986         uint16_t valid_event;
 987         uint8_t port = param->port;
 988         uint8_t new_sched_type = param->sched_type;
 989         rte_atomic32_t *total_events = param->total_events;
 990         uint64_t dequeue_tmo_ticks = param->dequeue_tmo_ticks;
 991
 992         while (rte_atomic32_read(total_events) > 0) {
 993                 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1,
 994                                         dequeue_tmo_ticks);
 995                 if (!valid_event)
 996                         continue;
 997
 998                 /* Events from stage 0(group 0) */
 999                 if (ev.queue_id == 0) {
1000                         /* Move to atomic flow to maintain the ordering */
1001                         ev.flow_id = 0x2;
1002                         ev.event_type = RTE_EVENT_TYPE_CPU;
1003                         ev.sched_type = new_sched_type;
1004                         ev.queue_id = 1; /* Stage 1*/
1005                         ev.op = RTE_EVENT_OP_FORWARD;
1006                         rte_event_enqueue_burst(evdev, port, &ev, 1);
1007                 } else if (ev.queue_id == 1) { /* Events from stage 1(group 1)*/
1008                         if (seqn_list_update(ev.mbuf->seqn) == TEST_SUCCESS) {
1009                                 rte_pktmbuf_free(ev.mbuf);
1010                                 rte_atomic32_sub(total_events, 1);
1011                         } else {
1012                                 printf("Failed to update seqn_list\n");
1013                                 return TEST_FAILED;
1014                         }
1015                 } else {
1016                         printf("Invalid ev.queue_id = %d\n", ev.queue_id);
1017                         return TEST_FAILED;
1018                 }
1019         }
1020
1021
1022         return 0;
1023 }
1024
1025 static int
1026 test_multiport_queue_sched_type_test(uint8_t in_sched_type,
1027                         uint8_t out_sched_type)
1028 {
1029         const unsigned int total_events = MAX_EVENTS;
1030         uint32_t nr_ports;
1031         int ret;
1032
1033         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
1034                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
1035                                 &nr_ports), "Port count get failed");
1036
1037         nr_ports = RTE_MIN(nr_ports, rte_lcore_count() - 1);
1038
1039         uint32_t queue_count;
1040         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
1041                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
1042                             &queue_count), "Queue count get failed");
1043         if (queue_count < 2 ||  !nr_ports) {
1044                 printf("%s: Not enough queues=%d ports=%d or workers=%d\n",
1045                          __func__, queue_count, nr_ports,
1046                          rte_lcore_count() - 1);
1047                 return TEST_SUCCESS;
1048         }
1049
1050         /* Injects events with m->seqn=0 to total_events */
1051         ret = inject_events(
1052                 0x1 /*flow_id */,
1053                 RTE_EVENT_TYPE_CPU /* event_type */,
1054                 0 /* sub_event_type (stage 0) */,
1055                 in_sched_type,
1056                 0 /* queue */,
1057                 0 /* port */,
1058                 total_events /* events */);
1059         if (ret)
1060                 return TEST_FAILED;
1061
1062         ret = launch_workers_and_wait(worker_group_based_pipeline,
1063                                         worker_group_based_pipeline,
1064                                         total_events, nr_ports, out_sched_type);
1065         if (ret)
1066                 return TEST_FAILED;
1067
1068         if (in_sched_type != RTE_SCHED_TYPE_PARALLEL &&
1069                         out_sched_type == RTE_SCHED_TYPE_ATOMIC) {
1070                 /* Check the events order maintained or not */
1071                 return seqn_list_check(total_events);
1072         }
1073         return TEST_SUCCESS;
1074 }
1075
1076 static int
1077 test_multi_port_queue_ordered_to_atomic(void)
1078 {
1079         /* Ingress event order test */
1080         return test_multiport_queue_sched_type_test(RTE_SCHED_TYPE_ORDERED,
1081                                 RTE_SCHED_TYPE_ATOMIC);
1082 }
1083
1084 static int
1085 test_multi_port_queue_ordered_to_ordered(void)
1086 {
1087         return test_multiport_queue_sched_type_test(RTE_SCHED_TYPE_ORDERED,
1088                                 RTE_SCHED_TYPE_ORDERED);
1089 }
1090
1091 static int
1092 test_multi_port_queue_ordered_to_parallel(void)
1093 {
1094         return test_multiport_queue_sched_type_test(RTE_SCHED_TYPE_ORDERED,
1095                                 RTE_SCHED_TYPE_PARALLEL);
1096 }
1097
1098 static int
1099 test_multi_port_queue_atomic_to_atomic(void)
1100 {
1101         /* Ingress event order test */
1102         return test_multiport_queue_sched_type_test(RTE_SCHED_TYPE_ATOMIC,
1103                                 RTE_SCHED_TYPE_ATOMIC);
1104 }
1105
1106 static int
1107 test_multi_port_queue_atomic_to_ordered(void)
1108 {
1109         return test_multiport_queue_sched_type_test(RTE_SCHED_TYPE_ATOMIC,
1110                                 RTE_SCHED_TYPE_ORDERED);
1111 }
1112
1113 static int
1114 test_multi_port_queue_atomic_to_parallel(void)
1115 {
1116         return test_multiport_queue_sched_type_test(RTE_SCHED_TYPE_ATOMIC,
1117                                 RTE_SCHED_TYPE_PARALLEL);
1118 }
1119
1120 static int
1121 test_multi_port_queue_parallel_to_atomic(void)
1122 {
1123         return test_multiport_queue_sched_type_test(RTE_SCHED_TYPE_PARALLEL,
1124                                 RTE_SCHED_TYPE_ATOMIC);
1125 }
1126
1127 static int
1128 test_multi_port_queue_parallel_to_ordered(void)
1129 {
1130         return test_multiport_queue_sched_type_test(RTE_SCHED_TYPE_PARALLEL,
1131                                 RTE_SCHED_TYPE_ORDERED);
1132 }
1133
1134 static int
1135 test_multi_port_queue_parallel_to_parallel(void)
1136 {
1137         return test_multiport_queue_sched_type_test(RTE_SCHED_TYPE_PARALLEL,
1138                                 RTE_SCHED_TYPE_PARALLEL);
1139 }
1140
1141 static int
1142 worker_flow_based_pipeline_max_stages_rand_sched_type(void *arg)
1143 {
1144         struct test_core_param *param = arg;
1145         struct rte_event ev;
1146         uint16_t valid_event;
1147         uint8_t port = param->port;
1148         rte_atomic32_t *total_events = param->total_events;
1149
1150         while (rte_atomic32_read(total_events) > 0) {
1151                 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1, 0);
1152                 if (!valid_event)
1153                         continue;
1154
1155                 if (ev.sub_event_type == 255) { /* last stage */
1156                         rte_pktmbuf_free(ev.mbuf);
1157                         rte_atomic32_sub(total_events, 1);
1158                 } else {
1159                         ev.event_type = RTE_EVENT_TYPE_CPU;
1160                         ev.sub_event_type++;
1161                         ev.sched_type =
1162                                 rte_rand() % (RTE_SCHED_TYPE_PARALLEL + 1);
1163                         ev.op = RTE_EVENT_OP_FORWARD;
1164                         rte_event_enqueue_burst(evdev, port, &ev, 1);
1165                 }
1166         }
1167         return 0;
1168 }
1169
1170 static int
1171 launch_multi_port_max_stages_random_sched_type(int (*fn)(void *))
1172 {
1173         uint32_t nr_ports;
1174         int ret;
1175
1176         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
1177                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
1178                                 &nr_ports), "Port count get failed");
1179         nr_ports = RTE_MIN(nr_ports, rte_lcore_count() - 1);
1180
1181         if (!nr_ports) {
1182                 printf("%s: Not enough ports=%d or workers=%d\n", __func__,
1183                         nr_ports, rte_lcore_count() - 1);
1184                 return TEST_SUCCESS;
1185         }
1186
1187         /* Injects events with m->seqn=0 to total_events */
1188         ret = inject_events(
1189                 0x1 /*flow_id */,
1190                 RTE_EVENT_TYPE_CPU /* event_type */,
1191                 0 /* sub_event_type (stage 0) */,
1192                 rte_rand() % (RTE_SCHED_TYPE_PARALLEL + 1) /* sched_type */,
1193                 0 /* queue */,
1194                 0 /* port */,
1195                 MAX_EVENTS /* events */);
1196         if (ret)
1197                 return TEST_FAILED;
1198
1199         return launch_workers_and_wait(fn, fn, MAX_EVENTS, nr_ports,
1200                                          0xff /* invalid */);
1201 }
1202
1203 /* Flow based pipeline with maximum stages with random sched type */
1204 static int
1205 test_multi_port_flow_max_stages_random_sched_type(void)
1206 {
1207         return launch_multi_port_max_stages_random_sched_type(
1208                 worker_flow_based_pipeline_max_stages_rand_sched_type);
1209 }
1210
1211 static int
1212 worker_queue_based_pipeline_max_stages_rand_sched_type(void *arg)
1213 {
1214         struct test_core_param *param = arg;
1215         struct rte_event ev;
1216         uint16_t valid_event;
1217         uint8_t port = param->port;
1218         uint32_t queue_count;
1219         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
1220                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
1221                             &queue_count), "Queue count get failed");
1222         uint8_t nr_queues = queue_count;
1223         rte_atomic32_t *total_events = param->total_events;
1224
1225         while (rte_atomic32_read(total_events) > 0) {
1226                 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1, 0);
1227                 if (!valid_event)
1228                         continue;
1229
1230                 if (ev.queue_id == nr_queues - 1) { /* last stage */
1231                         rte_pktmbuf_free(ev.mbuf);
1232                         rte_atomic32_sub(total_events, 1);
1233                 } else {
1234                         ev.event_type = RTE_EVENT_TYPE_CPU;
1235                         ev.queue_id++;
1236                         ev.sched_type =
1237                                 rte_rand() % (RTE_SCHED_TYPE_PARALLEL + 1);
1238                         ev.op = RTE_EVENT_OP_FORWARD;
1239                         rte_event_enqueue_burst(evdev, port, &ev, 1);
1240                 }
1241         }
1242         return 0;
1243 }
1244
1245 /* Queue based pipeline with maximum stages with random sched type */
1246 static int
1247 test_multi_port_queue_max_stages_random_sched_type(void)
1248 {
1249         return launch_multi_port_max_stages_random_sched_type(
1250                 worker_queue_based_pipeline_max_stages_rand_sched_type);
1251 }
1252
1253 static int
1254 worker_mixed_pipeline_max_stages_rand_sched_type(void *arg)
1255 {
1256         struct test_core_param *param = arg;
1257         struct rte_event ev;
1258         uint16_t valid_event;
1259         uint8_t port = param->port;
1260         uint32_t queue_count;
1261         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
1262                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
1263                             &queue_count), "Queue count get failed");
1264         uint8_t nr_queues = queue_count;
1265         rte_atomic32_t *total_events = param->total_events;
1266
1267         while (rte_atomic32_read(total_events) > 0) {
1268                 valid_event = rte_event_dequeue_burst(evdev, port, &ev, 1, 0);
1269                 if (!valid_event)
1270                         continue;
1271
1272                 if (ev.queue_id == nr_queues - 1) { /* Last stage */
1273                         rte_pktmbuf_free(ev.mbuf);
1274                         rte_atomic32_sub(total_events, 1);
1275                 } else {
1276                         ev.event_type = RTE_EVENT_TYPE_CPU;
1277                         ev.queue_id++;
1278                         ev.sub_event_type = rte_rand() % 256;
1279                         ev.sched_type =
1280                                 rte_rand() % (RTE_SCHED_TYPE_PARALLEL + 1);
1281                         ev.op = RTE_EVENT_OP_FORWARD;
1282                         rte_event_enqueue_burst(evdev, port, &ev, 1);
1283                 }
1284         }
1285         return 0;
1286 }
1287
1288 /* Queue and flow based pipeline with maximum stages with random sched type */
1289 static int
1290 test_multi_port_mixed_max_stages_random_sched_type(void)
1291 {
1292         return launch_multi_port_max_stages_random_sched_type(
1293                 worker_mixed_pipeline_max_stages_rand_sched_type);
1294 }
1295
1296 static int
1297 worker_ordered_flow_producer(void *arg)
1298 {
1299         struct test_core_param *param = arg;
1300         uint8_t port = param->port;
1301         struct rte_mbuf *m;
1302         int counter = 0;
1303
1304         while (counter < NUM_PACKETS) {
1305                 m = rte_pktmbuf_alloc(eventdev_test_mempool);
1306                 if (m == NULL)
1307                         continue;
1308
1309                 m->seqn = counter++;
1310
1311                 struct rte_event ev = {.event = 0, .u64 = 0};
1312
1313                 ev.flow_id = 0x1; /* Generate a fat flow */
1314                 ev.sub_event_type = 0;
1315                 /* Inject the new event */
1316                 ev.op = RTE_EVENT_OP_NEW;
1317                 ev.event_type = RTE_EVENT_TYPE_CPU;
1318                 ev.sched_type = RTE_SCHED_TYPE_ORDERED;
1319                 ev.queue_id = 0;
1320                 ev.mbuf = m;
1321                 rte_event_enqueue_burst(evdev, port, &ev, 1);
1322         }
1323
1324         return 0;
1325 }
1326
1327 static inline int
1328 test_producer_consumer_ingress_order_test(int (*fn)(void *))
1329 {
1330         uint32_t nr_ports;
1331
1332         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(evdev,
1333                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
1334                                 &nr_ports), "Port count get failed");
1335         nr_ports = RTE_MIN(nr_ports, rte_lcore_count() - 1);
1336
1337         if (rte_lcore_count() < 3 || nr_ports < 2) {
1338                 printf("### Not enough cores for %s test.\n", __func__);
1339                 return TEST_SUCCESS;
1340         }
1341
1342         launch_workers_and_wait(worker_ordered_flow_producer, fn,
1343                                 NUM_PACKETS, nr_ports, RTE_SCHED_TYPE_ATOMIC);
1344         /* Check the events order maintained or not */
1345         return seqn_list_check(NUM_PACKETS);
1346 }
1347
1348 /* Flow based producer consumer ingress order test */
1349 static int
1350 test_flow_producer_consumer_ingress_order_test(void)
1351 {
1352         return test_producer_consumer_ingress_order_test(
1353                                 worker_flow_based_pipeline);
1354 }
1355
1356 /* Queue based producer consumer ingress order test */
1357 static int
1358 test_queue_producer_consumer_ingress_order_test(void)
1359 {
1360         return test_producer_consumer_ingress_order_test(
1361                                 worker_group_based_pipeline);
1362 }
1363
1364 static struct unit_test_suite eventdev_octeontx_testsuite  = {
1365         .suite_name = "eventdev octeontx unit test suite",
1366         .setup = testsuite_setup,
1367         .teardown = testsuite_teardown,
1368         .unit_test_cases = {
1369                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1370                         test_simple_enqdeq_ordered),
1371                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1372                         test_simple_enqdeq_atomic),
1373                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1374                         test_simple_enqdeq_parallel),
1375                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1376                         test_multi_queue_enq_single_port_deq),
1377                 TEST_CASE_ST(eventdev_setup_priority, eventdev_teardown,
1378                         test_multi_queue_priority),
1379                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1380                         test_multi_queue_enq_multi_port_deq),
1381                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1382                         test_queue_to_port_single_link),
1383                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1384                         test_queue_to_port_multi_link),
1385                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1386                         test_multi_port_flow_ordered_to_atomic),
1387                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1388                         test_multi_port_flow_ordered_to_ordered),
1389                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1390                         test_multi_port_flow_ordered_to_parallel),
1391                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1392                         test_multi_port_flow_atomic_to_atomic),
1393                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1394                         test_multi_port_flow_atomic_to_ordered),
1395                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1396                         test_multi_port_flow_atomic_to_parallel),
1397                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1398                         test_multi_port_flow_parallel_to_atomic),
1399                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1400                         test_multi_port_flow_parallel_to_ordered),
1401                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1402                         test_multi_port_flow_parallel_to_parallel),
1403                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1404                         test_multi_port_queue_ordered_to_atomic),
1405                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1406                         test_multi_port_queue_ordered_to_ordered),
1407                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1408                         test_multi_port_queue_ordered_to_parallel),
1409                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1410                         test_multi_port_queue_atomic_to_atomic),
1411                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1412                         test_multi_port_queue_atomic_to_ordered),
1413                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1414                         test_multi_port_queue_atomic_to_parallel),
1415                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1416                         test_multi_port_queue_parallel_to_atomic),
1417                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1418                         test_multi_port_queue_parallel_to_ordered),
1419                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1420                         test_multi_port_queue_parallel_to_parallel),
1421                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1422                         test_multi_port_flow_max_stages_random_sched_type),
1423                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1424                         test_multi_port_queue_max_stages_random_sched_type),
1425                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1426                         test_multi_port_mixed_max_stages_random_sched_type),
1427                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1428                         test_flow_producer_consumer_ingress_order_test),
1429                 TEST_CASE_ST(eventdev_setup, eventdev_teardown,
1430                         test_queue_producer_consumer_ingress_order_test),
1431                 /* Tests with dequeue timeout */
1432                 TEST_CASE_ST(eventdev_setup_dequeue_timeout, eventdev_teardown,
1433                         test_multi_port_flow_ordered_to_atomic),
1434                 TEST_CASE_ST(eventdev_setup_dequeue_timeout, eventdev_teardown,
1435                         test_multi_port_queue_ordered_to_atomic),
1436                 TEST_CASES_END() /**< NULL terminate unit test array */
1437         }
1438 };
1439
1440 static int
1441 test_eventdev_octeontx(void)
1442 {
1443         return unit_test_suite_runner(&eventdev_octeontx_testsuite);
1444 }
1445
1446 REGISTER_TEST_COMMAND(eventdev_octeontx_autotest, test_eventdev_octeontx);