examples/l2fwd-event/l2fwd_event.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2019 Marvell International Ltd.
   3  */
   4
   5 #include <stdbool.h>
   6 #include <getopt.h>
   7
   8 #include <rte_cycles.h>
   9 #include <rte_ethdev.h>
  10 #include <rte_eventdev.h>
  11 #include <rte_event_eth_rx_adapter.h>
  12 #include <rte_event_eth_tx_adapter.h>
  13 #include <rte_lcore.h>
  14 #include <rte_malloc.h>
  15 #include <rte_spinlock.h>
  16
  17 #include "l2fwd_event.h"
  18
  19 #define L2FWD_EVENT_SINGLE      0x1
  20 #define L2FWD_EVENT_BURST       0x2
  21 #define L2FWD_EVENT_TX_DIRECT   0x4
  22 #define L2FWD_EVENT_TX_ENQ      0x8
  23 #define L2FWD_EVENT_UPDT_MAC    0x10
  24
  25 static inline int
  26 l2fwd_event_service_enable(uint32_t service_id)
  27 {
  28         uint8_t min_service_count = UINT8_MAX;
  29         uint32_t slcore_array[RTE_MAX_LCORE];
  30         unsigned int slcore = 0;
  31         uint8_t service_count;
  32         int32_t slcore_count;
  33
  34         if (!rte_service_lcore_count())
  35                 return -ENOENT;
  36
  37         slcore_count = rte_service_lcore_list(slcore_array, RTE_MAX_LCORE);
  38         if (slcore_count < 0)
  39                 return -ENOENT;
  40         /* Get the core which has least number of services running. */
  41         while (slcore_count--) {
  42                 /* Reset default mapping */
  43                 if (rte_service_map_lcore_set(service_id,
  44                                         slcore_array[slcore_count], 0) != 0)
  45                         return -ENOENT;
  46                 service_count = rte_service_lcore_count_services(
  47                                 slcore_array[slcore_count]);
  48                 if (service_count < min_service_count) {
  49                         slcore = slcore_array[slcore_count];
  50                         min_service_count = service_count;
  51                 }
  52         }
  53         if (rte_service_map_lcore_set(service_id, slcore, 1) != 0)
  54                 return -ENOENT;
  55         rte_service_lcore_start(slcore);
  56
  57         return 0;
  58 }
  59
  60 void
  61 l2fwd_event_service_setup(struct l2fwd_resources *rsrc)
  62 {
  63         struct l2fwd_event_resources *evt_rsrc = rsrc->evt_rsrc;
  64         struct rte_event_dev_info evdev_info;
  65         uint32_t service_id, caps;
  66         int ret, i;
  67
  68         /* Running eventdev scheduler service on service core. 8< */
  69         rte_event_dev_info_get(evt_rsrc->event_d_id, &evdev_info);
  70         if (!(evdev_info.event_dev_cap & RTE_EVENT_DEV_CAP_DISTRIBUTED_SCHED)) {
  71                 ret = rte_event_dev_service_id_get(evt_rsrc->event_d_id,
  72                                 &service_id);
  73                 if (ret != -ESRCH && ret != 0)
  74                         rte_panic("Error in starting eventdev service\n");
  75                 l2fwd_event_service_enable(service_id);
  76         }
  77         /* >8 End of running eventdev scheduler service on service core. */
  78
  79         /* Gets service ID for RX/TX adapters. 8< */
  80         for (i = 0; i < evt_rsrc->rx_adptr.nb_rx_adptr; i++) {
  81                 ret = rte_event_eth_rx_adapter_caps_get(evt_rsrc->event_d_id,
  82                                 evt_rsrc->rx_adptr.rx_adptr[i], &caps);
  83                 if (ret < 0)
  84                         rte_panic("Failed to get Rx adapter[%d] caps\n",
  85                                   evt_rsrc->rx_adptr.rx_adptr[i]);
  86                 ret = rte_event_eth_rx_adapter_service_id_get(
  87                                 evt_rsrc->event_d_id,
  88                                 &service_id);
  89                 if (ret != -ESRCH && ret != 0)
  90                         rte_panic("Error in starting Rx adapter[%d] service\n",
  91                                   evt_rsrc->rx_adptr.rx_adptr[i]);
  92                 l2fwd_event_service_enable(service_id);
  93         }
  94
  95         for (i = 0; i < evt_rsrc->tx_adptr.nb_tx_adptr; i++) {
  96                 ret = rte_event_eth_tx_adapter_caps_get(evt_rsrc->event_d_id,
  97                                 evt_rsrc->tx_adptr.tx_adptr[i], &caps);
  98                 if (ret < 0)
  99                         rte_panic("Failed to get Rx adapter[%d] caps\n",
 100                                   evt_rsrc->tx_adptr.tx_adptr[i]);
 101                 ret = rte_event_eth_tx_adapter_service_id_get(
 102                                 evt_rsrc->event_d_id,
 103                                 &service_id);
 104                 if (ret != -ESRCH && ret != 0)
 105                         rte_panic("Error in starting Rx adapter[%d] service\n",
 106                                   evt_rsrc->tx_adptr.tx_adptr[i]);
 107                 l2fwd_event_service_enable(service_id);
 108         }
 109         /* >8 End of get service ID for RX/TX adapters. */
 110 }
 111
 112 static void
 113 l2fwd_event_capability_setup(struct l2fwd_event_resources *evt_rsrc)
 114 {
 115         uint32_t caps = 0;
 116         uint16_t i;
 117         int ret;
 118
 119         RTE_ETH_FOREACH_DEV(i) {
 120                 ret = rte_event_eth_tx_adapter_caps_get(0, i, &caps);
 121                 if (ret)
 122                         rte_panic("Invalid capability for Tx adptr port %d\n",
 123                                   i);
 124
 125                 evt_rsrc->tx_mode_q |= !(caps &
 126                                    RTE_EVENT_ETH_TX_ADAPTER_CAP_INTERNAL_PORT);
 127         }
 128
 129         if (evt_rsrc->tx_mode_q)
 130                 l2fwd_event_set_generic_ops(&evt_rsrc->ops);
 131         else
 132                 l2fwd_event_set_internal_port_ops(&evt_rsrc->ops);
 133 }
 134
 135 static __rte_noinline int
 136 l2fwd_get_free_event_port(struct l2fwd_event_resources *evt_rsrc)
 137 {
 138         static int index;
 139         int port_id;
 140
 141         rte_spinlock_lock(&evt_rsrc->evp.lock);
 142         if (index >= evt_rsrc->evp.nb_ports) {
 143                 printf("No free event port is available\n");
 144                 return -1;
 145         }
 146
 147         port_id = evt_rsrc->evp.event_p_id[index];
 148         index++;
 149         rte_spinlock_unlock(&evt_rsrc->evp.lock);
 150
 151         return port_id;
 152 }
 153
 154 static  __rte_always_inline void
 155 l2fwd_event_fwd(struct l2fwd_resources *rsrc, struct rte_event *ev,
 156                 const uint8_t tx_q_id, const uint64_t timer_period,
 157                 const uint32_t flags)
 158 {
 159         struct rte_mbuf *mbuf = ev->mbuf;
 160         uint16_t dst_port;
 161
 162         rte_prefetch0(rte_pktmbuf_mtod(mbuf, void *));
 163         dst_port = rsrc->dst_ports[mbuf->port];
 164
 165         if (timer_period > 0)
 166                 __atomic_fetch_add(&rsrc->port_stats[mbuf->port].rx,
 167                                 1, __ATOMIC_RELAXED);
 168         mbuf->port = dst_port;
 169
 170         if (flags & L2FWD_EVENT_UPDT_MAC)
 171                 l2fwd_mac_updating(mbuf, dst_port, &rsrc->eth_addr[dst_port]);
 172
 173         if (flags & L2FWD_EVENT_TX_ENQ) {
 174                 ev->queue_id = tx_q_id;
 175                 ev->op = RTE_EVENT_OP_FORWARD;
 176         }
 177
 178         if (flags & L2FWD_EVENT_TX_DIRECT)
 179                 rte_event_eth_tx_adapter_txq_set(mbuf, 0);
 180
 181         if (timer_period > 0)
 182                 __atomic_fetch_add(&rsrc->port_stats[mbuf->port].tx,
 183                                 1, __ATOMIC_RELAXED);
 184 }
 185
 186 static __rte_always_inline void
 187 l2fwd_event_loop_single(struct l2fwd_resources *rsrc,
 188                         const uint32_t flags)
 189 {
 190         struct l2fwd_event_resources *evt_rsrc = rsrc->evt_rsrc;
 191         const int port_id = l2fwd_get_free_event_port(evt_rsrc);
 192         const uint8_t tx_q_id = evt_rsrc->evq.event_q_id[
 193                                         evt_rsrc->evq.nb_queues - 1];
 194         const uint64_t timer_period = rsrc->timer_period;
 195         const uint8_t event_d_id = evt_rsrc->event_d_id;
 196         struct rte_event ev;
 197
 198         if (port_id < 0)
 199                 return;
 200
 201         printf("%s(): entering eventdev main loop on lcore %u\n", __func__,
 202                 rte_lcore_id());
 203
 204         while (!rsrc->force_quit) {
 205                 /* Read packet from eventdev */
 206                 if (!rte_event_dequeue_burst(event_d_id, port_id, &ev, 1, 0))
 207                         continue;
 208
 209                 l2fwd_event_fwd(rsrc, &ev, tx_q_id, timer_period, flags);
 210
 211                 if (flags & L2FWD_EVENT_TX_ENQ) {
 212                         while (rte_event_enqueue_burst(event_d_id, port_id,
 213                                                        &ev, 1) &&
 214                                         !rsrc->force_quit)
 215                                 ;
 216                 }
 217
 218                 if (flags & L2FWD_EVENT_TX_DIRECT) {
 219                         while (!rte_event_eth_tx_adapter_enqueue(event_d_id,
 220                                                                 port_id,
 221                                                                 &ev, 1, 0) &&
 222                                         !rsrc->force_quit)
 223                                 ;
 224                 }
 225         }
 226 }
 227
 228 static __rte_always_inline void
 229 l2fwd_event_loop_burst(struct l2fwd_resources *rsrc,
 230                        const uint32_t flags)
 231 {
 232         struct l2fwd_event_resources *evt_rsrc = rsrc->evt_rsrc;
 233         const int port_id = l2fwd_get_free_event_port(evt_rsrc);
 234         const uint8_t tx_q_id = evt_rsrc->evq.event_q_id[
 235                                         evt_rsrc->evq.nb_queues - 1];
 236         const uint64_t timer_period = rsrc->timer_period;
 237         const uint8_t event_d_id = evt_rsrc->event_d_id;
 238         const uint8_t deq_len = evt_rsrc->deq_depth;
 239         struct rte_event ev[MAX_PKT_BURST];
 240         uint16_t nb_rx, nb_tx;
 241         uint8_t i;
 242
 243         if (port_id < 0)
 244                 return;
 245
 246         printf("%s(): entering eventdev main loop on lcore %u\n", __func__,
 247                 rte_lcore_id());
 248
 249         while (!rsrc->force_quit) {
 250                 /* Read packet from eventdev. 8< */
 251                 nb_rx = rte_event_dequeue_burst(event_d_id, port_id, ev,
 252                                                 deq_len, 0);
 253                 if (nb_rx == 0)
 254                         continue;
 255
 256                 for (i = 0; i < nb_rx; i++) {
 257                         l2fwd_event_fwd(rsrc, &ev[i], tx_q_id, timer_period,
 258                                         flags);
 259                 }
 260                 /* >8 End of reading packets from eventdev. */
 261
 262                 if (flags & L2FWD_EVENT_TX_ENQ) {
 263                         /* Forwarding to destination ports. 8< */
 264                         nb_tx = rte_event_enqueue_burst(event_d_id, port_id,
 265                                                         ev, nb_rx);
 266                         while (nb_tx < nb_rx && !rsrc->force_quit)
 267                                 nb_tx += rte_event_enqueue_burst(event_d_id,
 268                                                 port_id, ev + nb_tx,
 269                                                 nb_rx - nb_tx);
 270                         /* >8 End of forwarding to destination ports. */
 271                 }
 272
 273                 if (flags & L2FWD_EVENT_TX_DIRECT) {
 274                         nb_tx = rte_event_eth_tx_adapter_enqueue(event_d_id,
 275                                                                  port_id, ev,
 276                                                                  nb_rx, 0);
 277                         while (nb_tx < nb_rx && !rsrc->force_quit)
 278                                 nb_tx += rte_event_eth_tx_adapter_enqueue(
 279                                                 event_d_id, port_id,
 280                                                 ev + nb_tx, nb_rx - nb_tx, 0);
 281                 }
 282         }
 283 }
 284
 285 static __rte_always_inline void
 286 l2fwd_event_loop(struct l2fwd_resources *rsrc,
 287                         const uint32_t flags)
 288 {
 289         if (flags & L2FWD_EVENT_SINGLE)
 290                 l2fwd_event_loop_single(rsrc, flags);
 291         if (flags & L2FWD_EVENT_BURST)
 292                 l2fwd_event_loop_burst(rsrc, flags);
 293 }
 294
 295 static void __rte_noinline
 296 l2fwd_event_main_loop_tx_d(struct l2fwd_resources *rsrc)
 297 {
 298         l2fwd_event_loop(rsrc,
 299                          L2FWD_EVENT_TX_DIRECT | L2FWD_EVENT_SINGLE);
 300 }
 301
 302 static void __rte_noinline
 303 l2fwd_event_main_loop_tx_d_brst(struct l2fwd_resources *rsrc)
 304 {
 305         l2fwd_event_loop(rsrc, L2FWD_EVENT_TX_DIRECT | L2FWD_EVENT_BURST);
 306 }
 307
 308 static void __rte_noinline
 309 l2fwd_event_main_loop_tx_q(struct l2fwd_resources *rsrc)
 310 {
 311         l2fwd_event_loop(rsrc, L2FWD_EVENT_TX_ENQ | L2FWD_EVENT_SINGLE);
 312 }
 313
 314 static void __rte_noinline
 315 l2fwd_event_main_loop_tx_q_brst(struct l2fwd_resources *rsrc)
 316 {
 317         l2fwd_event_loop(rsrc, L2FWD_EVENT_TX_ENQ | L2FWD_EVENT_BURST);
 318 }
 319
 320 static void __rte_noinline
 321 l2fwd_event_main_loop_tx_d_mac(struct l2fwd_resources *rsrc)
 322 {
 323         l2fwd_event_loop(rsrc, L2FWD_EVENT_UPDT_MAC |
 324                         L2FWD_EVENT_TX_DIRECT | L2FWD_EVENT_SINGLE);
 325 }
 326
 327 static void __rte_noinline
 328 l2fwd_event_main_loop_tx_d_brst_mac(struct l2fwd_resources *rsrc)
 329 {
 330         l2fwd_event_loop(rsrc, L2FWD_EVENT_UPDT_MAC |
 331                         L2FWD_EVENT_TX_DIRECT | L2FWD_EVENT_BURST);
 332 }
 333
 334 static void __rte_noinline
 335 l2fwd_event_main_loop_tx_q_mac(struct l2fwd_resources *rsrc)
 336 {
 337         l2fwd_event_loop(rsrc, L2FWD_EVENT_UPDT_MAC |
 338                         L2FWD_EVENT_TX_ENQ | L2FWD_EVENT_SINGLE);
 339 }
 340
 341 static void __rte_noinline
 342 l2fwd_event_main_loop_tx_q_brst_mac(struct l2fwd_resources *rsrc)
 343 {
 344         l2fwd_event_loop(rsrc, L2FWD_EVENT_UPDT_MAC |
 345                         L2FWD_EVENT_TX_ENQ | L2FWD_EVENT_BURST);
 346 }
 347
 348 static __rte_always_inline void
 349 l2fwd_event_vector_fwd(struct l2fwd_resources *rsrc,
 350                        struct rte_event_vector *vec,
 351                        const uint64_t timer_period, const uint32_t flags)
 352 {
 353         struct rte_mbuf **mbufs = vec->mbufs;
 354         uint16_t i, j;
 355
 356         rte_prefetch0(rte_pktmbuf_mtod(mbufs[0], void *));
 357
 358         /* If vector attribute is valid, mbufs will be from same port/queue */
 359         if (vec->attr_valid) {
 360                 vec->port = rsrc->dst_ports[mbufs[0]->port];
 361                 if (flags & L2FWD_EVENT_TX_DIRECT)
 362                         vec->queue = 0;
 363
 364                 if (timer_period > 0)
 365                         __atomic_fetch_add(&rsrc->port_stats[mbufs[0]->port].rx,
 366                                            vec->nb_elem, __ATOMIC_RELAXED);
 367
 368                 for (i = 0, j = 1; i < vec->nb_elem; i++, j++) {
 369                         if (j < vec->nb_elem)
 370                                 rte_prefetch0(
 371                                         rte_pktmbuf_mtod(mbufs[j], void *));
 372
 373                         if (flags & L2FWD_EVENT_UPDT_MAC)
 374                                 l2fwd_mac_updating(
 375                                         mbufs[i], vec->port,
 376                                         &rsrc->eth_addr[vec->port]);
 377                 }
 378
 379                 if (timer_period > 0)
 380                         __atomic_fetch_add(&rsrc->port_stats[vec->port].tx,
 381                                            vec->nb_elem, __ATOMIC_RELAXED);
 382         } else {
 383                 for (i = 0, j = 1; i < vec->nb_elem; i++, j++) {
 384                         if (timer_period > 0)
 385                                 __atomic_fetch_add(
 386                                         &rsrc->port_stats[mbufs[i]->port].rx, 1,
 387                                         __ATOMIC_RELAXED);
 388
 389                         if (j < vec->nb_elem)
 390                                 rte_prefetch0(
 391                                         rte_pktmbuf_mtod(mbufs[j], void *));
 392
 393                         mbufs[i]->port = rsrc->dst_ports[mbufs[i]->port];
 394
 395                         if (flags & L2FWD_EVENT_UPDT_MAC)
 396                                 l2fwd_mac_updating(
 397                                         mbufs[i], mbufs[i]->port,
 398                                         &rsrc->eth_addr[mbufs[i]->port]);
 399
 400                         if (flags & L2FWD_EVENT_TX_DIRECT)
 401                                 rte_event_eth_tx_adapter_txq_set(mbufs[i], 0);
 402
 403                         if (timer_period > 0)
 404                                 __atomic_fetch_add(
 405                                         &rsrc->port_stats[mbufs[i]->port].tx, 1,
 406                                         __ATOMIC_RELAXED);
 407                 }
 408         }
 409 }
 410
 411 static __rte_always_inline void
 412 l2fwd_event_loop_vector(struct l2fwd_resources *rsrc, const uint32_t flags)
 413 {
 414         struct l2fwd_event_resources *evt_rsrc = rsrc->evt_rsrc;
 415         const int port_id = l2fwd_get_free_event_port(evt_rsrc);
 416         const uint8_t tx_q_id =
 417                 evt_rsrc->evq.event_q_id[evt_rsrc->evq.nb_queues - 1];
 418         const uint64_t timer_period = rsrc->timer_period;
 419         const uint8_t event_d_id = evt_rsrc->event_d_id;
 420         const uint8_t deq_len = evt_rsrc->deq_depth;
 421         struct rte_event ev[MAX_PKT_BURST];
 422         uint16_t nb_rx, nb_tx;
 423         uint8_t i;
 424
 425         if (port_id < 0)
 426                 return;
 427
 428         printf("%s(): entering eventdev main loop on lcore %u\n", __func__,
 429                rte_lcore_id());
 430
 431         while (!rsrc->force_quit) {
 432                 nb_rx = rte_event_dequeue_burst(event_d_id, port_id, ev,
 433                                                 deq_len, 0);
 434                 if (nb_rx == 0)
 435                         continue;
 436
 437                 for (i = 0; i < nb_rx; i++) {
 438                         if (flags & L2FWD_EVENT_TX_ENQ) {
 439                                 ev[i].queue_id = tx_q_id;
 440                                 ev[i].op = RTE_EVENT_OP_FORWARD;
 441                         }
 442
 443                         l2fwd_event_vector_fwd(rsrc, ev[i].vec, timer_period,
 444                                                flags);
 445                 }
 446
 447                 if (flags & L2FWD_EVENT_TX_ENQ) {
 448                         nb_tx = rte_event_enqueue_burst(event_d_id, port_id, ev,
 449                                                         nb_rx);
 450                         while (nb_tx < nb_rx && !rsrc->force_quit)
 451                                 nb_tx += rte_event_enqueue_burst(
 452                                         event_d_id, port_id, ev + nb_tx,
 453                                         nb_rx - nb_tx);
 454                 }
 455
 456                 if (flags & L2FWD_EVENT_TX_DIRECT) {
 457                         nb_tx = rte_event_eth_tx_adapter_enqueue(
 458                                 event_d_id, port_id, ev, nb_rx, 0);
 459                         while (nb_tx < nb_rx && !rsrc->force_quit)
 460                                 nb_tx += rte_event_eth_tx_adapter_enqueue(
 461                                         event_d_id, port_id, ev + nb_tx,
 462                                         nb_rx - nb_tx, 0);
 463                 }
 464         }
 465 }
 466
 467 static void __rte_noinline
 468 l2fwd_event_main_loop_tx_d_vec(struct l2fwd_resources *rsrc)
 469 {
 470         l2fwd_event_loop_vector(rsrc, L2FWD_EVENT_TX_DIRECT);
 471 }
 472
 473 static void __rte_noinline
 474 l2fwd_event_main_loop_tx_d_brst_vec(struct l2fwd_resources *rsrc)
 475 {
 476         l2fwd_event_loop_vector(rsrc, L2FWD_EVENT_TX_DIRECT);
 477 }
 478
 479 static void __rte_noinline
 480 l2fwd_event_main_loop_tx_q_vec(struct l2fwd_resources *rsrc)
 481 {
 482         l2fwd_event_loop_vector(rsrc, L2FWD_EVENT_TX_ENQ);
 483 }
 484
 485 static void __rte_noinline
 486 l2fwd_event_main_loop_tx_q_brst_vec(struct l2fwd_resources *rsrc)
 487 {
 488         l2fwd_event_loop_vector(rsrc, L2FWD_EVENT_TX_ENQ);
 489 }
 490
 491 static void __rte_noinline
 492 l2fwd_event_main_loop_tx_d_mac_vec(struct l2fwd_resources *rsrc)
 493 {
 494         l2fwd_event_loop_vector(rsrc,
 495                                 L2FWD_EVENT_UPDT_MAC | L2FWD_EVENT_TX_DIRECT);
 496 }
 497
 498 static void __rte_noinline
 499 l2fwd_event_main_loop_tx_d_brst_mac_vec(struct l2fwd_resources *rsrc)
 500 {
 501         l2fwd_event_loop_vector(rsrc,
 502                                 L2FWD_EVENT_UPDT_MAC | L2FWD_EVENT_TX_DIRECT);
 503 }
 504
 505 static void __rte_noinline
 506 l2fwd_event_main_loop_tx_q_mac_vec(struct l2fwd_resources *rsrc)
 507 {
 508         l2fwd_event_loop_vector(rsrc,
 509                                 L2FWD_EVENT_UPDT_MAC | L2FWD_EVENT_TX_ENQ);
 510 }
 511
 512 static void __rte_noinline
 513 l2fwd_event_main_loop_tx_q_brst_mac_vec(struct l2fwd_resources *rsrc)
 514 {
 515         l2fwd_event_loop_vector(rsrc,
 516                                 L2FWD_EVENT_UPDT_MAC | L2FWD_EVENT_TX_ENQ);
 517 }
 518
 519 void
 520 l2fwd_event_resource_setup(struct l2fwd_resources *rsrc)
 521 {
 522         /* [MAC_UPDT][TX_MODE][BURST] */
 523         const event_loop_cb event_loop[2][2][2][2] = {
 524                 [0][0][0][0] = l2fwd_event_main_loop_tx_d,
 525                 [0][0][0][1] = l2fwd_event_main_loop_tx_d_brst,
 526                 [0][0][1][0] = l2fwd_event_main_loop_tx_q,
 527                 [0][0][1][1] = l2fwd_event_main_loop_tx_q_brst,
 528                 [0][1][0][0] = l2fwd_event_main_loop_tx_d_mac,
 529                 [0][1][0][1] = l2fwd_event_main_loop_tx_d_brst_mac,
 530                 [0][1][1][0] = l2fwd_event_main_loop_tx_q_mac,
 531                 [0][1][1][1] = l2fwd_event_main_loop_tx_q_brst_mac,
 532                 [1][0][0][0] = l2fwd_event_main_loop_tx_d_vec,
 533                 [1][0][0][1] = l2fwd_event_main_loop_tx_d_brst_vec,
 534                 [1][0][1][0] = l2fwd_event_main_loop_tx_q_vec,
 535                 [1][0][1][1] = l2fwd_event_main_loop_tx_q_brst_vec,
 536                 [1][1][0][0] = l2fwd_event_main_loop_tx_d_mac_vec,
 537                 [1][1][0][1] = l2fwd_event_main_loop_tx_d_brst_mac_vec,
 538                 [1][1][1][0] = l2fwd_event_main_loop_tx_q_mac_vec,
 539                 [1][1][1][1] = l2fwd_event_main_loop_tx_q_brst_mac_vec,
 540         };
 541         struct l2fwd_event_resources *evt_rsrc;
 542         uint32_t event_queue_cfg;
 543         int ret;
 544
 545         if (!rte_event_dev_count())
 546                 rte_panic("No Eventdev found\n");
 547
 548         evt_rsrc = rte_zmalloc("l2fwd_event",
 549                                  sizeof(struct l2fwd_event_resources), 0);
 550         if (evt_rsrc == NULL)
 551                 rte_panic("Failed to allocate memory\n");
 552
 553         rsrc->evt_rsrc = evt_rsrc;
 554
 555         /* Setup eventdev capability callbacks */
 556         l2fwd_event_capability_setup(evt_rsrc);
 557
 558         /* Event device configuration */
 559         event_queue_cfg = evt_rsrc->ops.event_device_setup(rsrc);
 560
 561         /* Event queue configuration */
 562         evt_rsrc->ops.event_queue_setup(rsrc, event_queue_cfg);
 563
 564         /* Event port configuration */
 565         evt_rsrc->ops.event_port_setup(rsrc);
 566
 567         /* Rx/Tx adapters configuration */
 568         evt_rsrc->ops.adapter_setup(rsrc);
 569
 570         /* Start event device */
 571         ret = rte_event_dev_start(evt_rsrc->event_d_id);
 572         if (ret < 0)
 573                 rte_panic("Error in starting eventdev\n");
 574
 575         evt_rsrc->ops.l2fwd_event_loop =
 576                 event_loop[rsrc->evt_vec.enabled][rsrc->mac_updating]
 577                           [evt_rsrc->tx_mode_q][evt_rsrc->has_burst];
 578 }