DPDK patches and discussions
 help / color / mirror / Atom feed
* [PATCH v1 1/1] ethdev: introduce pool sort capability
@ 2022-08-12 10:46 Hanumanth Pothula
  2022-08-12 13:27 ` Morten Brørup
  2022-08-12 17:24 ` [PATCH v2 1/3] " Hanumanth Pothula
  0 siblings, 2 replies; 75+ messages in thread
From: Hanumanth Pothula @ 2022-08-12 10:46 UTC (permalink / raw)
  To: Thomas Monjalon, Ferruh Yigit, Andrew Rybchenko
  Cc: dev, xuan.ding, wenxuanx.wu, xiaoyun.li, stephen, yuanx.wang,
	mdr, yuying.zhang, qi.z.zhang, viacheslavo, jerinj, ndabilpuram,
	Hanumanth Pothula

Presently, the 'Buffer Split' feature supports sending multiple
segments of the received packet to PMD, which programs the HW
to receive the packet in segments from different pools.

This patch extends the feature to support the pool sort capability.
Some of the HW has support for choosing memory pools based on the
packet's size. The pool sort capability allows PMD to choose a
memory pool based on the packet's length.

This is often useful for saving the memory where the application
can create a different pool to steer the specific size of the
packet, thus enabling effective use of memory.

For example, let's say HW has a capability of three pools,
 - pool-1 size is 2K
 - pool-2 size is > 2K and < 4K
 - pool-3 size is > 4K
Here,
        pool-1 can accommodate packets with sizes < 2K
        pool-2 can accommodate packets with sizes > 2K and < 4K
        pool-3 can accommodate packets with sizes > 4K

With pool sort capability enabled in SW, an application may create
three pools of different sizes and send them to PMD. Allowing PMD
to program HW based on packet lengths. So that packets with less
than 2K are received on pool-1, packets with lengths between 2K
and 4K are received on pool-2 and finally packets greater than 4K
are received on pool-3.

The following two capabilities are added to the rte_eth_rxseg_capa
structure,
1. pool_sort --> tells pool sort capability is supported by HW.
2. max_npool --> max number of pools supported by HW.

Defined new structure rte_eth_rxseg_sort, to be used only when pool
sort capability is present. If required this may be extended further
to support more configurations.

Signed-off-by: Hanumanth Pothula <hpothula@marvell.com>
Change-Id: I5a2485a7919616902c468c767b5c01834d4a2c27
---
 lib/ethdev/rte_ethdev.c | 81 ++++++++++++++++++++++++++++++++++++++---
 lib/ethdev/rte_ethdev.h | 46 +++++++++++++++++++++--
 2 files changed, 119 insertions(+), 8 deletions(-)

diff --git a/lib/ethdev/rte_ethdev.c b/lib/ethdev/rte_ethdev.c
index 1979dc0850..e21a651787 100644
--- a/lib/ethdev/rte_ethdev.c
+++ b/lib/ethdev/rte_ethdev.c
@@ -1634,6 +1634,54 @@ rte_eth_dev_is_removed(uint16_t port_id)
 	return ret;
 }
 
+static int
+rte_eth_rx_queue_check_sort(const struct rte_eth_rxseg_sort *rx_seg,
+			     uint16_t n_seg, uint32_t *mbp_buf_size,
+			     const struct rte_eth_dev_info *dev_info)
+{
+	const struct rte_eth_rxseg_capa *seg_capa = &dev_info->rx_seg_capa;
+	uint16_t seg_idx;
+
+	if (!seg_capa->multi_pools || n_seg > seg_capa->max_npool) {
+		RTE_ETHDEV_LOG(ERR,
+			       "Invalid capabilities, multi_pools:%d differnt length segments %u exceed supported %u\n",
+			       seg_capa->multi_pools, n_seg, seg_capa->max_nseg);
+		return -EINVAL;
+	}
+
+	for (seg_idx = 0; seg_idx < n_seg; seg_idx++) {
+		struct rte_mempool *mpl = rx_seg[seg_idx].mp;
+		uint32_t length = rx_seg[seg_idx].length;
+
+		if (mpl == NULL) {
+			RTE_ETHDEV_LOG(ERR, "null mempool pointer\n");
+			return -EINVAL;
+		}
+
+		if (mpl->private_data_size <
+			sizeof(struct rte_pktmbuf_pool_private)) {
+			RTE_ETHDEV_LOG(ERR,
+				       "%s private_data_size %u < %u\n",
+				       mpl->name, mpl->private_data_size,
+				       (unsigned int)sizeof
+					(struct rte_pktmbuf_pool_private));
+			return -ENOSPC;
+		}
+
+		*mbp_buf_size = rte_pktmbuf_data_room_size(mpl);
+		length = length != 0 ? length : (*mbp_buf_size - RTE_PKTMBUF_HEADROOM);
+		if (*mbp_buf_size < length + RTE_PKTMBUF_HEADROOM) {
+			RTE_ETHDEV_LOG(ERR,
+				       "%s mbuf_data_room_size %u < %u))\n",
+				       mpl->name, *mbp_buf_size,
+				       length);
+			return -EINVAL;
+		}
+	}
+
+	return 0;
+}
+
 static int
 rte_eth_rx_queue_check_split(const struct rte_eth_rxseg_split *rx_seg,
 			     uint16_t n_seg, uint32_t *mbp_buf_size,
@@ -1693,7 +1741,11 @@ rte_eth_rx_queue_check_split(const struct rte_eth_rxseg_split *rx_seg,
 		}
 		offset += seg_idx != 0 ? 0 : RTE_PKTMBUF_HEADROOM;
 		*mbp_buf_size = rte_pktmbuf_data_room_size(mpl);
-		length = length != 0 ? length : *mbp_buf_size;
+		/* On segment length == 0, update segment's length with
+		 * the pool's length - headeroom space, to make sure enough
+		 * space is accomidate for header.
+		 **/
+		length = length != 0 ? length : (*mbp_buf_size - RTE_PKTMBUF_HEADROOM);
 		if (*mbp_buf_size < length + offset) {
 			RTE_ETHDEV_LOG(ERR,
 				       "%s mbuf_data_room_size %u < %u (segment length=%u + segment offset=%u)\n",
@@ -1765,6 +1817,7 @@ rte_eth_rx_queue_setup(uint16_t port_id, uint16_t rx_queue_id,
 		}
 	} else {
 		const struct rte_eth_rxseg_split *rx_seg;
+		const struct rte_eth_rxseg_sort *rx_sort;
 		uint16_t n_seg;
 
 		/* Extended multi-segment configuration check. */
@@ -1774,13 +1827,31 @@ rte_eth_rx_queue_setup(uint16_t port_id, uint16_t rx_queue_id,
 			return -EINVAL;
 		}
 
-		rx_seg = (const struct rte_eth_rxseg_split *)rx_conf->rx_seg;
 		n_seg = rx_conf->rx_nseg;
 
 		if (rx_conf->offloads & RTE_ETH_RX_OFFLOAD_BUFFER_SPLIT) {
-			ret = rte_eth_rx_queue_check_split(rx_seg, n_seg,
-							   &mbp_buf_size,
-							   &dev_info);
+			ret = -1; /* To make sure at least one of below conditions becomes true */
+
+			/* Check both NIX and application supports buffer-split capability */
+			if (dev_info.rx_seg_capa.mode_flag == RTE_ETH_RXSEG_MODE_SPLIT &&
+			    rx_conf->rx_seg->mode_flag == RTE_ETH_RXSEG_MODE_SPLIT) {
+				rx_seg = (const struct rte_eth_rxseg_split *)
+					 &(rx_conf->rx_seg->split);
+				ret = rte_eth_rx_queue_check_split(rx_seg, n_seg,
+								   &mbp_buf_size,
+								   &dev_info);
+			}
+
+			/* Check both NIX and application supports pool-sort capability */
+			if (dev_info.rx_seg_capa.mode_flag == RTE_ETH_RXSEG_MODE_SORT &&
+			    rx_conf->rx_seg->mode_flag == RTE_ETH_RXSEG_MODE_SORT) {
+				rx_sort = (const struct rte_eth_rxseg_sort *)
+					  &(rx_conf->rx_seg->sort);
+				ret = rte_eth_rx_queue_check_sort(rx_sort, n_seg,
+								  &mbp_buf_size,
+								  &dev_info);
+			}
+
 			if (ret != 0)
 				return ret;
 		} else {
diff --git a/lib/ethdev/rte_ethdev.h b/lib/ethdev/rte_ethdev.h
index de9e970d4d..9ff8ba8085 100644
--- a/lib/ethdev/rte_ethdev.h
+++ b/lib/ethdev/rte_ethdev.h
@@ -1204,16 +1204,53 @@ struct rte_eth_rxseg_split {
 	uint32_t reserved; /**< Reserved field. */
 };
 
+/**
+ * The pool sort capability allows PMD to choose a memory pool based on the
+ * packet's length. So, basically, PMD programs HW for receiving packets from
+ * different pools, based on the packet's length.
+ *
+ * This is often useful for saving the memory where the application can create
+ * a different pool to steer the specific size of the packet, thus enabling
+ * effective use of memory.
+ */
+struct rte_eth_rxseg_sort {
+	struct rte_mempool *mp; /**< Memory pool to allocate packets from. */
+	uint16_t length; /**< Packet data length. */
+	uint32_t reserved; /**< Reserved field. */
+};
+
+enum rte_eth_rxseg_mode {
+	/**
+	 * Buffer split mode: PMD split the received packets into multiple segments.
+	 * @see struct rte_eth_rxseg_split
+	 */
+	RTE_ETH_RXSEG_MODE_SPLIT = RTE_BIT64(0),
+	/**
+	 * Pool sort mode: PMD to chooses a memory pool based on the packet's length.
+	 * @see struct rte_eth_rxseg_sort
+	 */
+	RTE_ETH_RXSEG_MODE_SORT  = RTE_BIT64(1),
+};
+
 /**
  * @warning
  * @b EXPERIMENTAL: this structure may change without prior notice.
  *
  * A common structure used to describe Rx packet segment properties.
  */
-union rte_eth_rxseg {
+struct rte_eth_rxseg {
+
+	/**
+	 * PMD may support more than one rxseg mode. This allows application
+	 * to chose which mode to enable.
+	 */
+	enum rte_eth_rxseg_mode mode_flag;
+
 	/* The settings for buffer split offload. */
 	struct rte_eth_rxseg_split split;
-	/* The other features settings should be added here. */
+
+	/*The settings for packet sort offload. */
+	struct rte_eth_rxseg_sort sort;
 };
 
 /**
@@ -1246,7 +1283,7 @@ struct rte_eth_rxconf {
 	 * The supported capabilities of receiving segmentation is reported
 	 * in rte_eth_dev_info.rx_seg_capa field.
 	 */
-	union rte_eth_rxseg *rx_seg;
+	struct rte_eth_rxseg *rx_seg;
 
 	uint64_t reserved_64s[2]; /**< Reserved for future fields */
 	void *reserved_ptrs[2];   /**< Reserved for future fields */
@@ -1831,6 +1868,9 @@ struct rte_eth_rxseg_capa {
 	uint32_t offset_allowed:1; /**< Supports buffer offsets. */
 	uint32_t offset_align_log2:4; /**< Required offset alignment. */
 	uint16_t max_nseg; /**< Maximum amount of segments to split. */
+	/* < Maximum amount of pools that PMD can sort based on packet/segment lengths */
+	uint16_t max_npool;
+	enum rte_eth_rxseg_mode mode_flag; /**< supported rxseg  modes */
 	uint16_t reserved; /**< Reserved field. */
 };
 
-- 
2.25.1


^ permalink raw reply	[flat|nested] 75+ messages in thread

end of thread, other threads:[~2022-11-17 11:38 UTC | newest]

Thread overview: 75+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-08-12 10:46 [PATCH v1 1/1] ethdev: introduce pool sort capability Hanumanth Pothula
2022-08-12 13:27 ` Morten Brørup
2022-08-12 17:24 ` [PATCH v2 1/3] " Hanumanth Pothula
2022-08-12 17:24   ` [PATCH v2 2/3] app/testpmd: add command line argument 'rxseg-mode' Hanumanth Pothula
2022-08-12 17:24   ` [PATCH v2 3/3] net/cnxk: introduce pool sort capability Hanumanth Pothula
2022-08-23  3:26   ` [PATCH v2 1/3] ethdev: " Ding, Xuan
2022-08-24 15:33     ` Ferruh Yigit
2022-08-30 12:08       ` [EXT] " Hanumanth Reddy Pothula
2022-09-06 12:18         ` Ferruh Yigit
2022-09-07  7:02           ` Hanumanth Reddy Pothula
2022-09-07 11:24             ` Ferruh Yigit
2022-09-07 21:31               ` Hanumanth Reddy Pothula
2022-09-13  9:28                 ` Ferruh Yigit
2022-09-13 10:00                   ` Hanumanth Reddy Pothula
2022-09-02  7:00   ` [PATCH v3 " Hanumanth Pothula
2022-09-02  7:00     ` [PATCH v3 2/3] app/testpmd: Add support for " Hanumanth Pothula
2022-09-02  7:00     ` [PATCH v3 3/3] net/cnxk: introduce " Hanumanth Pothula
2022-09-13  8:06     ` [PATCH v3 1/3] ethdev: " Andrew Rybchenko
2022-09-13  9:31       ` Ferruh Yigit
2022-09-13 10:41         ` [EXT] " Hanumanth Reddy Pothula
2022-09-15  7:07     ` [PATCH v4 1/3] ethdev: Add support for mulitiple mbuf pools per Rx queue Hanumanth Pothula
2022-09-15  7:07       ` [PATCH v4 2/3] app/testpmd: " Hanumanth Pothula
2022-09-15  7:07       ` [PATCH v4 3/3] net/cnxk: Add support for mulitiple mbuf pools Hanumanth Pothula
2022-09-28  9:43       ` [PATCH v4 1/3] ethdev: Add support for mulitiple mbuf pools per Rx queue Andrew Rybchenko
2022-09-28 11:06         ` Thomas Monjalon
2022-10-06 17:01       ` [PATCH v5 1/3] ethdev: support " Hanumanth Pothula
2022-10-06 17:01         ` [PATCH v5 2/3] net/cnxk: " Hanumanth Pothula
2022-10-06 17:01         ` [PATCH v5 3/3] app/testpmd: " Hanumanth Pothula
2022-10-06 17:29         ` [PATCH v5 1/3] ethdev: " Stephen Hemminger
2022-10-07 14:13           ` Andrew Rybchenko
2022-10-06 17:53         ` [PATCH v6 " Hanumanth Pothula
2022-10-06 17:53           ` [PATCH v6 2/3] net/cnxk: " Hanumanth Pothula
2022-10-06 17:53           ` [PATCH v6 3/3] app/testpmd: " Hanumanth Pothula
2022-10-06 18:14           ` [PATCH v6 1/3] ethdev: " Hanumanth Reddy Pothula
2022-10-07 14:37         ` [PATCH v7 0/4] " Andrew Rybchenko
2022-10-07 14:37           ` [PATCH v7 1/4] ethdev: factor out helper function to check Rx mempool Andrew Rybchenko
2022-10-07 14:37           ` [PATCH v7 2/4] ethdev: support mulitiple mbuf pools per Rx queue Andrew Rybchenko
2022-10-07 16:08             ` Thomas Monjalon
2022-10-07 16:18               ` Stephen Hemminger
2022-10-07 16:20                 ` Stephen Hemminger
2022-10-07 16:33                   ` Andrew Rybchenko
2022-10-07 17:30               ` Andrew Rybchenko
2022-10-07 14:37           ` [PATCH v7 3/4] net/cnxk: " Andrew Rybchenko
2022-10-07 14:37           ` [PATCH v7 4/4] app/testpmd: " Andrew Rybchenko
2022-10-07 17:29         ` [PATCH v8 0/4] ethdev: " Andrew Rybchenko
2022-10-07 17:29           ` [PATCH v8 1/4] ethdev: factor out helper function to check Rx mempool Andrew Rybchenko
2022-10-07 17:29           ` [PATCH v8 2/4] ethdev: support multiple mbuf pools per Rx queue Andrew Rybchenko
2022-10-07 18:35             ` Thomas Monjalon
2022-10-07 19:45               ` Andrew Rybchenko
2022-10-07 17:29           ` [PATCH v8 3/4] net/cnxk: support mulitiple " Andrew Rybchenko
2022-10-07 17:29           ` [PATCH v8 4/4] app/testpmd: " Andrew Rybchenko
     [not found]             ` <PH0PR18MB47500560DC1793F68E7312DDCB5F9@PH0PR18MB4750.namprd18.prod.outlook.com>
2022-10-07 19:43               ` [EXT] " Andrew Rybchenko
2022-10-07 19:56                 ` Hanumanth Reddy Pothula
2022-10-17  8:48             ` [PATCH v9 1/1] " Hanumanth Pothula
2022-10-21 15:57               ` Singh, Aman Deep
2022-10-24  3:32                 ` [EXT] " Hanumanth Reddy Pothula
2022-10-24  4:07               ` [PATCH v10 1/1] app/testpmd: support multiple " Hanumanth Pothula
2022-10-25  1:40                 ` [PATCH v11 " Hanumanth Pothula
2022-11-01 14:13                   ` Hanumanth Reddy Pothula
2022-11-03 12:15                   ` Singh, Aman Deep
2022-11-03 12:36                     ` [EXT] " Hanumanth Reddy Pothula
2022-11-03 15:20                       ` Singh, Aman Deep
2022-11-04 15:38                         ` Hanumanth Reddy Pothula
2022-11-07  5:31                   ` [PATCH v12 " Hanumanth Pothula
2022-11-09  8:04                     ` Singh, Aman Deep
2022-11-09 10:39                       ` Andrew Rybchenko
2022-11-10  6:51                         ` Andrew Rybchenko
2022-11-10  8:17                     ` [PATCH v13 " Hanumanth Pothula
2022-11-10  9:01                       ` Andrew Rybchenko
2022-11-10  9:31                         ` [EXT] " Hanumanth Reddy Pothula
2022-11-10 10:16                       ` [PATCH v14 " Hanumanth Pothula
2022-11-10 10:47                         ` Andrew Rybchenko
2022-11-17  8:43                         ` Jiang, YuX
2022-11-17 11:38                           ` Hanumanth Reddy Pothula
2022-10-08 20:38           ` [PATCH v8 0/4] ethdev: support mulitiple " Thomas Monjalon

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).