lib/port/rte_port_sched.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4 #include <string.h>
   5
   6 #include <rte_malloc.h>
   7
   8 #include "rte_port_sched.h"
   9
  10 /*
  11  * Reader
  12  */
  13 #ifdef RTE_PORT_STATS_COLLECT
  14
  15 #define RTE_PORT_SCHED_READER_PKTS_IN_ADD(port, val) \
  16         port->stats.n_pkts_in += val
  17 #define RTE_PORT_SCHED_READER_PKTS_DROP_ADD(port, val) \
  18         port->stats.n_pkts_drop += val
  19
  20 #else
  21
  22 #define RTE_PORT_SCHED_READER_PKTS_IN_ADD(port, val)
  23 #define RTE_PORT_SCHED_READER_PKTS_DROP_ADD(port, val)
  24
  25 #endif
  26
  27 struct rte_port_sched_reader {
  28         struct rte_port_in_stats stats;
  29
  30         struct rte_sched_port *sched;
  31 };
  32
  33 static void *
  34 rte_port_sched_reader_create(void *params, int socket_id)
  35 {
  36         struct rte_port_sched_reader_params *conf =
  37                         params;
  38         struct rte_port_sched_reader *port;
  39
  40         /* Check input parameters */
  41         if ((conf == NULL) ||
  42             (conf->sched == NULL)) {
  43                 RTE_LOG(ERR, PORT, "%s: Invalid params\n", __func__);
  44                 return NULL;
  45         }
  46
  47         /* Memory allocation */
  48         port = rte_zmalloc_socket("PORT", sizeof(*port),
  49                         RTE_CACHE_LINE_SIZE, socket_id);
  50         if (port == NULL) {
  51                 RTE_LOG(ERR, PORT, "%s: Failed to allocate port\n", __func__);
  52                 return NULL;
  53         }
  54
  55         /* Initialization */
  56         port->sched = conf->sched;
  57
  58         return port;
  59 }
  60
  61 static int
  62 rte_port_sched_reader_rx(void *port, struct rte_mbuf **pkts, uint32_t n_pkts)
  63 {
  64         struct rte_port_sched_reader *p = port;
  65         uint32_t nb_rx;
  66
  67         nb_rx = rte_sched_port_dequeue(p->sched, pkts, n_pkts);
  68         RTE_PORT_SCHED_READER_PKTS_IN_ADD(p, nb_rx);
  69
  70         return nb_rx;
  71 }
  72
  73 static int
  74 rte_port_sched_reader_free(void *port)
  75 {
  76         if (port == NULL) {
  77                 RTE_LOG(ERR, PORT, "%s: port is NULL\n", __func__);
  78                 return -EINVAL;
  79         }
  80
  81         rte_free(port);
  82
  83         return 0;
  84 }
  85
  86 static int
  87 rte_port_sched_reader_stats_read(void *port,
  88                 struct rte_port_in_stats *stats, int clear)
  89 {
  90         struct rte_port_sched_reader *p =
  91                 port;
  92
  93         if (stats != NULL)
  94                 memcpy(stats, &p->stats, sizeof(p->stats));
  95
  96         if (clear)
  97                 memset(&p->stats, 0, sizeof(p->stats));
  98
  99         return 0;
 100 }
 101
 102 /*
 103  * Writer
 104  */
 105 #ifdef RTE_PORT_STATS_COLLECT
 106
 107 #define RTE_PORT_SCHED_WRITER_STATS_PKTS_IN_ADD(port, val) \
 108         port->stats.n_pkts_in += val
 109 #define RTE_PORT_SCHED_WRITER_STATS_PKTS_DROP_ADD(port, val) \
 110         port->stats.n_pkts_drop += val
 111
 112 #else
 113
 114 #define RTE_PORT_SCHED_WRITER_STATS_PKTS_IN_ADD(port, val)
 115 #define RTE_PORT_SCHED_WRITER_STATS_PKTS_DROP_ADD(port, val)
 116
 117 #endif
 118
 119 struct rte_port_sched_writer {
 120         struct rte_port_out_stats stats;
 121
 122         struct rte_mbuf *tx_buf[2 * RTE_PORT_IN_BURST_SIZE_MAX];
 123         struct rte_sched_port *sched;
 124         uint32_t tx_burst_sz;
 125         uint32_t tx_buf_count;
 126         uint64_t bsz_mask;
 127 };
 128
 129 static void *
 130 rte_port_sched_writer_create(void *params, int socket_id)
 131 {
 132         struct rte_port_sched_writer_params *conf =
 133                         params;
 134         struct rte_port_sched_writer *port;
 135
 136         /* Check input parameters */
 137         if ((conf == NULL) ||
 138             (conf->sched == NULL) ||
 139             (conf->tx_burst_sz == 0) ||
 140             (conf->tx_burst_sz > RTE_PORT_IN_BURST_SIZE_MAX) ||
 141                 (!rte_is_power_of_2(conf->tx_burst_sz))) {
 142                 RTE_LOG(ERR, PORT, "%s: Invalid params\n", __func__);
 143                 return NULL;
 144         }
 145
 146         /* Memory allocation */
 147         port = rte_zmalloc_socket("PORT", sizeof(*port),
 148                         RTE_CACHE_LINE_SIZE, socket_id);
 149         if (port == NULL) {
 150                 RTE_LOG(ERR, PORT, "%s: Failed to allocate port\n", __func__);
 151                 return NULL;
 152         }
 153
 154         /* Initialization */
 155         port->sched = conf->sched;
 156         port->tx_burst_sz = conf->tx_burst_sz;
 157         port->tx_buf_count = 0;
 158         port->bsz_mask = 1LLU << (conf->tx_burst_sz - 1);
 159
 160         return port;
 161 }
 162
 163 static int
 164 rte_port_sched_writer_tx(void *port, struct rte_mbuf *pkt)
 165 {
 166         struct rte_port_sched_writer *p = (struct rte_port_sched_writer *) port;
 167
 168         p->tx_buf[p->tx_buf_count++] = pkt;
 169         RTE_PORT_SCHED_WRITER_STATS_PKTS_IN_ADD(p, 1);
 170         if (p->tx_buf_count >= p->tx_burst_sz) {
 171                 __rte_unused uint32_t nb_tx;
 172
 173                 nb_tx = rte_sched_port_enqueue(p->sched, p->tx_buf, p->tx_buf_count);
 174                 RTE_PORT_SCHED_WRITER_STATS_PKTS_DROP_ADD(p, p->tx_buf_count - nb_tx);
 175                 p->tx_buf_count = 0;
 176         }
 177
 178         return 0;
 179 }
 180
 181 static int
 182 rte_port_sched_writer_tx_bulk(void *port,
 183                 struct rte_mbuf **pkts,
 184                 uint64_t pkts_mask)
 185 {
 186         struct rte_port_sched_writer *p = (struct rte_port_sched_writer *) port;
 187         uint64_t bsz_mask = p->bsz_mask;
 188         uint32_t tx_buf_count = p->tx_buf_count;
 189         uint64_t expr = (pkts_mask & (pkts_mask + 1)) |
 190                         ((pkts_mask & bsz_mask) ^ bsz_mask);
 191
 192         if (expr == 0) {
 193                 __rte_unused uint32_t nb_tx;
 194                 uint64_t n_pkts = __builtin_popcountll(pkts_mask);
 195
 196                 if (tx_buf_count) {
 197                         nb_tx = rte_sched_port_enqueue(p->sched, p->tx_buf,
 198                                 tx_buf_count);
 199                         RTE_PORT_SCHED_WRITER_STATS_PKTS_DROP_ADD(p, tx_buf_count - nb_tx);
 200                         p->tx_buf_count = 0;
 201                 }
 202
 203                 nb_tx = rte_sched_port_enqueue(p->sched, pkts, n_pkts);
 204                 RTE_PORT_SCHED_WRITER_STATS_PKTS_DROP_ADD(p, n_pkts - nb_tx);
 205         } else {
 206                 for ( ; pkts_mask; ) {
 207                         uint32_t pkt_index = __builtin_ctzll(pkts_mask);
 208                         uint64_t pkt_mask = 1LLU << pkt_index;
 209                         struct rte_mbuf *pkt = pkts[pkt_index];
 210
 211                         p->tx_buf[tx_buf_count++] = pkt;
 212                         RTE_PORT_SCHED_WRITER_STATS_PKTS_IN_ADD(p, 1);
 213                         pkts_mask &= ~pkt_mask;
 214                 }
 215                 p->tx_buf_count = tx_buf_count;
 216
 217                 if (tx_buf_count >= p->tx_burst_sz) {
 218                         __rte_unused uint32_t nb_tx;
 219
 220                         nb_tx = rte_sched_port_enqueue(p->sched, p->tx_buf,
 221                                 tx_buf_count);
 222                         RTE_PORT_SCHED_WRITER_STATS_PKTS_DROP_ADD(p, tx_buf_count - nb_tx);
 223                         p->tx_buf_count = 0;
 224                 }
 225         }
 226
 227         return 0;
 228 }
 229
 230 static int
 231 rte_port_sched_writer_flush(void *port)
 232 {
 233         struct rte_port_sched_writer *p = (struct rte_port_sched_writer *) port;
 234
 235         if (p->tx_buf_count) {
 236                 __rte_unused uint32_t nb_tx;
 237
 238                 nb_tx = rte_sched_port_enqueue(p->sched, p->tx_buf, p->tx_buf_count);
 239                 RTE_PORT_SCHED_WRITER_STATS_PKTS_DROP_ADD(p, p->tx_buf_count - nb_tx);
 240                 p->tx_buf_count = 0;
 241         }
 242
 243         return 0;
 244 }
 245
 246 static int
 247 rte_port_sched_writer_free(void *port)
 248 {
 249         if (port == NULL) {
 250                 RTE_LOG(ERR, PORT, "%s: port is NULL\n", __func__);
 251                 return -EINVAL;
 252         }
 253
 254         rte_port_sched_writer_flush(port);
 255         rte_free(port);
 256
 257         return 0;
 258 }
 259
 260 static int
 261 rte_port_sched_writer_stats_read(void *port,
 262                 struct rte_port_out_stats *stats, int clear)
 263 {
 264         struct rte_port_sched_writer *p =
 265                 port;
 266
 267         if (stats != NULL)
 268                 memcpy(stats, &p->stats, sizeof(p->stats));
 269
 270         if (clear)
 271                 memset(&p->stats, 0, sizeof(p->stats));
 272
 273         return 0;
 274 }
 275
 276 /*
 277  * Summary of port operations
 278  */
 279 struct rte_port_in_ops rte_port_sched_reader_ops = {
 280         .f_create = rte_port_sched_reader_create,
 281         .f_free = rte_port_sched_reader_free,
 282         .f_rx = rte_port_sched_reader_rx,
 283         .f_stats = rte_port_sched_reader_stats_read,
 284 };
 285
 286 struct rte_port_out_ops rte_port_sched_writer_ops = {
 287         .f_create = rte_port_sched_writer_create,
 288         .f_free = rte_port_sched_writer_free,
 289         .f_tx = rte_port_sched_writer_tx,
 290         .f_tx_bulk = rte_port_sched_writer_tx_bulk,
 291         .f_flush = rte_port_sched_writer_flush,
 292         .f_stats = rte_port_sched_writer_stats_read,
 293 };