ethdev: increase port id range

[dpdk.git] / examples / load_balancer / runtime.c

diff --git a/examples/load_balancer/runtime.c b/examples/load_balancer/runtime.c
index 438224a..b342e75 100644 (file)
--- a/examples/load_balancer/runtime.c
+++ b/examples/load_balancer/runtime.c
@@ -48,9 +48,7 @@
 #include <rte_memory.h>
 #include <rte_memcpy.h>
 #include <rte_memzone.h>
-#include <rte_tailq.h>
 #include <rte_eal.h>
-#include <rte_per_lcore.h>
 #include <rte_launch.h>
 #include <rte_atomic.h>
 #include <rte_cycles.h>
@@ -145,9 +143,10 @@ app_lcore_io_rx_buffer_to_send (
        ret = rte_ring_sp_enqueue_bulk(
                lp->rx.rings[worker],
                (void **) lp->rx.mbuf_out[worker].array,
-               bsz);
+               bsz,
+               NULL);
 
-       if (unlikely(ret == -ENOBUFS)) {
+       if (unlikely(ret == 0)) {
                uint32_t k;
                for (k = 0; k < bsz; k ++) {
                        struct rte_mbuf *m = lp->rx.mbuf_out[worker].array[k];
@@ -189,7 +188,7 @@ app_lcore_io_rx(
        uint32_t i;
 
        for (i = 0; i < lp->rx.n_nic_queues; i ++) {
-               uint8_t port = lp->rx.nic_queues[i].port;
+               uint16_t port = lp->rx.nic_queues[i].port;
                uint8_t queue = lp->rx.nic_queues[i].queue;
                uint32_t n_mbufs, j;
 
@@ -214,8 +213,8 @@ app_lcore_io_rx(
 
                        printf("I/O RX %u in (NIC port %u): NIC drop ratio = %.2f avg burst size = %.2f\n",
                                lcore,
-                               (unsigned) port,
-                               (double) stats.ierrors / (double) (stats.ierrors + stats.ipackets),
+                               port,
+                               (double) stats.imissed / (double) (stats.imissed + stats.ipackets),
                                ((double) lp->rx.nic_queues_count[i]) / ((double) lp->rx.nic_queues_iters[i]));
                        lp->rx.nic_queues_iters[i] = 0;
                        lp->rx.nic_queues_count[i] = 0;
@@ -311,9 +310,10 @@ app_lcore_io_rx_flush(struct app_lcore_params_io *lp, uint32_t n_workers)
                ret = rte_ring_sp_enqueue_bulk(
                        lp->rx.rings[worker],
                        (void **) lp->rx.mbuf_out[worker].array,
-                       lp->rx.mbuf_out[worker].n_mbufs);
+                       lp->rx.mbuf_out[worker].n_mbufs,
+                       NULL);
 
-               if (unlikely(ret < 0)) {
+               if (unlikely(ret == 0)) {
                        uint32_t k;
                        for (k = 0; k < lp->rx.mbuf_out[worker].n_mbufs; k ++) {
                                struct rte_mbuf *pkt_to_free = lp->rx.mbuf_out[worker].array[k];
@@ -339,7 +339,7 @@ app_lcore_io_tx(
                uint32_t i;
 
                for (i = 0; i < lp->tx.n_nic_ports; i ++) {
-                       uint8_t port = lp->tx.nic_ports[i];
+                       uint16_t port = lp->tx.nic_ports[i];
                        struct rte_ring *ring = lp->tx.rings[port][worker];
                        uint32_t n_mbufs, n_pkts;
                        int ret;
@@ -348,11 +348,11 @@ app_lcore_io_tx(
                        ret = rte_ring_sc_dequeue_bulk(
                                ring,
                                (void **) &lp->tx.mbuf_out[port].array[n_mbufs],
-                               bsz_rd);
+                               bsz_rd,
+                               NULL);
 
-                       if (unlikely(ret == -ENOENT)) {
+                       if (unlikely(ret == 0))
                                continue;
-                       }
 
                        n_mbufs += bsz_rd;
 
@@ -395,7 +395,7 @@ app_lcore_io_tx(
 
                                printf("\t\t\tI/O TX %u out (port %u): avg burst size = %.2f\n",
                                        lcore,
-                                       (unsigned) port,
+                                       port,
                                        ((double) lp->tx.nic_ports_count[port]) / ((double) lp->tx.nic_ports_iters[port]));
                                lp->tx.nic_ports_iters[port] = 0;
                                lp->tx.nic_ports_count[port] = 0;
@@ -418,11 +418,13 @@ app_lcore_io_tx(
 static inline void
 app_lcore_io_tx_flush(struct app_lcore_params_io *lp)
 {
-       uint8_t port;
+       uint16_t port;
+       uint32_t i;
 
-       for (port = 0; port < lp->tx.n_nic_ports; port ++) {
+       for (i = 0; i < lp->tx.n_nic_ports; i++) {
                uint32_t n_pkts;
 
+               port = lp->tx.nic_ports[i];
                if (likely((lp->tx.mbuf_out_flush[port] == 0) ||
                           (lp->tx.mbuf_out[port].n_mbufs == 0))) {
                        lp->tx.mbuf_out_flush[port] = 1;
@@ -504,11 +506,11 @@ app_lcore_worker(
                ret = rte_ring_sc_dequeue_bulk(
                        ring_in,
                        (void **) lp->mbuf_in.array,
-                       bsz_rd);
+                       bsz_rd,
+                       NULL);
 
-               if (unlikely(ret == -ENOENT)) {
+               if (unlikely(ret == 0))
                        continue;
-               }
 
 #if APP_WORKER_DROP_ALL_PACKETS
                for (j = 0; j < bsz_rd; j ++) {
@@ -526,7 +528,7 @@ app_lcore_worker(
                        struct rte_mbuf *pkt;
                        struct ipv4_hdr *ipv4_hdr;
                        uint32_t ipv4_dst, pos;
-                       uint8_t port;
+                       uint32_t port;
 
                        if (likely(j < bsz_rd - 1)) {
                                APP_WORKER_PREFETCH1(rte_pktmbuf_mtod(lp->mbuf_in.array[j+1], unsigned char *));
@@ -536,11 +538,13 @@ app_lcore_worker(
                        }
 
                        pkt = lp->mbuf_in.array[j];
-                       ipv4_hdr = (struct ipv4_hdr *)(rte_pktmbuf_mtod(pkt, unsigned char *) + sizeof(struct ether_hdr));
+                       ipv4_hdr = rte_pktmbuf_mtod_offset(pkt,
+                                                          struct ipv4_hdr *,
+                                                          sizeof(struct ether_hdr));
                        ipv4_dst = rte_be_to_cpu_32(ipv4_hdr->dst_addr);
 
                        if (unlikely(rte_lpm_lookup(lp->lpm_table, ipv4_dst, &port) != 0)) {
-                               port = pkt->pkt.in_port;
+                               port = pkt->port;
                        }
 
                        pos = lp->mbuf_out[port].n_mbufs;
@@ -554,24 +558,25 @@ app_lcore_worker(
                        ret = rte_ring_sp_enqueue_bulk(
                                lp->rings_out[port],
                                (void **) lp->mbuf_out[port].array,
-                               bsz_wr);
+                               bsz_wr,
+                               NULL);
 
 #if APP_STATS
                        lp->rings_out_iters[port] ++;
-                       if (ret == 0) {
+                       if (ret > 0) {
                                lp->rings_out_count[port] += 1;
                        }
                        if (lp->rings_out_iters[port] == APP_STATS){
                                printf("\t\tWorker %u out (NIC port %u): enq success rate = %.2f\n",
                                        (unsigned) lp->worker_id,
-                                       (unsigned) port,
+                                       port,
                                        ((double) lp->rings_out_count[port]) / ((double) lp->rings_out_iters[port]));
                                lp->rings_out_iters[port] = 0;
                                lp->rings_out_count[port] = 0;
                        }
 #endif
 
-                       if (unlikely(ret == -ENOBUFS)) {
+                       if (unlikely(ret == 0)) {
                                uint32_t k;
                                for (k = 0; k < bsz_wr; k ++) {
                                        struct rte_mbuf *pkt_to_free = lp->mbuf_out[port].array[k];
@@ -606,9 +611,10 @@ app_lcore_worker_flush(struct app_lcore_params_worker *lp)
                ret = rte_ring_sp_enqueue_bulk(
                        lp->rings_out[port],
                        (void **) lp->mbuf_out[port].array,
-                       lp->mbuf_out[port].n_mbufs);
+                       lp->mbuf_out[port].n_mbufs,
+                       NULL);
 
-               if (unlikely(ret < 0)) {
+               if (unlikely(ret == 0)) {
                        uint32_t k;
                        for (k = 0; k < lp->mbuf_out[port].n_mbufs; k ++) {
                                struct rte_mbuf *pkt_to_free = lp->mbuf_out[port].array[k];