drivers/event/dlb/dlb_selftest.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2016-2020 Intel Corporation
   3  */
   4
   5 #include <stdio.h>
   6 #include <string.h>
   7 #include <stdint.h>
   8 #include <errno.h>
   9 #include <unistd.h>
  10 #include <sys/queue.h>
  11
  12 #include <rte_memory.h>
  13 #include <rte_memzone.h>
  14 #include <rte_launch.h>
  15 #include <rte_eal.h>
  16 #include <rte_lcore.h>
  17 #include <rte_debug.h>
  18 #include <rte_cycles.h>
  19 #include <rte_eventdev.h>
  20 #include <rte_mempool.h>
  21 #include <rte_mbuf.h>
  22
  23 #include "dlb_priv.h"
  24 #include "rte_pmd_dlb.h"
  25
  26 #define MAX_PORTS 32
  27 #define MAX_QIDS 32
  28 #define DEFAULT_NUM_SEQ_NUMS 32
  29
  30 static struct rte_mempool *eventdev_func_mempool;
  31 static int evdev;
  32
  33 struct test {
  34         struct rte_mempool *mbuf_pool;
  35         int nb_qids;
  36 };
  37
  38 /* initialization and config */
  39 static inline int
  40 init(struct test *t, int nb_queues, int nb_ports)
  41 {
  42         struct rte_event_dev_config config = {0};
  43         struct rte_event_dev_info info;
  44         int ret;
  45
  46         memset(t, 0, sizeof(*t));
  47
  48         t->mbuf_pool = eventdev_func_mempool;
  49
  50         if (rte_event_dev_info_get(evdev, &info)) {
  51                 printf("%d: Error querying device info\n", __LINE__);
  52                 return -1;
  53         }
  54
  55         config.nb_event_queues = nb_queues;
  56         config.nb_event_ports = nb_ports;
  57         config.nb_event_queue_flows = info.max_event_queue_flows;
  58         config.nb_events_limit = info.max_num_events;
  59         config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
  60         config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
  61         config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
  62         config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
  63
  64         ret = rte_event_dev_configure(evdev, &config);
  65         if (ret < 0)
  66                 printf("%d: Error configuring device\n", __LINE__);
  67
  68         return ret;
  69 }
  70
  71 static inline int
  72 create_ports(int num_ports)
  73 {
  74         int i;
  75
  76         if (num_ports > MAX_PORTS)
  77                 return -1;
  78
  79         for (i = 0; i < num_ports; i++) {
  80                 struct rte_event_port_conf conf;
  81
  82                 if (rte_event_port_default_conf_get(evdev, i, &conf)) {
  83                         printf("%d: Error querying default port conf\n",
  84                                __LINE__);
  85                         return -1;
  86                 }
  87
  88                 if (rte_event_port_setup(evdev, i, &conf) < 0) {
  89                         printf("%d: Error setting up port %d\n", __LINE__, i);
  90                         return -1;
  91                 }
  92         }
  93
  94         return 0;
  95 }
  96
  97 static inline int
  98 create_lb_qids(struct test *t, int num_qids, uint32_t flags)
  99 {
 100         int i;
 101
 102         for (i = t->nb_qids; i < t->nb_qids + num_qids; i++) {
 103                 struct rte_event_queue_conf conf;
 104
 105                 if (rte_event_queue_default_conf_get(evdev, i, &conf)) {
 106                         printf("%d: Error querying default queue conf\n",
 107                                __LINE__);
 108                         return -1;
 109                 }
 110
 111                 conf.schedule_type = flags;
 112
 113                 if (conf.schedule_type == RTE_SCHED_TYPE_PARALLEL)
 114                         conf.nb_atomic_order_sequences = 0;
 115                 else
 116                         conf.nb_atomic_order_sequences = DEFAULT_NUM_SEQ_NUMS;
 117
 118                 if (rte_event_queue_setup(evdev, i, &conf) < 0) {
 119                         printf("%d: error creating qid %d\n", __LINE__, i);
 120                         return -1;
 121                 }
 122         }
 123
 124         t->nb_qids += num_qids;
 125         if (t->nb_qids > MAX_QIDS)
 126                 return -1;
 127
 128         return 0;
 129 }
 130
 131 static inline int
 132 create_atomic_qids(struct test *t, int num_qids)
 133 {
 134         return create_lb_qids(t, num_qids, RTE_SCHED_TYPE_ATOMIC);
 135 }
 136
 137 /* destruction */
 138 static inline int
 139 cleanup(void)
 140 {
 141         rte_event_dev_stop(evdev);
 142         return rte_event_dev_close(evdev);
 143 };
 144
 145 static inline int
 146 enqueue_timeout(uint8_t port_id, struct rte_event *ev, uint64_t tmo_us)
 147 {
 148         const uint64_t start = rte_get_timer_cycles();
 149         const uint64_t ticks = (tmo_us * rte_get_timer_hz()) / 1E6;
 150
 151         while ((rte_get_timer_cycles() - start) < ticks) {
 152                 if (rte_event_enqueue_burst(evdev, port_id, ev, 1) == 1)
 153                         return 0;
 154
 155                 if (rte_errno != -ENOSPC)
 156                         return -1;
 157         }
 158
 159         return -1;
 160 }
 161
 162 static void
 163 flush(uint8_t id __rte_unused, struct rte_event event, void *arg __rte_unused)
 164 {
 165         rte_pktmbuf_free(event.mbuf);
 166 }
 167
 168 static int
 169 test_stop_flush(struct test *t) /* test to check we can properly flush events */
 170 {
 171         struct rte_event ev;
 172         uint32_t dequeue_depth;
 173         unsigned int i, count;
 174         uint8_t queue_id;
 175
 176         ev.op = RTE_EVENT_OP_NEW;
 177
 178         if (init(t, 2, 1) < 0 ||
 179             create_ports(1) < 0 ||
 180             create_atomic_qids(t, 2) < 0) {
 181                 printf("%d: Error initializing device\n", __LINE__);
 182                 return -1;
 183         }
 184
 185         if (rte_event_port_link(evdev, 0, NULL, NULL, 0) != 2) {
 186                 printf("%d: Error linking queues to the port\n", __LINE__);
 187                 goto err;
 188         }
 189
 190         if (rte_event_dev_start(evdev) < 0) {
 191                 printf("%d: Error with start call\n", __LINE__);
 192                 goto err;
 193         }
 194
 195         /* Unlink queue 1 so the PMD's stop callback has to cleanup an unlinked
 196          * queue.
 197          */
 198         queue_id = 1;
 199
 200         if (rte_event_port_unlink(evdev, 0, &queue_id, 1) != 1) {
 201                 printf("%d: Error unlinking queue 1 from port\n", __LINE__);
 202                 goto err;
 203         }
 204
 205         if (t->mbuf_pool)
 206                 count = rte_mempool_avail_count(t->mbuf_pool);
 207         else {
 208                 printf("%d: mbuf_pool is NULL\n", __LINE__);
 209                 goto err;
 210         }
 211
 212         if (rte_event_port_attr_get(evdev,
 213                                     0,
 214                                     RTE_EVENT_PORT_ATTR_DEQ_DEPTH,
 215                                     &dequeue_depth)) {
 216                 printf("%d: Error retrieveing dequeue depth\n", __LINE__);
 217                 goto err;
 218         }
 219
 220         /* Send QEs to queue 0 */
 221         for (i = 0; i < dequeue_depth + 1; i++) {
 222                 ev.mbuf = rte_pktmbuf_alloc(t->mbuf_pool);
 223                 ev.queue_id = 0;
 224                 ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 225
 226                 if (enqueue_timeout(0, &ev, 1000)) {
 227                         printf("%d: Error enqueuing events\n", __LINE__);
 228                         goto err;
 229                 }
 230         }
 231
 232         /* Send QEs to queue 1 */
 233         for (i = 0; i < dequeue_depth + 1; i++) {
 234                 ev.mbuf = rte_pktmbuf_alloc(t->mbuf_pool);
 235                 ev.queue_id = 1;
 236                 ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 237
 238                 if (enqueue_timeout(0, &ev, 1000)) {
 239                         printf("%d: Error enqueuing events\n", __LINE__);
 240                         goto err;
 241                 }
 242         }
 243
 244         /* Now the DLB is scheduling events from the port to the IQ, and at
 245          * least one event should be remaining in each queue.
 246          */
 247
 248         if (rte_event_dev_stop_flush_callback_register(evdev, flush, NULL)) {
 249                 printf("%d: Error installing the flush callback\n", __LINE__);
 250                 goto err;
 251         }
 252
 253         cleanup();
 254
 255         if (count != rte_mempool_avail_count(t->mbuf_pool)) {
 256                 printf("%d: Error executing the flush callback\n", __LINE__);
 257                 goto err;
 258         }
 259
 260         if (rte_event_dev_stop_flush_callback_register(evdev, NULL, NULL)) {
 261                 printf("%d: Error uninstalling the flush callback\n", __LINE__);
 262                 goto err;
 263         }
 264
 265         return 0;
 266 err:
 267         cleanup();
 268         return -1;
 269 }
 270
 271 static int
 272 test_single_link(void)
 273 {
 274         struct rte_event_dev_config config = {0};
 275         struct rte_event_queue_conf queue_conf;
 276         struct rte_event_port_conf port_conf;
 277         struct rte_event_dev_info info;
 278         uint8_t queue_id;
 279         int ret;
 280
 281         if (rte_event_dev_info_get(evdev, &info)) {
 282                 printf("%d: Error querying device info\n", __LINE__);
 283                 return -1;
 284         }
 285
 286         config.nb_event_queues = 2;
 287         config.nb_event_ports = 2;
 288         config.nb_single_link_event_port_queues = 1;
 289         config.nb_event_queue_flows = info.max_event_queue_flows;
 290         config.nb_events_limit = info.max_num_events;
 291         config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
 292         config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
 293         config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
 294         config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
 295
 296         ret = rte_event_dev_configure(evdev, &config);
 297         if (ret < 0) {
 298                 printf("%d: Error configuring device\n", __LINE__);
 299                 return -1;
 300         }
 301
 302         /* Create a directed port */
 303         if (rte_event_port_default_conf_get(evdev, 0, &port_conf)) {
 304                 printf("%d: Error querying default port conf\n", __LINE__);
 305                 goto err;
 306         }
 307
 308         port_conf.event_port_cfg = RTE_EVENT_PORT_CFG_SINGLE_LINK;
 309
 310         if (rte_event_port_setup(evdev, 0, &port_conf) < 0) {
 311                 printf("%d: port 0 setup expected to succeed\n", __LINE__);
 312                 goto err;
 313         }
 314
 315         /* Attempt to create another directed port */
 316         if (rte_event_port_setup(evdev, 1, &port_conf) == 0) {
 317                 printf("%d: port 1 setup expected to fail\n", __LINE__);
 318                 goto err;
 319         }
 320
 321         port_conf.event_port_cfg = 0;
 322
 323         /* Create a load-balanced port */
 324         if (rte_event_port_setup(evdev, 1, &port_conf) < 0) {
 325                 printf("%d: port 1 setup expected to succeed\n", __LINE__);
 326                 goto err;
 327         }
 328
 329         /* Create a directed queue */
 330         if (rte_event_queue_default_conf_get(evdev, 0, &queue_conf)) {
 331                 printf("%d: Error querying default queue conf\n", __LINE__);
 332                 goto err;
 333         }
 334
 335         queue_conf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
 336
 337         if (rte_event_queue_setup(evdev, 0, &queue_conf) < 0) {
 338                 printf("%d: queue 0 setup expected to succeed\n", __LINE__);
 339                 goto err;
 340         }
 341
 342         /* Attempt to create another directed queue */
 343         if (rte_event_queue_setup(evdev, 1, &queue_conf) == 0) {
 344                 printf("%d: queue 1 setup expected to fail\n", __LINE__);
 345                 goto err;
 346         }
 347
 348         /* Create a load-balanced queue */
 349         queue_conf.event_queue_cfg = 0;
 350
 351         if (rte_event_queue_setup(evdev, 1, &queue_conf) < 0) {
 352                 printf("%d: queue 1 setup expected to succeed\n", __LINE__);
 353                 goto err;
 354         }
 355
 356         /* Attempt to link directed and load-balanced resources */
 357         queue_id = 1;
 358         if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) == 1) {
 359                 printf("%d: port 0 link expected to fail\n", __LINE__);
 360                 goto err;
 361         }
 362
 363         queue_id = 0;
 364         if (rte_event_port_link(evdev, 1, &queue_id, NULL, 1) == 1) {
 365                 printf("%d: port 1 link expected to fail\n", __LINE__);
 366                 goto err;
 367         }
 368
 369         /* Link ports to queues */
 370         queue_id = 0;
 371         if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
 372                 printf("%d: port 0 link expected to succeed\n", __LINE__);
 373                 goto err;
 374         }
 375
 376         queue_id = 1;
 377         if (rte_event_port_link(evdev, 1, &queue_id, NULL, 1) != 1) {
 378                 printf("%d: port 1 link expected to succeed\n", __LINE__);
 379                 goto err;
 380         }
 381
 382         return rte_event_dev_close(evdev);
 383
 384 err:
 385         rte_event_dev_close(evdev);
 386         return -1;
 387 }
 388
 389 #define NUM_LDB_PORTS 64
 390 #define NUM_LDB_QUEUES 128
 391
 392 static int
 393 test_info_get(void)
 394 {
 395         struct rte_event_dev_config config = {0};
 396         struct rte_event_dev_info info;
 397         int ret;
 398
 399         if (rte_event_dev_info_get(evdev, &info)) {
 400                 printf("%d: Error querying device info\n", __LINE__);
 401                 return -1;
 402         }
 403
 404         if (info.max_event_ports != NUM_LDB_PORTS) {
 405                 printf("%d: Got %u ports, expected %u\n",
 406                        __LINE__, info.max_event_ports, NUM_LDB_PORTS);
 407                 goto err;
 408         }
 409
 410         if (info.max_event_queues != NUM_LDB_QUEUES) {
 411                 printf("%d: Got %u queues, expected %u\n",
 412                        __LINE__, info.max_event_queues, NUM_LDB_QUEUES);
 413                 goto err;
 414         }
 415
 416         config.nb_event_ports = info.max_event_ports;
 417         config.nb_event_queues = NUM_LDB_QUEUES + info.max_event_ports / 2;
 418         config.nb_single_link_event_port_queues = info.max_event_ports / 2;
 419         config.nb_event_queue_flows = info.max_event_queue_flows;
 420         config.nb_events_limit = info.max_num_events;
 421         config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
 422         config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
 423         config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
 424         config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
 425
 426         ret = rte_event_dev_configure(evdev, &config);
 427         if (ret < 0) {
 428                 printf("%d: Error configuring device\n", __LINE__);
 429                 return -1;
 430         }
 431
 432         if (rte_event_dev_info_get(evdev, &info)) {
 433                 printf("%d: Error querying device info\n", __LINE__);
 434                 goto err;
 435         }
 436
 437         /* The DLB PMD only reports load-balanced ports and queues in its
 438          * info_get function. Confirm that these values don't include the
 439          * directed port or queue counts.
 440          */
 441
 442         if (info.max_event_ports != NUM_LDB_PORTS) {
 443                 printf("%d: Got %u ports, expected %u\n",
 444                        __LINE__, info.max_event_ports, NUM_LDB_PORTS);
 445                 goto err;
 446         }
 447
 448         if (info.max_event_queues != NUM_LDB_QUEUES) {
 449                 printf("%d: Got %u queues, expected %u\n",
 450                        __LINE__, info.max_event_queues, NUM_LDB_QUEUES);
 451                 goto err;
 452         }
 453
 454         ret = rte_event_dev_close(evdev);
 455         if (ret) {
 456                 printf("rte_event_dev_close err %d\n", ret);
 457                 goto err;
 458         }
 459
 460         return 0;
 461
 462 err:
 463         rte_event_dev_close(evdev);
 464         return -1;
 465 }
 466
 467 static int
 468 test_reconfiguration_link(void)
 469 {
 470         struct rte_event_dev_config config = {0};
 471         struct rte_event_queue_conf queue_conf;
 472         struct rte_event_port_conf port_conf;
 473         struct rte_event_dev_info info;
 474         uint8_t queue_id;
 475         int ret, i;
 476
 477         if (rte_event_dev_info_get(evdev, &info)) {
 478                 printf("%d: Error querying device info\n", __LINE__);
 479                 return -1;
 480         }
 481
 482         config.nb_event_queues = 2;
 483         config.nb_event_ports = 2;
 484         config.nb_single_link_event_port_queues = 0;
 485         config.nb_event_queue_flows = info.max_event_queue_flows;
 486         config.nb_events_limit = info.max_num_events;
 487         config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
 488         config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
 489         config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
 490         config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
 491
 492         /* Configure the device with 2 LDB ports and 2 LDB queues */
 493         ret = rte_event_dev_configure(evdev, &config);
 494         if (ret < 0) {
 495                 printf("%d: Error configuring device\n", __LINE__);
 496                 return -1;
 497         }
 498
 499         /* Configure the ports and queues */
 500         if (rte_event_port_default_conf_get(evdev, 0, &port_conf)) {
 501                 printf("%d: Error querying default port conf\n", __LINE__);
 502                 goto err;
 503         }
 504
 505         for (i = 0; i < 2; i++) {
 506                 if (rte_event_port_setup(evdev, i, &port_conf) < 0) {
 507                         printf("%d: port %d setup expected to succeed\n",
 508                                __LINE__, i);
 509                         goto err;
 510                 }
 511         }
 512
 513         if (rte_event_queue_default_conf_get(evdev, 0, &queue_conf)) {
 514                 printf("%d: Error querying default queue conf\n", __LINE__);
 515                 goto err;
 516         }
 517
 518         for (i = 0; i < 2; i++) {
 519                 if (rte_event_queue_setup(evdev, i, &queue_conf) < 0) {
 520                         printf("%d: queue %d setup expected to succeed\n",
 521                                __LINE__, i);
 522                         goto err;
 523                 }
 524         }
 525
 526         /* Link P0->Q0 and P1->Q1 */
 527         for (i = 0; i < 2; i++) {
 528                 queue_id = i;
 529
 530                 if (rte_event_port_link(evdev, i, &queue_id, NULL, 1) != 1) {
 531                         printf("%d: port %d link expected to succeed\n",
 532                                __LINE__, i);
 533                         goto err;
 534                 }
 535         }
 536
 537         /* Start the device */
 538         if (rte_event_dev_start(evdev) < 0) {
 539                 printf("%d: device start failed\n", __LINE__);
 540                 goto err;
 541         }
 542
 543         /* Stop the device */
 544         rte_event_dev_stop(evdev);
 545
 546         /* Reconfigure device */
 547         ret = rte_event_dev_configure(evdev, &config);
 548         if (ret < 0) {
 549                 printf("%d: Error re-configuring device\n", __LINE__);
 550                 return -1;
 551         }
 552
 553         /* Configure P1 and Q1, leave P0 and Q0 to be configured by the PMD. */
 554         if (rte_event_port_setup(evdev, 1, &port_conf) < 0) {
 555                 printf("%d: port 1 setup expected to succeed\n",
 556                        __LINE__);
 557                 goto err;
 558         }
 559
 560         if (rte_event_queue_setup(evdev, 1, &queue_conf) < 0) {
 561                 printf("%d: queue 1 setup expected to succeed\n",
 562                        __LINE__);
 563                 goto err;
 564         }
 565
 566         /* Link P0->Q0 and Q1 */
 567         for (i = 0; i < 2; i++) {
 568                 queue_id = i;
 569
 570                 if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
 571                         printf("%d: P0->Q%d link expected to succeed\n",
 572                                __LINE__, i);
 573                         goto err;
 574                 }
 575         }
 576
 577         /* Link P1->Q0 and Q1 */
 578         for (i = 0; i < 2; i++) {
 579                 queue_id = i;
 580
 581                 if (rte_event_port_link(evdev, 1, &queue_id, NULL, 1) != 1) {
 582                         printf("%d: P1->Q%d link expected to succeed\n",
 583                                __LINE__, i);
 584                         goto err;
 585                 }
 586         }
 587
 588         /* Start the device */
 589         if (rte_event_dev_start(evdev) < 0) {
 590                 printf("%d: device start failed\n", __LINE__);
 591                 goto err;
 592         }
 593
 594         /* Stop the device */
 595         rte_event_dev_stop(evdev);
 596
 597         /* Configure device with 2 DIR ports and 2 DIR queues */
 598         config.nb_single_link_event_port_queues = 2;
 599
 600         ret = rte_event_dev_configure(evdev, &config);
 601         if (ret < 0) {
 602                 printf("%d: Error configuring device\n", __LINE__);
 603                 return -1;
 604         }
 605
 606         /* Configure the ports and queues */
 607         port_conf.event_port_cfg = RTE_EVENT_PORT_CFG_SINGLE_LINK;
 608
 609         for (i = 0; i < 2; i++) {
 610                 if (rte_event_port_setup(evdev, i, &port_conf) < 0) {
 611                         printf("%d: port %d setup expected to succeed\n",
 612                                __LINE__, i);
 613                         goto err;
 614                 }
 615         }
 616
 617         queue_conf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
 618
 619         for (i = 0; i < 2; i++) {
 620                 if (rte_event_queue_setup(evdev, i, &queue_conf) < 0) {
 621                         printf("%d: queue %d setup expected to succeed\n",
 622                                __LINE__, i);
 623                         goto err;
 624                 }
 625         }
 626
 627         /* Link P0->Q0 and P1->Q1 */
 628         for (i = 0; i < 2; i++) {
 629                 queue_id = i;
 630
 631                 if (rte_event_port_link(evdev, i, &queue_id, NULL, 1) != 1) {
 632                         printf("%d: port %d link expected to succeed\n",
 633                                __LINE__, i);
 634                         goto err;
 635                 }
 636         }
 637
 638         /* Start the device */
 639         if (rte_event_dev_start(evdev) < 0) {
 640                 printf("%d: device start failed\n", __LINE__);
 641                 goto err;
 642         }
 643
 644         /* Stop the device */
 645         rte_event_dev_stop(evdev);
 646
 647         /* Reconfigure device */
 648         ret = rte_event_dev_configure(evdev, &config);
 649         if (ret < 0) {
 650                 printf("%d: Error re-configuring device\n", __LINE__);
 651                 return -1;
 652         }
 653
 654         /* Configure P1 and Q0, leave P0 and Q1 to be configured by the PMD. */
 655         if (rte_event_port_setup(evdev, 1, &port_conf) < 0) {
 656                 printf("%d: port 1 setup expected to succeed\n",
 657                        __LINE__);
 658                 goto err;
 659         }
 660
 661         if (rte_event_queue_setup(evdev, 0, &queue_conf) < 0) {
 662                 printf("%d: queue 1 setup expected to succeed\n",
 663                        __LINE__);
 664                 goto err;
 665         }
 666
 667         /* Link P0->Q1 */
 668         queue_id = 1;
 669
 670         if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
 671                 printf("%d: P0->Q%d link expected to succeed\n",
 672                        __LINE__, i);
 673                 goto err;
 674         }
 675
 676         /* Link P1->Q0 */
 677         queue_id = 0;
 678
 679         if (rte_event_port_link(evdev, 1, &queue_id, NULL, 1) != 1) {
 680                 printf("%d: P1->Q%d link expected to succeed\n",
 681                        __LINE__, i);
 682                 goto err;
 683         }
 684
 685         /* Start the device */
 686         if (rte_event_dev_start(evdev) < 0) {
 687                 printf("%d: device start failed\n", __LINE__);
 688                 goto err;
 689         }
 690
 691         rte_event_dev_stop(evdev);
 692
 693         config.nb_event_queues = 5;
 694         config.nb_event_ports = 5;
 695         config.nb_single_link_event_port_queues = 1;
 696
 697         ret = rte_event_dev_configure(evdev, &config);
 698         if (ret < 0) {
 699                 printf("%d: Error re-configuring device\n", __LINE__);
 700                 return -1;
 701         }
 702
 703         for (i = 0; i < config.nb_event_queues - 1; i++) {
 704                 port_conf.event_port_cfg = 0;
 705                 queue_conf.event_queue_cfg = 0;
 706
 707                 if (rte_event_port_setup(evdev, i, &port_conf) < 0) {
 708                         printf("%d: port %d setup expected to succeed\n",
 709                                __LINE__, i);
 710                         goto err;
 711                 }
 712
 713                 if (rte_event_queue_setup(evdev, i, &queue_conf) < 0) {
 714                         printf("%d: queue %d setup expected to succeed\n",
 715                                __LINE__, i);
 716                         goto err;
 717                 }
 718
 719                 queue_id = i;
 720
 721                 if (rte_event_port_link(evdev, i, &queue_id, NULL, 1) != 1) {
 722                         printf("%d: P%d->Q%d link expected to succeed\n",
 723                                __LINE__, i, i);
 724                         goto err;
 725                 }
 726         }
 727
 728         port_conf.event_port_cfg = RTE_EVENT_PORT_CFG_SINGLE_LINK;
 729         queue_conf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
 730
 731         if (rte_event_port_setup(evdev, i, &port_conf) < 0) {
 732                 printf("%d: port %d setup expected to succeed\n",
 733                        __LINE__, i);
 734                 goto err;
 735         }
 736
 737         if (rte_event_queue_setup(evdev, i, &queue_conf) < 0) {
 738                 printf("%d: queue %d setup expected to succeed\n",
 739                        __LINE__, i);
 740                 goto err;
 741         }
 742
 743         queue_id = i;
 744
 745         if (rte_event_port_link(evdev, i, &queue_id, NULL, 1) != 1) {
 746                 printf("%d: P%d->Q%d link expected to succeed\n",
 747                        __LINE__, i, i);
 748                 goto err;
 749         }
 750
 751         /* Start the device */
 752         if (rte_event_dev_start(evdev) < 0) {
 753                 printf("%d: device start failed\n", __LINE__);
 754                 goto err;
 755         }
 756
 757         /* Stop the device */
 758         rte_event_dev_stop(evdev);
 759
 760         config.nb_event_ports += 1;
 761
 762         /* Reconfigure device with 1 more load-balanced port */
 763         ret = rte_event_dev_configure(evdev, &config);
 764         if (ret < 0) {
 765                 printf("%d: Error re-configuring device\n", __LINE__);
 766                 return -1;
 767         }
 768
 769         port_conf.event_port_cfg = 0;
 770
 771         /* Configure the new port */
 772         if (rte_event_port_setup(evdev, config.nb_event_ports - 1,
 773                                  &port_conf) < 0) {
 774                 printf("%d: port 1 setup expected to succeed\n",
 775                        __LINE__);
 776                 goto err;
 777         }
 778
 779         /* Start the device */
 780         if (rte_event_dev_start(evdev) < 0) {
 781                 printf("%d: device start failed\n", __LINE__);
 782                 goto err;
 783         }
 784
 785         cleanup();
 786         return 0;
 787
 788 err:
 789         cleanup();
 790         return -1;
 791 }
 792
 793 static int
 794 test_load_balanced_traffic(void)
 795 {
 796         uint64_t timeout;
 797         struct rte_event_dev_config config = {0};
 798         struct rte_event_queue_conf queue_conf;
 799         struct rte_event_port_conf port_conf;
 800         struct rte_event_dev_info info;
 801         struct rte_event ev;
 802         uint8_t queue_id;
 803         int ret;
 804
 805         if (rte_event_dev_info_get(evdev, &info)) {
 806                 printf("%d: Error querying device info\n", __LINE__);
 807                 return -1;
 808         }
 809
 810         config.nb_event_queues = 1;
 811         config.nb_event_ports = 1;
 812         config.nb_single_link_event_port_queues = 0;
 813         config.nb_event_queue_flows = info.max_event_queue_flows;
 814         config.nb_events_limit = info.max_num_events;
 815         config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
 816         config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
 817         config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
 818         config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
 819
 820         /* Configure the device with 1 LDB port and queue */
 821         ret = rte_event_dev_configure(evdev, &config);
 822         if (ret < 0) {
 823                 printf("%d: Error configuring device\n", __LINE__);
 824                 return -1;
 825         }
 826
 827         /* Configure the ports and queues */
 828         if (rte_event_port_default_conf_get(evdev, 0, &port_conf)) {
 829                 printf("%d: Error querying default port conf\n", __LINE__);
 830                 goto err;
 831         }
 832
 833         if (rte_event_port_setup(evdev, 0, &port_conf) < 0) {
 834                 printf("%d: port 0 setup expected to succeed\n",
 835                        __LINE__);
 836                 goto err;
 837         }
 838
 839         if (rte_event_queue_default_conf_get(evdev, 0, &queue_conf)) {
 840                 printf("%d: Error querying default queue conf\n", __LINE__);
 841                 goto err;
 842         }
 843
 844         if (rte_event_queue_setup(evdev, 0, &queue_conf) < 0) {
 845                 printf("%d: queue 0 setup expected to succeed\n",
 846                        __LINE__);
 847                 goto err;
 848         }
 849
 850         /* Link P0->Q0 */
 851         queue_id = 0;
 852
 853         if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
 854                 printf("%d: port 0 link expected to succeed\n",
 855                        __LINE__);
 856                 goto err;
 857         }
 858
 859         /* Start the device */
 860         if (rte_event_dev_start(evdev) < 0) {
 861                 printf("%d: device start failed\n", __LINE__);
 862                 goto err;
 863         }
 864
 865         /* Enqueue 1 NEW event */
 866         ev.op = RTE_EVENT_OP_NEW;
 867         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 868         ev.queue_id = 0;
 869         ev.priority = 0;
 870         ev.u64 = 0;
 871
 872         if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
 873                 printf("%d: NEW enqueue expected to succeed\n",
 874                        __LINE__);
 875                 goto err;
 876         }
 877
 878         /* Dequeue and enqueue 1 FORWARD event */
 879         timeout = 0xFFFFFFFFF;
 880         if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
 881                 printf("%d: event dequeue expected to succeed\n",
 882                        __LINE__);
 883                 goto err;
 884         }
 885
 886         ev.op = RTE_EVENT_OP_FORWARD;
 887
 888         if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
 889                 printf("%d: NEW enqueue expected to succeed\n",
 890                        __LINE__);
 891                 goto err;
 892         }
 893
 894         /* Dequeue and enqueue 1 RELEASE operation */
 895         if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
 896                 printf("%d: event dequeue expected to succeed\n",
 897                        __LINE__);
 898                 goto err;
 899         }
 900
 901         ev.op = RTE_EVENT_OP_RELEASE;
 902
 903         if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
 904                 printf("%d: NEW enqueue expected to succeed\n",
 905                        __LINE__);
 906                 goto err;
 907         }
 908
 909         cleanup();
 910         return 0;
 911
 912 err:
 913         cleanup();
 914         return -1;
 915 }
 916
 917 static int
 918 test_directed_traffic(void)
 919 {
 920         uint64_t timeout;
 921         struct rte_event_dev_config config = {0};
 922         struct rte_event_queue_conf queue_conf;
 923         struct rte_event_port_conf port_conf;
 924         struct rte_event_dev_info info;
 925         struct rte_event ev;
 926         uint8_t queue_id;
 927         int ret;
 928
 929         if (rte_event_dev_info_get(evdev, &info)) {
 930                 printf("%d: Error querying device info\n", __LINE__);
 931                 return -1;
 932         }
 933
 934         config.nb_event_queues = 1;
 935         config.nb_event_ports = 1;
 936         config.nb_single_link_event_port_queues = 1;
 937         config.nb_event_queue_flows = info.max_event_queue_flows;
 938         config.nb_events_limit = info.max_num_events;
 939         config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
 940         config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
 941         config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
 942         config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
 943
 944         /* Configure the device with 1 DIR port and queue */
 945         ret = rte_event_dev_configure(evdev, &config);
 946         if (ret < 0) {
 947                 printf("%d: Error configuring device\n", __LINE__);
 948                 return -1;
 949         }
 950
 951         /* Configure the ports and queues */
 952         if (rte_event_port_default_conf_get(evdev, 0, &port_conf)) {
 953                 printf("%d: Error querying default port conf\n", __LINE__);
 954                 goto err;
 955         }
 956
 957         port_conf.event_port_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
 958
 959         if (rte_event_port_setup(evdev, 0, &port_conf) < 0) {
 960                 printf("%d: port 0 setup expected to succeed\n",
 961                        __LINE__);
 962                 goto err;
 963         }
 964
 965         if (rte_event_queue_default_conf_get(evdev, 0, &queue_conf)) {
 966                 printf("%d: Error querying default queue conf\n", __LINE__);
 967                 goto err;
 968         }
 969
 970         queue_conf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
 971
 972         if (rte_event_queue_setup(evdev, 0, &queue_conf) < 0) {
 973                 printf("%d: queue 0 setup expected to succeed\n",
 974                        __LINE__);
 975                 goto err;
 976         }
 977
 978         /* Link P0->Q0 */
 979         queue_id = 0;
 980
 981         if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
 982                 printf("%d: port 0 link expected to succeed\n",
 983                        __LINE__);
 984                 goto err;
 985         }
 986
 987         /* Start the device */
 988         if (rte_event_dev_start(evdev) < 0) {
 989                 printf("%d: device start failed\n", __LINE__);
 990                 goto err;
 991         }
 992
 993         /* Enqueue 1 NEW event */
 994         ev.op = RTE_EVENT_OP_NEW;
 995         ev.queue_id = 0;
 996         ev.priority = 0;
 997         ev.u64 = 0;
 998
 999         if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1000                 printf("%d: NEW enqueue expected to succeed\n",
1001                        __LINE__);
1002                 goto err;
1003         }
1004
1005         /* Dequeue and enqueue 1 FORWARD event */
1006         timeout = 0xFFFFFFFFF;
1007         if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
1008                 printf("%d: event dequeue expected to succeed\n",
1009                        __LINE__);
1010                 goto err;
1011         }
1012
1013         if (ev.queue_id != 0) {
1014                 printf("%d: invalid dequeued event queue ID (%d)\n",
1015                        __LINE__, ev.queue_id);
1016                 goto err;
1017         }
1018
1019         ev.op = RTE_EVENT_OP_FORWARD;
1020
1021         if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1022                 printf("%d: NEW enqueue expected to succeed\n",
1023                        __LINE__);
1024                 goto err;
1025         }
1026
1027         /* Dequeue and enqueue 1 RELEASE operation */
1028         if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
1029                 printf("%d: event dequeue expected to succeed\n",
1030                        __LINE__);
1031                 goto err;
1032         }
1033
1034         ev.op = RTE_EVENT_OP_RELEASE;
1035
1036         if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1037                 printf("%d: NEW enqueue expected to succeed\n",
1038                        __LINE__);
1039                 goto err;
1040         }
1041
1042         cleanup();
1043         return 0;
1044
1045 err:
1046         cleanup();
1047         return -1;
1048 }
1049
1050 static int
1051 test_deferred_sched(void)
1052 {
1053         uint64_t timeout;
1054         struct rte_event_dev_config config = {0};
1055         struct rte_event_queue_conf queue_conf;
1056         struct rte_event_port_conf port_conf;
1057         struct rte_event_dev_info info;
1058         const int num_events = 128;
1059         struct rte_event ev;
1060         uint8_t queue_id;
1061         int ret, i;
1062
1063         if (rte_event_dev_info_get(evdev, &info)) {
1064                 printf("%d: Error querying device info\n", __LINE__);
1065                 return -1;
1066         }
1067
1068         config.nb_event_queues = 1;
1069         config.nb_event_ports = 2;
1070         config.nb_single_link_event_port_queues = 0;
1071         config.nb_event_queue_flows = info.max_event_queue_flows;
1072         config.nb_events_limit = info.max_num_events;
1073         config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
1074         config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
1075         config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
1076         config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
1077
1078         /* Configure the device with 2 LDB ports and 1 queue */
1079         ret = rte_event_dev_configure(evdev, &config);
1080         if (ret < 0) {
1081                 printf("%d: Error configuring device\n", __LINE__);
1082                 return -1;
1083         }
1084
1085         ret = rte_pmd_dlb_set_token_pop_mode(evdev, 0, DEFERRED_POP);
1086         if (ret < 0) {
1087                 printf("%d: Error setting deferred scheduling\n", __LINE__);
1088                 goto err;
1089         }
1090
1091         ret = rte_pmd_dlb_set_token_pop_mode(evdev, 1, DEFERRED_POP);
1092         if (ret < 0) {
1093                 printf("%d: Error setting deferred scheduling\n", __LINE__);
1094                 goto err;
1095         }
1096
1097         /* Configure the ports and queues */
1098         if (rte_event_port_default_conf_get(evdev, 0, &port_conf)) {
1099                 printf("%d: Error querying default port conf\n", __LINE__);
1100                 goto err;
1101         }
1102
1103         port_conf.dequeue_depth = 1;
1104
1105         if (rte_event_port_setup(evdev, 0, &port_conf) < 0) {
1106                 printf("%d: port 0 setup expected to succeed\n",
1107                        __LINE__);
1108                 goto err;
1109         }
1110
1111         if (rte_event_port_setup(evdev, 1, &port_conf) < 0) {
1112                 printf("%d: port 1 setup expected to succeed\n",
1113                        __LINE__);
1114                 goto err;
1115         }
1116
1117         if (rte_event_queue_default_conf_get(evdev, 0, &queue_conf)) {
1118                 printf("%d: Error querying default queue conf\n", __LINE__);
1119                 goto err;
1120         }
1121
1122         queue_conf.schedule_type = RTE_SCHED_TYPE_PARALLEL;
1123         queue_conf.nb_atomic_order_sequences = 0;
1124
1125         if (rte_event_queue_setup(evdev, 0, &queue_conf) < 0) {
1126                 printf("%d: queue 0 setup expected to succeed\n",
1127                        __LINE__);
1128                 goto err;
1129         }
1130
1131         /* Link P0->Q0 and P1->Q0 */
1132         queue_id = 0;
1133
1134         if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
1135                 printf("%d: port 0 link expected to succeed\n",
1136                        __LINE__);
1137                 goto err;
1138         }
1139
1140         if (rte_event_port_link(evdev, 1, &queue_id, NULL, 1) != 1) {
1141                 printf("%d: port 1 link expected to succeed\n",
1142                        __LINE__);
1143                 goto err;
1144         }
1145
1146         /* Start the device */
1147         if (rte_event_dev_start(evdev) < 0) {
1148                 printf("%d: device start failed\n", __LINE__);
1149                 goto err;
1150         }
1151
1152         /* Enqueue 128 NEW events */
1153         ev.op = RTE_EVENT_OP_NEW;
1154         ev.sched_type = RTE_SCHED_TYPE_PARALLEL;
1155         ev.queue_id = 0;
1156         ev.priority = 0;
1157         ev.u64 = 0;
1158
1159         for (i = 0; i < num_events; i++) {
1160                 if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1161                         printf("%d: NEW enqueue expected to succeed\n",
1162                                __LINE__);
1163                         goto err;
1164                 }
1165         }
1166
1167         /* Dequeue two events from port 0 (dequeue_depth * 2 due to the
1168          * reserved token scheme)
1169          */
1170         timeout = 0xFFFFFFFFF;
1171         if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
1172                 printf("%d: event dequeue expected to succeed\n",
1173                        __LINE__);
1174                 goto err;
1175         }
1176
1177         if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
1178                 printf("%d: event dequeue expected to succeed\n",
1179                        __LINE__);
1180                 goto err;
1181         }
1182
1183         /* Dequeue (and release) all other events from port 1. Deferred
1184          * scheduling ensures no other events are scheduled to port 0 without a
1185          * subsequent rte_event_dequeue_burst() call.
1186          */
1187         for (i = 0; i < num_events - 2; i++) {
1188                 if (rte_event_dequeue_burst(evdev, 1, &ev, 1, timeout) != 1) {
1189                         printf("%d: event dequeue expected to succeed\n",
1190                                __LINE__);
1191                         goto err;
1192                 }
1193
1194                 ev.op = RTE_EVENT_OP_RELEASE;
1195
1196                 if (rte_event_enqueue_burst(evdev, 1, &ev, 1) != 1) {
1197                         printf("%d: RELEASE enqueue expected to succeed\n",
1198                                __LINE__);
1199                         goto err;
1200                 }
1201         }
1202
1203         cleanup();
1204         return 0;
1205
1206 err:
1207         cleanup();
1208         return -1;
1209 }
1210
1211 static int
1212 test_delayed_pop(void)
1213 {
1214         uint64_t timeout;
1215         struct rte_event_dev_config config = {0};
1216         struct rte_event_queue_conf queue_conf;
1217         struct rte_event_port_conf port_conf;
1218         struct rte_event_dev_info info;
1219         int ret, i, num_events;
1220         struct rte_event ev;
1221         uint8_t queue_id;
1222
1223         if (rte_event_dev_info_get(evdev, &info)) {
1224                 printf("%d: Error querying device info\n", __LINE__);
1225                 return -1;
1226         }
1227
1228         config.nb_event_queues = 1;
1229         config.nb_event_ports = 1;
1230         config.nb_single_link_event_port_queues = 0;
1231         config.nb_event_queue_flows = info.max_event_queue_flows;
1232         config.nb_events_limit = info.max_num_events;
1233         config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
1234         config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
1235         config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
1236         config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
1237
1238         /* Configure the device with 1 LDB port and queue */
1239         ret = rte_event_dev_configure(evdev, &config);
1240         if (ret < 0) {
1241                 printf("%d: Error configuring device\n", __LINE__);
1242                 return -1;
1243         }
1244
1245         ret = rte_pmd_dlb_set_token_pop_mode(evdev, 0, DELAYED_POP);
1246         if (ret < 0) {
1247                 printf("%d: Error setting deferred scheduling\n", __LINE__);
1248                 goto err;
1249         }
1250
1251         /* Configure the ports and queues */
1252         if (rte_event_port_default_conf_get(evdev, 0, &port_conf)) {
1253                 printf("%d: Error querying default port conf\n", __LINE__);
1254                 goto err;
1255         }
1256
1257         port_conf.dequeue_depth = 16;
1258         port_conf.event_port_cfg = RTE_EVENT_PORT_CFG_DISABLE_IMPL_REL;
1259
1260         if (rte_event_port_setup(evdev, 0, &port_conf) < 0) {
1261                 printf("%d: port 0 setup expected to succeed\n",
1262                        __LINE__);
1263                 goto err;
1264         }
1265
1266         if (rte_event_queue_default_conf_get(evdev, 0, &queue_conf)) {
1267                 printf("%d: Error querying default queue conf\n", __LINE__);
1268                 goto err;
1269         }
1270
1271         if (rte_event_queue_setup(evdev, 0, &queue_conf) < 0) {
1272                 printf("%d: queue 0 setup expected to succeed\n",
1273                        __LINE__);
1274                 goto err;
1275         }
1276
1277         /* Link P0->Q0 */
1278         queue_id = 0;
1279
1280         if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
1281                 printf("%d: port 0 link expected to succeed\n",
1282                        __LINE__);
1283                 goto err;
1284         }
1285
1286         /* Start the device */
1287         if (rte_event_dev_start(evdev) < 0) {
1288                 printf("%d: device start failed\n", __LINE__);
1289                 goto err;
1290         }
1291
1292         num_events = 2 * port_conf.dequeue_depth;
1293
1294         /* Enqueue 2 * dequeue_depth NEW events. Due to the PMD's reserved
1295          * token scheme, the port will initially behave as though its
1296          * dequeue_depth is twice the requested size.
1297          */
1298         ev.op = RTE_EVENT_OP_NEW;
1299         ev.sched_type = RTE_SCHED_TYPE_PARALLEL;
1300         ev.queue_id = 0;
1301         ev.priority = 0;
1302         ev.u64 = 0;
1303
1304         for (i = 0; i < num_events; i++) {
1305                 if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1306                         printf("%d: NEW enqueue expected to succeed\n",
1307                                __LINE__);
1308                         goto err;
1309                 }
1310         }
1311
1312         /* Flush these events out of the CQ */
1313         timeout = 0xFFFFFFFFF;
1314
1315         for (i = 0; i < num_events; i++) {
1316                 if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
1317                         printf("%d: event dequeue expected to succeed\n",
1318                                __LINE__);
1319                         goto err;
1320                 }
1321         }
1322
1323         ev.op = RTE_EVENT_OP_RELEASE;
1324
1325         for (i = 0; i < num_events; i++) {
1326                 if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1327                         printf("%d: RELEASE enqueue expected to succeed\n",
1328                                __LINE__);
1329                         goto err;
1330                 }
1331         }
1332
1333         /* Enqueue 2 * dequeue_depth NEW events again */
1334         ev.op = RTE_EVENT_OP_NEW;
1335         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
1336         ev.queue_id = 0;
1337         ev.priority = 0;
1338         ev.u64 = 0;
1339
1340         for (i = 0; i < num_events; i++) {
1341                 if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1342                         printf("%d: NEW enqueue expected to succeed\n",
1343                                __LINE__);
1344                         goto err;
1345                 }
1346         }
1347
1348         /* Dequeue dequeue_depth events but only release dequeue_depth - 1.
1349          * Delayed pop won't perform the pop and no more events will be
1350          * scheduled.
1351          */
1352         for (i = 0; i < port_conf.dequeue_depth; i++) {
1353                 if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
1354                         printf("%d: event dequeue expected to succeed\n",
1355                                __LINE__);
1356                         goto err;
1357                 }
1358         }
1359
1360         ev.op = RTE_EVENT_OP_RELEASE;
1361
1362         for (i = 0; i < port_conf.dequeue_depth - 1; i++) {
1363                 if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1364                         printf("%d: RELEASE enqueue expected to succeed\n",
1365                                __LINE__);
1366                         goto err;
1367                 }
1368         }
1369
1370         timeout = 0x10000;
1371
1372         ret = rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout);
1373         if (ret != 0) {
1374                 printf("%d: event dequeue expected to fail (ret = %d)\n",
1375                        __LINE__, ret);
1376                 goto err;
1377         }
1378
1379         /* Release one more event. This will trigger the token pop, and
1380          * another batch of events will be scheduled to the device.
1381          */
1382         ev.op = RTE_EVENT_OP_RELEASE;
1383
1384         if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1385                 printf("%d: RELEASE enqueue expected to succeed\n",
1386                        __LINE__);
1387                 goto err;
1388         }
1389
1390         timeout = 0xFFFFFFFFF;
1391
1392         for (i = 0; i < port_conf.dequeue_depth; i++) {
1393                 if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
1394                         printf("%d: event dequeue expected to succeed\n",
1395                                __LINE__);
1396                         goto err;
1397                 }
1398         }
1399
1400         cleanup();
1401         return 0;
1402
1403 err:
1404         cleanup();
1405         return -1;
1406 }
1407
1408 static int
1409 do_selftest(void)
1410 {
1411         struct test t;
1412         int ret;
1413
1414         /* Only create mbuf pool once, reuse for each test run */
1415         if (!eventdev_func_mempool) {
1416                 eventdev_func_mempool =
1417                         rte_pktmbuf_pool_create("EVENTDEV_DLB_SA_MBUF_POOL",
1418                                                 (1 << 12), /* 4k buffers */
1419                                                 32 /*MBUF_CACHE_SIZE*/,
1420                                                 0,
1421                                                 512, /* use very small mbufs */
1422                                                 rte_socket_id());
1423                 if (!eventdev_func_mempool) {
1424                         printf("ERROR creating mempool\n");
1425                         goto test_fail;
1426                 }
1427         }
1428         t.mbuf_pool = eventdev_func_mempool;
1429
1430         printf("*** Running Stop Flush test...\n");
1431         ret = test_stop_flush(&t);
1432         if (ret != 0) {
1433                 printf("ERROR - Stop Flush test FAILED.\n");
1434                 return ret;
1435         }
1436
1437         printf("*** Running Single Link test...\n");
1438         ret = test_single_link();
1439         if (ret != 0) {
1440                 printf("ERROR - Single Link test FAILED.\n");
1441
1442                 goto test_fail;
1443         }
1444
1445         printf("*** Running Info Get test...\n");
1446         ret = test_info_get();
1447         if (ret != 0) {
1448                 printf("ERROR - Stop Flush test FAILED.\n");
1449                 return ret;
1450         }
1451
1452         printf("*** Running Reconfiguration Link test...\n");
1453         ret = test_reconfiguration_link();
1454         if (ret != 0) {
1455                 printf("ERROR - Reconfiguration Link test FAILED.\n");
1456
1457                 goto test_fail;
1458         }
1459
1460         printf("*** Running Load-Balanced Traffic test...\n");
1461         ret = test_load_balanced_traffic();
1462         if (ret != 0) {
1463                 printf("ERROR - Load-Balanced Traffic test FAILED.\n");
1464
1465                 goto test_fail;
1466         }
1467
1468         printf("*** Running Directed Traffic test...\n");
1469         ret = test_directed_traffic();
1470         if (ret != 0) {
1471                 printf("ERROR - Directed Traffic test FAILED.\n");
1472
1473                 goto test_fail;
1474         }
1475
1476         printf("*** Running Deferred Scheduling test...\n");
1477         ret = test_deferred_sched();
1478         if (ret != 0) {
1479                 printf("ERROR - Deferred Scheduling test FAILED.\n");
1480
1481                 goto test_fail;
1482         }
1483
1484         printf("*** Running Delayed Pop test...\n");
1485         ret = test_delayed_pop();
1486         if (ret != 0) {
1487                 printf("ERROR - Delayed Pop test FAILED.\n");
1488
1489                 goto test_fail;
1490         }
1491
1492         return 0;
1493
1494 test_fail:
1495         return -1;
1496 }
1497
1498 int
1499 test_dlb_eventdev(void)
1500 {
1501         const char *dlb_eventdev_name = "dlb_event";
1502         uint8_t num_evdevs = rte_event_dev_count();
1503         int i, ret = 0;
1504         int found = 0, skipped = 0, passed = 0, failed = 0;
1505         struct rte_event_dev_info info;
1506
1507         for (i = 0; found + skipped < num_evdevs && i < RTE_EVENT_MAX_DEVS;
1508              i++) {
1509                 ret = rte_event_dev_info_get(i, &info);
1510                 if (ret < 0)
1511                         continue;
1512
1513                 /* skip non-dlb event devices */
1514                 if (strncmp(info.driver_name, dlb_eventdev_name,
1515                             sizeof(*info.driver_name)) != 0) {
1516                         skipped++;
1517                         continue;
1518                 }
1519
1520                 evdev = rte_event_dev_get_dev_id(info.driver_name);
1521                 if (evdev < 0) {
1522                         printf("Could not get dev_id for eventdev with name %s, i=%d\n",
1523                                info.driver_name, i);
1524                         skipped++;
1525                         continue;
1526                 }
1527                 found++;
1528                 printf("Running selftest on eventdev %s\n", info.driver_name);
1529                 ret = do_selftest();
1530                 if (ret == 0) {
1531                         passed++;
1532                         printf("Selftest passed for eventdev %s\n",
1533                                info.driver_name);
1534                 } else {
1535                         failed++;
1536                         printf("Selftest failed for eventdev %s, err=%d\n",
1537                                info.driver_name, ret);
1538                 }
1539         }
1540
1541         printf("Ran selftest on %d eventdevs, %d skipped, %d passed, %d failed\n",
1542                found, skipped, passed, failed);
1543         return ret;
1544 }