drivers/event/opdl/opdl_test.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  * Copyright(c) 2010-2014 Intel Corporation
   4  */
   5
   6 #include <stdio.h>
   7 #include <string.h>
   8 #include <stdint.h>
   9 #include <errno.h>
  10 #include <unistd.h>
  11 #include <sys/queue.h>
  12
  13 #include <rte_memory.h>
  14 #include <rte_memzone.h>
  15 #include <rte_launch.h>
  16 #include <rte_eal.h>
  17 #include <rte_per_lcore.h>
  18 #include <rte_lcore.h>
  19 #include <rte_debug.h>
  20 #include <rte_ethdev.h>
  21 #include <rte_cycles.h>
  22 #include <rte_eventdev.h>
  23 #include <rte_bus_vdev.h>
  24 #include <rte_pause.h>
  25
  26 #include "opdl_evdev.h"
  27 #include "opdl_log.h"
  28
  29
  30 #define MAX_PORTS 16
  31 #define MAX_QIDS 16
  32 #define NUM_PACKETS (1<<18)
  33 #define NUM_EVENTS 256
  34 #define BURST_SIZE 32
  35
  36
  37
  38 static int evdev;
  39
  40 struct test {
  41         struct rte_mempool *mbuf_pool;
  42         uint8_t port[MAX_PORTS];
  43         uint8_t qid[MAX_QIDS];
  44         int nb_qids;
  45 };
  46
  47 static struct rte_mempool *eventdev_func_mempool;
  48
  49 static __rte_always_inline struct rte_mbuf *
  50 rte_gen_arp(int portid, struct rte_mempool *mp)
  51 {
  52         /*
  53          * len = 14 + 46
  54          * ARP, Request who-has 10.0.0.1 tell 10.0.0.2, length 46
  55          */
  56         static const uint8_t arp_request[] = {
  57                 /*0x0000:*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, 0xa8,
  58                 0x6b, 0xfd, 0x02, 0x29, 0x08, 0x06, 0x00, 0x01,
  59                 /*0x0010:*/ 0x08, 0x00, 0x06, 0x04, 0x00, 0x01, 0xec, 0xa8,
  60                 0x6b, 0xfd, 0x02, 0x29, 0x0a, 0x00, 0x00, 0x01,
  61                 /*0x0020:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00,
  62                 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  63                 /*0x0030:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  64                 0x00, 0x00, 0x00, 0x00
  65         };
  66         struct rte_mbuf *m;
  67         int pkt_len = sizeof(arp_request) - 1;
  68
  69         m = rte_pktmbuf_alloc(mp);
  70         if (!m)
  71                 return 0;
  72
  73         memcpy((void *)((uintptr_t)m->buf_addr + m->data_off),
  74                 arp_request, pkt_len);
  75         rte_pktmbuf_pkt_len(m) = pkt_len;
  76         rte_pktmbuf_data_len(m) = pkt_len;
  77
  78         RTE_SET_USED(portid);
  79
  80         return m;
  81 }
  82
  83 /* initialization and config */
  84 static __rte_always_inline int
  85 init(struct test *t, int nb_queues, int nb_ports)
  86 {
  87         struct rte_event_dev_config config = {
  88                         .nb_event_queues = nb_queues,
  89                         .nb_event_ports = nb_ports,
  90                         .nb_event_queue_flows = 1024,
  91                         .nb_events_limit = 4096,
  92                         .nb_event_port_dequeue_depth = 128,
  93                         .nb_event_port_enqueue_depth = 128,
  94         };
  95         int ret;
  96
  97         void *temp = t->mbuf_pool; /* save and restore mbuf pool */
  98
  99         memset(t, 0, sizeof(*t));
 100         t->mbuf_pool = temp;
 101
 102         ret = rte_event_dev_configure(evdev, &config);
 103         if (ret < 0)
 104                 PMD_DRV_LOG(ERR, "%d: Error configuring device\n", __LINE__);
 105         return ret;
 106 };
 107
 108 static __rte_always_inline int
 109 create_ports(struct test *t, int num_ports)
 110 {
 111         int i;
 112         static const struct rte_event_port_conf conf = {
 113                         .new_event_threshold = 1024,
 114                         .dequeue_depth = 32,
 115                         .enqueue_depth = 32,
 116         };
 117         if (num_ports > MAX_PORTS)
 118                 return -1;
 119
 120         for (i = 0; i < num_ports; i++) {
 121                 if (rte_event_port_setup(evdev, i, &conf) < 0) {
 122                         PMD_DRV_LOG(ERR, "Error setting up port %d\n", i);
 123                         return -1;
 124                 }
 125                 t->port[i] = i;
 126         }
 127
 128         return 0;
 129 };
 130
 131 static __rte_always_inline int
 132 create_queues_type(struct test *t, int num_qids, enum queue_type flags)
 133 {
 134         int i;
 135         uint8_t type;
 136
 137         switch (flags) {
 138         case OPDL_Q_TYPE_ORDERED:
 139                 type = RTE_SCHED_TYPE_ORDERED;
 140                 break;
 141         case OPDL_Q_TYPE_ATOMIC:
 142                 type = RTE_SCHED_TYPE_ATOMIC;
 143                 break;
 144         default:
 145                 type = 0;
 146         }
 147
 148         /* Q creation */
 149         const struct rte_event_queue_conf conf = {
 150                 .event_queue_cfg =
 151                 (flags == OPDL_Q_TYPE_SINGLE_LINK ?
 152                  RTE_EVENT_QUEUE_CFG_SINGLE_LINK : 0),
 153                 .schedule_type = type,
 154                 .priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
 155                 .nb_atomic_flows = 1024,
 156                 .nb_atomic_order_sequences = 1024,
 157         };
 158
 159         for (i = t->nb_qids ; i < t->nb_qids + num_qids; i++) {
 160                 if (rte_event_queue_setup(evdev, i, &conf) < 0) {
 161                         PMD_DRV_LOG(ERR, "%d: error creating qid %d\n ",
 162                                         __LINE__, i);
 163                         return -1;
 164                 }
 165                 t->qid[i] = i;
 166         }
 167
 168         t->nb_qids += num_qids;
 169
 170         if (t->nb_qids > MAX_QIDS)
 171                 return -1;
 172
 173         return 0;
 174 }
 175
 176
 177 /* destruction */
 178 static __rte_always_inline int
 179 cleanup(struct test *t __rte_unused)
 180 {
 181         rte_event_dev_stop(evdev);
 182         rte_event_dev_close(evdev);
 183         PMD_DRV_LOG(ERR, "clean up for test done\n");
 184         return 0;
 185 };
 186
 187 static int
 188 ordered_basic(struct test *t)
 189 {
 190         const uint8_t rx_port = 0;
 191         const uint8_t w1_port = 1;
 192         const uint8_t w3_port = 3;
 193         const uint8_t tx_port = 4;
 194         int err;
 195         uint32_t i;
 196         uint32_t deq_pkts;
 197         struct rte_mbuf *mbufs[3];
 198
 199         const uint32_t MAGIC_SEQN = 1234;
 200
 201         /* Create instance with 5 ports */
 202         if (init(t, 2, tx_port+1) < 0 ||
 203             create_ports(t, tx_port+1) < 0 ||
 204             create_queues_type(t, 2, OPDL_Q_TYPE_ORDERED)) {
 205                 PMD_DRV_LOG(ERR, "%d: Error initializing device\n", __LINE__);
 206                 return -1;
 207         }
 208
 209         /*
 210          * CQ mapping to QID
 211          * We need three ports, all mapped to the same ordered qid0. Then we'll
 212          * take a packet out to each port, re-enqueue in reverse order,
 213          * then make sure the reordering has taken place properly when we
 214          * dequeue from the tx_port.
 215          *
 216          * Simplified test setup diagram:
 217          *
 218          * rx_port        w1_port
 219          *        \     /         \
 220          *         qid0 - w2_port - qid1
 221          *              \         /     \
 222          *                w3_port        tx_port
 223          */
 224         /* CQ mapping to QID for LB ports (directed mapped on create) */
 225         for (i = w1_port; i <= w3_port; i++) {
 226                 err = rte_event_port_link(evdev, t->port[i], &t->qid[0], NULL,
 227                                 1);
 228                 if (err != 1) {
 229                         PMD_DRV_LOG(ERR, "%d: error mapping lb qid\n",
 230                                         __LINE__);
 231                         cleanup(t);
 232                         return -1;
 233                 }
 234         }
 235
 236         err = rte_event_port_link(evdev, t->port[tx_port], &t->qid[1], NULL,
 237                         1);
 238         if (err != 1) {
 239                 PMD_DRV_LOG(ERR, "%d: error mapping TX  qid\n", __LINE__);
 240                 cleanup(t);
 241                 return -1;
 242         }
 243
 244         if (rte_event_dev_start(evdev) < 0) {
 245                 PMD_DRV_LOG(ERR, "%d: Error with start call\n", __LINE__);
 246                 return -1;
 247         }
 248         /* Enqueue 3 packets to the rx port */
 249         for (i = 0; i < 3; i++) {
 250                 struct rte_event ev;
 251                 mbufs[i] = rte_gen_arp(0, t->mbuf_pool);
 252                 if (!mbufs[i]) {
 253                         PMD_DRV_LOG(ERR, "%d: gen of pkt failed\n", __LINE__);
 254                         return -1;
 255                 }
 256
 257                 ev.queue_id = t->qid[0];
 258                 ev.op = RTE_EVENT_OP_NEW;
 259                 ev.mbuf = mbufs[i];
 260                 mbufs[i]->seqn = MAGIC_SEQN + i;
 261
 262                 /* generate pkt and enqueue */
 263                 err = rte_event_enqueue_burst(evdev, t->port[rx_port], &ev, 1);
 264                 if (err != 1) {
 265                         PMD_DRV_LOG(ERR, "%d: Failed to enqueue pkt %u, retval = %u\n",
 266                                         __LINE__, i, err);
 267                         return -1;
 268                 }
 269         }
 270
 271         /* use extra slot to make logic in loops easier */
 272         struct rte_event deq_ev[w3_port + 1];
 273
 274         uint32_t  seq  = 0;
 275
 276         /* Dequeue the 3 packets, one from each worker port */
 277         for (i = w1_port; i <= w3_port; i++) {
 278                 deq_pkts = rte_event_dequeue_burst(evdev, t->port[i],
 279                                 &deq_ev[i], 1, 0);
 280                 if (deq_pkts != 1) {
 281                         PMD_DRV_LOG(ERR, "%d: Failed to deq\n", __LINE__);
 282                         rte_event_dev_dump(evdev, stdout);
 283                         return -1;
 284                 }
 285                 seq = deq_ev[i].mbuf->seqn  - MAGIC_SEQN;
 286
 287                 if (seq != (i-1)) {
 288                         PMD_DRV_LOG(ERR, " seq test failed ! eq is %d , "
 289                                         "port number is %u\n", seq, i);
 290                         return -1;
 291                 }
 292         }
 293
 294         /* Enqueue each packet in reverse order, flushing after each one */
 295         for (i = w3_port; i >= w1_port; i--) {
 296
 297                 deq_ev[i].op = RTE_EVENT_OP_FORWARD;
 298                 deq_ev[i].queue_id = t->qid[1];
 299                 err = rte_event_enqueue_burst(evdev, t->port[i], &deq_ev[i], 1);
 300                 if (err != 1) {
 301                         PMD_DRV_LOG(ERR, "%d: Failed to enqueue\n", __LINE__);
 302                         return -1;
 303                 }
 304         }
 305
 306         /* dequeue from the tx ports, we should get 3 packets */
 307         deq_pkts = rte_event_dequeue_burst(evdev, t->port[tx_port], deq_ev,
 308                         3, 0);
 309
 310         /* Check to see if we've got all 3 packets */
 311         if (deq_pkts != 3) {
 312                 PMD_DRV_LOG(ERR, "%d: expected 3 pkts at tx port got %d from port %d\n",
 313                         __LINE__, deq_pkts, tx_port);
 314                 rte_event_dev_dump(evdev, stdout);
 315                 return 1;
 316         }
 317
 318         /* Destroy the instance */
 319         cleanup(t);
 320
 321         return 0;
 322 }
 323
 324
 325 static int
 326 atomic_basic(struct test *t)
 327 {
 328         const uint8_t rx_port = 0;
 329         const uint8_t w1_port = 1;
 330         const uint8_t w3_port = 3;
 331         const uint8_t tx_port = 4;
 332         int err;
 333         int i;
 334         uint32_t deq_pkts;
 335         struct rte_mbuf *mbufs[3];
 336         const uint32_t MAGIC_SEQN = 1234;
 337
 338         /* Create instance with 5 ports */
 339         if (init(t, 2, tx_port+1) < 0 ||
 340             create_ports(t, tx_port+1) < 0 ||
 341             create_queues_type(t, 2, OPDL_Q_TYPE_ATOMIC)) {
 342                 PMD_DRV_LOG(ERR, "%d: Error initializing device\n", __LINE__);
 343                 return -1;
 344         }
 345
 346
 347         /*
 348          * CQ mapping to QID
 349          * We need three ports, all mapped to the same ordered qid0. Then we'll
 350          * take a packet out to each port, re-enqueue in reverse order,
 351          * then make sure the reordering has taken place properly when we
 352          * dequeue from the tx_port.
 353          *
 354          * Simplified test setup diagram:
 355          *
 356          * rx_port        w1_port
 357          *        \     /         \
 358          *         qid0 - w2_port - qid1
 359          *              \         /     \
 360          *                w3_port        tx_port
 361          */
 362         /* CQ mapping to QID for Atomic  ports (directed mapped on create) */
 363         for (i = w1_port; i <= w3_port; i++) {
 364                 err = rte_event_port_link(evdev, t->port[i], &t->qid[0], NULL,
 365                                 1);
 366                 if (err != 1) {
 367                         PMD_DRV_LOG(ERR, "%d: error mapping lb qid\n",
 368                                         __LINE__);
 369                         cleanup(t);
 370                         return -1;
 371                 }
 372         }
 373
 374         err = rte_event_port_link(evdev, t->port[tx_port], &t->qid[1], NULL,
 375                         1);
 376         if (err != 1) {
 377                 PMD_DRV_LOG(ERR, "%d: error mapping TX  qid\n", __LINE__);
 378                 cleanup(t);
 379                 return -1;
 380         }
 381
 382         if (rte_event_dev_start(evdev) < 0) {
 383                 PMD_DRV_LOG(ERR, "%d: Error with start call\n", __LINE__);
 384                 return -1;
 385         }
 386
 387         /* Enqueue 3 packets to the rx port */
 388         for (i = 0; i < 3; i++) {
 389                 struct rte_event ev;
 390                 mbufs[i] = rte_gen_arp(0, t->mbuf_pool);
 391                 if (!mbufs[i]) {
 392                         PMD_DRV_LOG(ERR, "%d: gen of pkt failed\n", __LINE__);
 393                         return -1;
 394                 }
 395
 396                 ev.queue_id = t->qid[0];
 397                 ev.op = RTE_EVENT_OP_NEW;
 398                 ev.flow_id = 1;
 399                 ev.mbuf = mbufs[i];
 400                 mbufs[i]->seqn = MAGIC_SEQN + i;
 401
 402                 /* generate pkt and enqueue */
 403                 err = rte_event_enqueue_burst(evdev, t->port[rx_port], &ev, 1);
 404                 if (err != 1) {
 405                         PMD_DRV_LOG(ERR, "%d: Failed to enqueue pkt %u, retval = %u\n",
 406                                         __LINE__, i, err);
 407                         return -1;
 408                 }
 409         }
 410
 411         /* use extra slot to make logic in loops easier */
 412         struct rte_event deq_ev[w3_port + 1];
 413
 414         /* Dequeue the 3 packets, one from each worker port */
 415         for (i = w1_port; i <= w3_port; i++) {
 416
 417                 deq_pkts = rte_event_dequeue_burst(evdev, t->port[i],
 418                                 deq_ev, 3, 0);
 419
 420                 if (t->port[i] != 2) {
 421                         if (deq_pkts != 0) {
 422                                 PMD_DRV_LOG(ERR, "%d: deq none zero !\n",
 423                                                 __LINE__);
 424                                 rte_event_dev_dump(evdev, stdout);
 425                                 return -1;
 426                         }
 427                 } else {
 428
 429                         if (deq_pkts != 3) {
 430                                 PMD_DRV_LOG(ERR, "%d: deq not eqal to 3 %u !\n",
 431                                                 __LINE__, deq_pkts);
 432                                 rte_event_dev_dump(evdev, stdout);
 433                                 return -1;
 434                         }
 435
 436                         int j;
 437                         for (j = 0; j < 3; j++) {
 438                                 deq_ev[j].op = RTE_EVENT_OP_FORWARD;
 439                                 deq_ev[j].queue_id = t->qid[1];
 440                         }
 441
 442                         err = rte_event_enqueue_burst(evdev, t->port[i],
 443                                         deq_ev, 3);
 444
 445                         if (err != 3) {
 446                                 PMD_DRV_LOG(ERR, "port %d: Failed to enqueue pkt %u, "
 447                                                 "retval = %u\n",
 448                                                 t->port[i], 3, err);
 449                                 return -1;
 450                         }
 451
 452                 }
 453
 454         }
 455
 456
 457         /* dequeue from the tx ports, we should get 3 packets */
 458         deq_pkts = rte_event_dequeue_burst(evdev, t->port[tx_port], deq_ev,
 459                         3, 0);
 460
 461         /* Check to see if we've got all 3 packets */
 462         if (deq_pkts != 3) {
 463                 PMD_DRV_LOG(ERR, "%d: expected 3 pkts at tx port got %d from port %d\n",
 464                         __LINE__, deq_pkts, tx_port);
 465                 rte_event_dev_dump(evdev, stdout);
 466                 return 1;
 467         }
 468
 469         cleanup(t);
 470
 471         return 0;
 472 }
 473 static __rte_always_inline int
 474 check_qid_stats(uint32_t id[], int index)
 475 {
 476
 477         if (index == 0) {
 478                 if (id[0] != 3 || id[1] != 3
 479                                 || id[2] != 3)
 480                         return -1;
 481         } else if (index == 1) {
 482                 if (id[0] != 5 || id[1] != 5
 483                                 || id[2] != 2)
 484                         return -1;
 485         } else if (index == 2) {
 486                 if (id[0] != 3 || id[1] != 1
 487                                 || id[2] != 1)
 488                         return -1;
 489         }
 490
 491         return 0;
 492 }
 493
 494
 495 static int
 496 check_statistics(void)
 497 {
 498         int num_ports = 3; /* Hard-coded for this app */
 499         int i;
 500
 501         for (i = 0; i < num_ports; i++) {
 502                 int num_stats, num_stats_returned;
 503
 504                 num_stats = rte_event_dev_xstats_names_get(0,
 505                                 RTE_EVENT_DEV_XSTATS_PORT,
 506                                 i,
 507                                 NULL,
 508                                 NULL,
 509                                 0);
 510                 if (num_stats > 0) {
 511
 512                         uint32_t id[num_stats];
 513                         struct rte_event_dev_xstats_name names[num_stats];
 514                         uint64_t values[num_stats];
 515
 516                         num_stats_returned = rte_event_dev_xstats_names_get(0,
 517                                         RTE_EVENT_DEV_XSTATS_PORT,
 518                                         i,
 519                                         names,
 520                                         id,
 521                                         num_stats);
 522
 523                         if (num_stats == num_stats_returned) {
 524                                 num_stats_returned = rte_event_dev_xstats_get(0,
 525                                                 RTE_EVENT_DEV_XSTATS_PORT,
 526                                                 i,
 527                                                 id,
 528                                                 values,
 529                                                 num_stats);
 530
 531                                 if (num_stats == num_stats_returned) {
 532                                         int err;
 533
 534                                         err = check_qid_stats(id, i);
 535
 536                                         if (err)
 537                                                 return err;
 538
 539                                 } else {
 540                                         return -1;
 541                                 }
 542                         } else {
 543                                 return -1;
 544                         }
 545                 } else {
 546                         return -1;
 547                 }
 548         }
 549         return 0;
 550 }
 551
 552 #define OLD_NUM_PACKETS 3
 553 #define NEW_NUM_PACKETS 2
 554 static int
 555 single_link_w_stats(struct test *t)
 556 {
 557         const uint8_t rx_port = 0;
 558         const uint8_t w1_port = 1;
 559         const uint8_t tx_port = 2;
 560         int err;
 561         int i;
 562         uint32_t deq_pkts;
 563         struct rte_mbuf *mbufs[3];
 564         RTE_SET_USED(mbufs);
 565
 566         /* Create instance with 3 ports */
 567         if (init(t, 2, tx_port + 1) < 0 ||
 568             create_ports(t, 3) < 0 || /* 0,1,2 */
 569             create_queues_type(t, 1, OPDL_Q_TYPE_SINGLE_LINK) < 0 ||
 570             create_queues_type(t, 1, OPDL_Q_TYPE_ORDERED) < 0) {
 571                 PMD_DRV_LOG(ERR, "%d: Error initializing device\n", __LINE__);
 572                 return -1;
 573         }
 574
 575
 576         /*
 577          *
 578          * Simplified test setup diagram:
 579          *
 580          * rx_port(0)
 581          *           \
 582          *            qid0 - w1_port(1) - qid1
 583          *                                    \
 584          *                                     tx_port(2)
 585          */
 586
 587         err = rte_event_port_link(evdev, t->port[1], &t->qid[0], NULL,
 588                                   1);
 589         if (err != 1) {
 590                 PMD_DRV_LOG(ERR, "%d: error linking port:[%u] to queue:[%u]\n",
 591                        __LINE__,
 592                        t->port[1],
 593                        t->qid[0]);
 594                 cleanup(t);
 595                 return -1;
 596         }
 597
 598         err = rte_event_port_link(evdev, t->port[2], &t->qid[1], NULL,
 599                                   1);
 600         if (err != 1) {
 601                 PMD_DRV_LOG(ERR, "%d: error linking port:[%u] to queue:[%u]\n",
 602                        __LINE__,
 603                        t->port[2],
 604                        t->qid[1]);
 605                 cleanup(t);
 606                 return -1;
 607         }
 608
 609         if (rte_event_dev_start(evdev) != 0) {
 610                 PMD_DRV_LOG(ERR, "%d: failed to start device\n", __LINE__);
 611                 cleanup(t);
 612                 return -1;
 613         }
 614
 615         /*
 616          * Enqueue 3 packets to the rx port
 617          */
 618         for (i = 0; i < 3; i++) {
 619                 struct rte_event ev;
 620                 mbufs[i] = rte_gen_arp(0, t->mbuf_pool);
 621                 if (!mbufs[i]) {
 622                         PMD_DRV_LOG(ERR, "%d: gen of pkt failed\n", __LINE__);
 623                         return -1;
 624                 }
 625
 626                 ev.queue_id = t->qid[0];
 627                 ev.op = RTE_EVENT_OP_NEW;
 628                 ev.mbuf = mbufs[i];
 629                 mbufs[i]->seqn = 1234 + i;
 630
 631                 /* generate pkt and enqueue */
 632                 err = rte_event_enqueue_burst(evdev, t->port[rx_port], &ev, 1);
 633                 if (err != 1) {
 634                         PMD_DRV_LOG(ERR, "%d: Failed to enqueue pkt %u, retval = %u\n",
 635                                __LINE__,
 636                                t->port[rx_port],
 637                                err);
 638                         return -1;
 639                 }
 640         }
 641
 642         /* Dequeue the 3 packets, from SINGLE_LINK worker port */
 643         struct rte_event deq_ev[3];
 644
 645         deq_pkts = rte_event_dequeue_burst(evdev,
 646                                            t->port[w1_port],
 647                                            deq_ev, 3, 0);
 648
 649         if (deq_pkts != 3) {
 650                 PMD_DRV_LOG(ERR, "%d: deq not 3 !\n", __LINE__);
 651                 cleanup(t);
 652                 return -1;
 653         }
 654
 655         /* Just enqueue 2 onto new ring */
 656         for (i = 0; i < NEW_NUM_PACKETS; i++)
 657                 deq_ev[i].queue_id = t->qid[1];
 658
 659         deq_pkts = rte_event_enqueue_burst(evdev,
 660                                            t->port[w1_port],
 661                                            deq_ev,
 662                                            NEW_NUM_PACKETS);
 663
 664         if (deq_pkts != 2) {
 665                 PMD_DRV_LOG(ERR, "%d: enq not 2 but %u!\n", __LINE__, deq_pkts);
 666                 cleanup(t);
 667                 return -1;
 668         }
 669
 670         /* dequeue from the tx ports, we should get 2 packets */
 671         deq_pkts = rte_event_dequeue_burst(evdev,
 672                                            t->port[tx_port],
 673                                            deq_ev,
 674                                            3,
 675                                            0);
 676
 677         /* Check to see if we've got all 2 packets */
 678         if (deq_pkts != 2) {
 679                 PMD_DRV_LOG(ERR, "%d: expected 2 pkts at tx port got %d from port %d\n",
 680                         __LINE__, deq_pkts, tx_port);
 681                 cleanup(t);
 682                 return -1;
 683         }
 684
 685         if (!check_statistics()) {
 686                 PMD_DRV_LOG(ERR, "xstats check failed");
 687                 cleanup(t);
 688                 return -1;
 689         }
 690
 691         cleanup(t);
 692
 693         return 0;
 694 }
 695
 696 static int
 697 single_link(struct test *t)
 698 {
 699         /* const uint8_t rx_port = 0; */
 700         /* const uint8_t w1_port = 1; */
 701         /* const uint8_t w3_port = 3; */
 702         const uint8_t tx_port = 2;
 703         int err;
 704         struct rte_mbuf *mbufs[3];
 705         RTE_SET_USED(mbufs);
 706
 707         /* Create instance with 5 ports */
 708         if (init(t, 2, tx_port+1) < 0 ||
 709             create_ports(t, 3) < 0 || /* 0,1,2 */
 710             create_queues_type(t, 1, OPDL_Q_TYPE_SINGLE_LINK) < 0 ||
 711             create_queues_type(t, 1, OPDL_Q_TYPE_ORDERED) < 0) {
 712                 PMD_DRV_LOG(ERR, "%d: Error initializing device\n", __LINE__);
 713                 return -1;
 714         }
 715
 716
 717         /*
 718          *
 719          * Simplified test setup diagram:
 720          *
 721          * rx_port(0)
 722          *           \
 723          *            qid0 - w1_port(1) - qid1
 724          *                                    \
 725          *                                     tx_port(2)
 726          */
 727
 728         err = rte_event_port_link(evdev, t->port[1], &t->qid[0], NULL,
 729                                   1);
 730         if (err != 1) {
 731                 PMD_DRV_LOG(ERR, "%d: error mapping lb qid\n", __LINE__);
 732                 cleanup(t);
 733                 return -1;
 734         }
 735
 736         err = rte_event_port_link(evdev, t->port[2], &t->qid[0], NULL,
 737                                   1);
 738         if (err != 1) {
 739                 PMD_DRV_LOG(ERR, "%d: error mapping lb qid\n", __LINE__);
 740                 cleanup(t);
 741                 return -1;
 742         }
 743
 744         if (rte_event_dev_start(evdev) == 0) {
 745                 PMD_DRV_LOG(ERR, "%d: start DIDN'T FAIL with more than 1 "
 746                                 "SINGLE_LINK PORT\n", __LINE__);
 747                 cleanup(t);
 748                 return -1;
 749         }
 750
 751         cleanup(t);
 752
 753         return 0;
 754 }
 755
 756
 757 static __rte_always_inline void
 758 populate_event_burst(struct rte_event ev[],
 759                      uint8_t qid,
 760                      uint16_t num_events)
 761 {
 762         uint16_t i;
 763         for (i = 0; i < num_events; i++) {
 764                 ev[i].flow_id = 1;
 765                 ev[i].op = RTE_EVENT_OP_NEW;
 766                 ev[i].sched_type = RTE_SCHED_TYPE_ORDERED;
 767                 ev[i].queue_id = qid;
 768                 ev[i].event_type = RTE_EVENT_TYPE_ETHDEV;
 769                 ev[i].sub_event_type = 0;
 770                 ev[i].priority = RTE_EVENT_DEV_PRIORITY_NORMAL;
 771                 ev[i].mbuf = (struct rte_mbuf *)0xdead0000;
 772         }
 773 }
 774
 775 #define NUM_QUEUES 3
 776 #define BATCH_SIZE 32
 777
 778 static int
 779 qid_basic(struct test *t)
 780 {
 781         int err = 0;
 782
 783         uint8_t q_id = 0;
 784         uint8_t p_id = 0;
 785
 786         uint32_t num_events;
 787         uint32_t i;
 788
 789         struct rte_event ev[BATCH_SIZE];
 790
 791         /* Create instance with 4 ports */
 792         if (init(t, NUM_QUEUES, NUM_QUEUES+1) < 0 ||
 793             create_ports(t, NUM_QUEUES+1) < 0 ||
 794             create_queues_type(t, NUM_QUEUES, OPDL_Q_TYPE_ORDERED)) {
 795                 PMD_DRV_LOG(ERR, "%d: Error initializing device\n", __LINE__);
 796                 return -1;
 797         }
 798
 799         for (i = 0; i < NUM_QUEUES; i++) {
 800                 int nb_linked;
 801                 q_id = i;
 802
 803                 nb_linked = rte_event_port_link(evdev,
 804                                 i+1, /* port = q_id + 1*/
 805                                 &q_id,
 806                                 NULL,
 807                                 1);
 808
 809                 if (nb_linked != 1) {
 810
 811                         PMD_DRV_LOG(ERR, "%s:%d: error mapping port:%u to queue:%u\n",
 812                                         __FILE__,
 813                                         __LINE__,
 814                                         i + 1,
 815                                         q_id);
 816
 817                         err = -1;
 818                         break;
 819                 }
 820
 821         }
 822
 823
 824         /* Try and link to the same port again */
 825         if (!err) {
 826                 uint8_t t_qid = 0;
 827                 if (rte_event_port_link(evdev,
 828                                         1,
 829                                         &t_qid,
 830                                         NULL,
 831                                         1) > 0) {
 832                         PMD_DRV_LOG(ERR, "%s:%d: Second call to port link on same port DID NOT fail\n",
 833                                         __FILE__,
 834                                         __LINE__);
 835                         err = -1;
 836                 }
 837
 838                 uint32_t test_num_events;
 839
 840                 if (!err) {
 841                         test_num_events = rte_event_dequeue_burst(evdev,
 842                                         p_id,
 843                                         ev,
 844                                         BATCH_SIZE,
 845                                         0);
 846                         if (test_num_events != 0) {
 847                                 PMD_DRV_LOG(ERR, "%s:%d: Error dequeuing 0 packets from port %u on stopped device\n",
 848                                                 __FILE__,
 849                                                 __LINE__,
 850                                                 p_id);
 851                                 err = -1;
 852                         }
 853                 }
 854
 855                 if (!err) {
 856                         test_num_events = rte_event_enqueue_burst(evdev,
 857                                         p_id,
 858                                         ev,
 859                                         BATCH_SIZE);
 860                         if (test_num_events != 0) {
 861                                 PMD_DRV_LOG(ERR, "%s:%d: Error enqueuing 0 packets to port %u on stopped device\n",
 862                                                 __FILE__,
 863                                                 __LINE__,
 864                                                 p_id);
 865                                 err = -1;
 866                         }
 867                 }
 868         }
 869
 870
 871         /* Start the devicea */
 872         if (!err) {
 873                 if (rte_event_dev_start(evdev) < 0) {
 874                         PMD_DRV_LOG(ERR, "%s:%d: Error with start call\n",
 875                                         __FILE__,
 876                                         __LINE__);
 877                         err = -1;
 878                 }
 879         }
 880
 881
 882         /* Check we can't do any more links now that device is started.*/
 883         if (!err) {
 884                 uint8_t t_qid = 0;
 885                 if (rte_event_port_link(evdev,
 886                                         1,
 887                                         &t_qid,
 888                                         NULL,
 889                                         1) > 0) {
 890                         PMD_DRV_LOG(ERR, "%s:%d: Call to port link on started device DID NOT fail\n",
 891                                         __FILE__,
 892                                         __LINE__);
 893                         err = -1;
 894                 }
 895         }
 896
 897         if (!err) {
 898
 899                 q_id = 0;
 900
 901                 populate_event_burst(ev,
 902                                 q_id,
 903                                 BATCH_SIZE);
 904
 905                 num_events = rte_event_enqueue_burst(evdev,
 906                                 p_id,
 907                                 ev,
 908                                 BATCH_SIZE);
 909                 if (num_events != BATCH_SIZE) {
 910                         PMD_DRV_LOG(ERR, "%s:%d: Error enqueuing rx packets\n",
 911                                         __FILE__,
 912                                         __LINE__);
 913                         err = -1;
 914                 }
 915         }
 916
 917         if (!err) {
 918                 while (++p_id < NUM_QUEUES) {
 919
 920                         num_events = rte_event_dequeue_burst(evdev,
 921                                         p_id,
 922                                         ev,
 923                                         BATCH_SIZE,
 924                                         0);
 925
 926                         if (num_events != BATCH_SIZE) {
 927                                 PMD_DRV_LOG(ERR, "%s:%d: Error dequeuing packets from port %u\n",
 928                                                 __FILE__,
 929                                                 __LINE__,
 930                                                 p_id);
 931                                 err = -1;
 932                                 break;
 933                         }
 934
 935                         if (ev[0].queue_id != q_id) {
 936                                 PMD_DRV_LOG(ERR, "%s:%d: Error event portid[%u] q_id:[%u] does not match expected:[%u]\n",
 937                                                 __FILE__,
 938                                                 __LINE__,
 939                                                 p_id,
 940                                                 ev[0].queue_id,
 941                                                 q_id);
 942                                 err = -1;
 943                                 break;
 944                         }
 945
 946                         populate_event_burst(ev,
 947                                         ++q_id,
 948                                         BATCH_SIZE);
 949
 950                         num_events = rte_event_enqueue_burst(evdev,
 951                                         p_id,
 952                                         ev,
 953                                         BATCH_SIZE);
 954                         if (num_events != BATCH_SIZE) {
 955                                 PMD_DRV_LOG(ERR, "%s:%d: Error enqueuing packets from port:%u to queue:%u\n",
 956                                                 __FILE__,
 957                                                 __LINE__,
 958                                                 p_id,
 959                                                 q_id);
 960                                 err = -1;
 961                                 break;
 962                         }
 963                 }
 964         }
 965
 966         if (!err) {
 967                 num_events = rte_event_dequeue_burst(evdev,
 968                                 p_id,
 969                                 ev,
 970                                 BATCH_SIZE,
 971                                 0);
 972                 if (num_events != BATCH_SIZE) {
 973                         PMD_DRV_LOG(ERR, "%s:%d: Error dequeuing packets from tx port %u\n",
 974                                         __FILE__,
 975                                         __LINE__,
 976                                         p_id);
 977                         err = -1;
 978                 }
 979         }
 980
 981         cleanup(t);
 982
 983         return err;
 984 }
 985
 986
 987
 988 int
 989 opdl_selftest(void)
 990 {
 991         struct test *t = malloc(sizeof(struct test));
 992         int ret;
 993
 994         const char *eventdev_name = "event_opdl0";
 995
 996         evdev = rte_event_dev_get_dev_id(eventdev_name);
 997
 998         if (evdev < 0) {
 999                 PMD_DRV_LOG(ERR, "%d: Eventdev %s not found - creating.\n",
1000                                 __LINE__, eventdev_name);
1001                 /* turn on stats by default */
1002                 if (rte_vdev_init(eventdev_name, "do_validation=1") < 0) {
1003                         PMD_DRV_LOG(ERR, "Error creating eventdev\n");
1004                         return -1;
1005                 }
1006                 evdev = rte_event_dev_get_dev_id(eventdev_name);
1007                 if (evdev < 0) {
1008                         PMD_DRV_LOG(ERR, "Error finding newly created eventdev\n");
1009                         return -1;
1010                 }
1011         }
1012
1013         /* Only create mbuf pool once, reuse for each test run */
1014         if (!eventdev_func_mempool) {
1015                 eventdev_func_mempool = rte_pktmbuf_pool_create(
1016                                 "EVENTDEV_SW_SA_MBUF_POOL",
1017                                 (1<<12), /* 4k buffers */
1018                                 32 /*MBUF_CACHE_SIZE*/,
1019                                 0,
1020                                 512, /* use very small mbufs */
1021                                 rte_socket_id());
1022                 if (!eventdev_func_mempool) {
1023                         PMD_DRV_LOG(ERR, "ERROR creating mempool\n");
1024                         return -1;
1025                 }
1026         }
1027         t->mbuf_pool = eventdev_func_mempool;
1028
1029         PMD_DRV_LOG(ERR, "*** Running Ordered Basic test...\n");
1030         ret = ordered_basic(t);
1031
1032         PMD_DRV_LOG(ERR, "*** Running Atomic Basic test...\n");
1033         ret = atomic_basic(t);
1034
1035
1036         PMD_DRV_LOG(ERR, "*** Running QID  Basic test...\n");
1037         ret = qid_basic(t);
1038
1039         PMD_DRV_LOG(ERR, "*** Running SINGLE LINK failure test...\n");
1040         ret = single_link(t);
1041
1042         PMD_DRV_LOG(ERR, "*** Running SINGLE LINK w stats test...\n");
1043         ret = single_link_w_stats(t);
1044
1045         /*
1046          * Free test instance, leaving mempool initialized, and a pointer to it
1047          * in static eventdev_func_mempool, as it is re-used on re-runs
1048          */
1049         free(t);
1050
1051         if (ret != 0)
1052                 return ret;
1053         return 0;
1054
1055 }