Skip to contentSkip to conversation

mbuf: add bulk free function

PATCH Superseded Morten Brørup 3 participants 6 messages Oct 7, 2019 – Oct 9, 2019

v4 of 9 Superseded Latest is v9 →

lore
Share & tools
lore
#0 lore raw

v4 cover mbuf: add bulk free function

Add function for freeing a bulk of mbufs.

v4:
* Marked as experimental by adding __rte_experimental.
* Add function to experimental section of map file.
* Fix source code formatting regarding pointer to pointer.
* Squashed multiple modifications into one.
v3:
* Bugfix: Handle pakets with multiple segments.
* Added inline helper function, mainly for readability.
* Fix source code formatting regarding indentation.
v2:
* Function is not inline.
* Optimized to free multible mbufs belonging to the same mempool in bulk. Inspired by ixgbe_tx_free_bufs(), but allowing NULL pointers in the array, just like rte_pktmbuf_free() can take a NULL pointer.
* Use unsigned int instead of unsigned. Passes checkpatch, but mismatches the original coding style of the modified files.
* Fixed a typo in the description headline: mempools is plural.

Morten Brørup (1):
mbuf: add bulk free function

 lib/librte_mbuf/rte_mbuf.c           | 50 ++++++++++++++++++++++++++++
 lib/librte_mbuf/rte_mbuf.h           | 12 +++++++
 lib/librte_mbuf/rte_mbuf_version.map |  1 +
 3 files changed, 63 insertions(+)
Signature · 1 line
2.17.1
#1 lore raw

PATCH v4 1/1 mbuf: add bulk free function

Add function for freeing a bulk of mbufs.

v4:
* Marked as experimental by adding __rte_experimental.
* Add function to experimental section of map file.
* Fix source code formatting regarding pointer to pointer.
* Squashed multiple modifications into one.
v3:
* Bugfix: Handle pakets with multiple segments.
* Added inline helper function, mainly for readability.
* Fix source code formatting regarding indentation.
v2:
* Function is not inline.
* Optimized to free multible mbufs belonging to the same mempool in bulk. Inspired by ixgbe_tx_free_bufs(), but allowing NULL pointers in the array, just like rte_pktmbuf_free() can take a NULL pointer.
* Use unsigned int instead of unsigned. Passes checkpatch, but mismatches the original coding style of the modified files.
* Fixed a typo in the description headline: mempools is plural.

---
 lib/librte_mbuf/rte_mbuf.c           | 50 ++++++++++++++++++++++++++++
 lib/librte_mbuf/rte_mbuf.h           | 12 +++++++
 lib/librte_mbuf/rte_mbuf_version.map |  1 +
 3 files changed, 63 insertions(+)
lib/librte_mbuf/rte_mbuf.c +50 -0
index 37718d49c..0088117a3 100644
@@ -245,6 +245,56 @@ int rte_mbuf_check(const struct rte_mbuf *m, int is_header,
 	return 0;
 }
 
+/**
+ * Size of the array holding mbufs from the same membool to be freed in bulk.
+ */
+#define RTE_PKTMBUF_FREE_BULK_SZ 64
+
+/**
+ * @internal helper function for freeing a bulk of mbufs via an array holding
+ * mbufs from the same mempool.
+ */
+static __rte_always_inline void
+rte_pktmbuf_free_seg_via_array(struct rte_mbuf *m,
+	struct rte_mbuf ** const free, unsigned int * const nb_free)
+{
+	m = rte_pktmbuf_prefree_seg(m);
+	if (likely(m != NULL)) {
+		if (*nb_free >= RTE_PKTMBUF_FREE_BULK_SZ ||
+		    (*nb_free > 0 && m->pool != free[0]->pool)) {
+			rte_mempool_put_bulk(free[0]->pool, (void **)free,
+					     *nb_free);
+			*nb_free = 0;
+		}
+
+		free[(*nb_free)++] = m;
+	}
+}
+
+/* Free a bulk of mbufs back into their original mempools. */
+void rte_pktmbuf_free_bulk(struct rte_mbuf **mbufs, unsigned int count)
+{
+	struct rte_mbuf *m, *m_next, *free[RTE_PKTMBUF_FREE_BULK_SZ];
+	unsigned int idx, nb_free = 0;
+
+	for (idx = 0; idx < count; idx++) {
+		m = mbufs[idx];
+		if (unlikely(m == NULL))
+			continue;
+
+		__rte_mbuf_sanity_check(m, 1);
+
+		do {
+			m_next = m->next;
+			rte_pktmbuf_free_seg_via_array(m, free, &nb_free);
+			m = m_next;
+		} while (m != NULL);
+	}
+
+	if (nb_free > 0)
+		rte_mempool_put_bulk(free[0]->pool, (void **)free, nb_free);
+}
+
 /* dump a mbuf on console */
 void
 rte_pktmbuf_dump(FILE *f, const struct rte_mbuf *m, unsigned dump_len)
lib/librte_mbuf/rte_mbuf.h +12 -0
index 98225ec80..871145796 100644
@@ -1907,6 +1907,18 @@ static inline void rte_pktmbuf_free(struct rte_mbuf *m)
 	}
 }
 
+/**
+ * Free a bulk of mbufs back into their original mempools.
+ *
+ *  @param mbufs
+ *    Array of pointers to mbufs.
+ *    The array may contain NULL pointers.
+ *  @param count
+ *    Array size.
+ */
+__rte_experimental
+void rte_pktmbuf_free_bulk(struct rte_mbuf **mbufs, unsigned int count);
+
 /**
  * Creates a "clone" of the given packet mbuf.
  *
lib/librte_mbuf/rte_mbuf_version.map +1 -0
index 2662a37bf..cd6154ef2 100644
@@ -50,4 +50,5 @@ EXPERIMENTAL {
 	global:
 
 	rte_mbuf_check;
+	rte_pktmbuf_free_bulk;
 } DPDK_18.08;
Signature · 1 line
2.17.1
#2 lore raw
Quoted 32 lines · Morten Brørup

Add function for freeing a bulk of mbufs.

v4:
* Marked as experimental by adding __rte_experimental.
* Add function to experimental section of map file.
* Fix source code formatting regarding pointer to pointer.
* Squashed multiple modifications into one.
v3:
* Bugfix: Handle pakets with multiple segments.
* Added inline helper function, mainly for readability.
* Fix source code formatting regarding indentation.
v2:
* Function is not inline.
* Optimized to free multible mbufs belonging to the same mempool in bulk. Inspired by ixgbe_tx_free_bufs(), but allowing NULL pointers in the array, just like rte_pktmbuf_free() can take a NULL pointer.
* Use unsigned int instead of unsigned. Passes checkpatch, but mismatches the original coding style of the modified files.
* Fixed a typo in the description headline: mempools is plural.

---
  lib/librte_mbuf/rte_mbuf.c           | 50 ++++++++++++++++++++++++++++
  lib/librte_mbuf/rte_mbuf.h           | 12 +++++++
  lib/librte_mbuf/rte_mbuf_version.map |  1 +
  3 files changed, 63 insertions(+)
lib/librte_mbuf/rte_mbuf.c +0 -0
index 37718d49c..0088117a3 100644

lib/librte_mbuf/rte_mbuf.c int rte_mbuf_check(const struct rte_mbuf *m, int is_header, · line 251

Quoted 7 lines
lib/librte_mbuf/rte_mbuf.c +4 -0
@@ -245,6 +245,56 @@ int rte_mbuf_check(const struct rte_mbuf *m, int is_header,
  	return 0;
  }
 
+/**
+ * Size of the array holding mbufs from the same membool to be freed in bulk.
+ */
+#define RTE_PKTMBUF_FREE_BULK_SZ 64

How is the constant chosen? When we benchmarked similar thing in net/sfc, we finally stick to 32 as the best option.

lib/librte_mbuf/rte_mbuf.c int rte_mbuf_check(const struct rte_mbuf *m, int is_header, · line 258

Quoted 7 lines
lib/librte_mbuf/rte_mbuf.c +7 -0
+
+/**
+ * @internal helper function for freeing a bulk of mbufs via an array holding
+ * mbufs from the same mempool.
+ */
+static __rte_always_inline void
+rte_pktmbuf_free_seg_via_array(struct rte_mbuf *m,

Other internal functions in the file have __ (two underscore) prefix.

lib/librte_mbuf/rte_mbuf.c int rte_mbuf_check(const struct rte_mbuf *m, int is_header, · line 259

Quoted 1 line
lib/librte_mbuf/rte_mbuf.c +1 -0
+	struct rte_mbuf ** const free, unsigned int * const nb_free)

free is bad variable name because of libc free() function. It is a bit confusing. Same below.

lib/librte_mbuf/rte_mbuf.c int rte_mbuf_check(const struct rte_mbuf *m, int is_header, · line 262

Quoted 3 lines
lib/librte_mbuf/rte_mbuf.c +3 -0
+{
+	m = rte_pktmbuf_prefree_seg(m);
+	if (likely(m != NULL)) {

I'm not sure about likely() here, but hope that compiler is wise enough to inline rte_pktmbuf_prefree_seg() here and avoid the branch completely.

Quoted 71 lines
lib/librte_mbuf/rte_mbuf.c +35 -0
+		if (*nb_free >= RTE_PKTMBUF_FREE_BULK_SZ ||
+		    (*nb_free > 0 && m->pool != free[0]->pool)) {
+			rte_mempool_put_bulk(free[0]->pool, (void **)free,
+					     *nb_free);
+			*nb_free = 0;
+		}
+
+		free[(*nb_free)++] = m;
+	}
+}
+
+/* Free a bulk of mbufs back into their original mempools. */
+void rte_pktmbuf_free_bulk(struct rte_mbuf **mbufs, unsigned int count)
+{
+	struct rte_mbuf *m, *m_next, *free[RTE_PKTMBUF_FREE_BULK_SZ];
+	unsigned int idx, nb_free = 0;
+
+	for (idx = 0; idx < count; idx++) {
+		m = mbufs[idx];
+		if (unlikely(m == NULL))
+			continue;
+
+		__rte_mbuf_sanity_check(m, 1);
+
+		do {
+			m_next = m->next;
+			rte_pktmbuf_free_seg_via_array(m, free, &nb_free);
+			m = m_next;
+		} while (m != NULL);
+	}
+
+	if (nb_free > 0)
+		rte_mempool_put_bulk(free[0]->pool, (void **)free, nb_free);
+}
+
  /* dump a mbuf on console */
  void
  rte_pktmbuf_dump(FILE *f, const struct rte_mbuf *m, unsigned dump_len)
lib/librte_mbuf/rte_mbuf.h +12 -0
index 98225ec80..871145796 100644
@@ -1907,6 +1907,18 @@ static inline void rte_pktmbuf_free(struct rte_mbuf *m)
  	}
  }
 
+/**
+ * Free a bulk of mbufs back into their original mempools.
+ *
+ *  @param mbufs
+ *    Array of pointers to mbufs.
+ *    The array may contain NULL pointers.
+ *  @param count
+ *    Array size.
+ */
+__rte_experimental
+void rte_pktmbuf_free_bulk(struct rte_mbuf **mbufs, unsigned int count);
+
  /**
   * Creates a "clone" of the given packet mbuf.
   *
lib/librte_mbuf/rte_mbuf_version.map +1 -0
index 2662a37bf..cd6154ef2 100644
@@ -50,4 +50,5 @@ EXPERIMENTAL {
  	global:
 
  	rte_mbuf_check;
+	rte_pktmbuf_free_bulk;
  } DPDK_18.08;
#3 lore raw
Quoted 41 lines

-----Original Message-----
From: dev [mailto:[email protected]] On Behalf Of Andrew Rybchenko
Sent: Tuesday, October 8, 2019 7:26 PM

lib/librte_mbuf/rte_mbuf.c int rte_mbuf_check(const struct rte_mbuf *m, int

Quoted 32 lines · Morten Brørup

Add function for freeing a bulk of mbufs.

v4:
* Marked as experimental by adding __rte_experimental.
* Add function to experimental section of map file.
* Fix source code formatting regarding pointer to pointer.
* Squashed multiple modifications into one.
v3:
* Bugfix: Handle pakets with multiple segments.
* Added inline helper function, mainly for readability.
* Fix source code formatting regarding indentation.
v2:
* Function is not inline.
* Optimized to free multible mbufs belonging to the same mempool in bulk. Inspired by ixgbe_tx_free_bufs(), but allowing NULL pointers in the array, just like rte_pktmbuf_free() can take a NULL pointer.
* Use unsigned int instead of unsigned. Passes checkpatch, but mismatches the original coding style of the modified files.
* Fixed a typo in the description headline: mempools is plural.

---
  lib/librte_mbuf/rte_mbuf.c           | 50 ++++++++++++++++++++++++++++
  lib/librte_mbuf/rte_mbuf.h           | 12 +++++++
  lib/librte_mbuf/rte_mbuf_version.map |  1 +
  3 files changed, 63 insertions(+)
lib/librte_mbuf/rte_mbuf.c +0 -0
index 37718d49c..0088117a3 100644
@@ -245,6 +245,56 @@ int rte_mbuf_check(const struct rte_mbuf *m, int

is_header,

Quoted 3 lines
lib/librte_mbuf/rte_mbuf.c +0 -0
  	return 0;
  }
 
Quoted 9 lines

lib/librte_mbuf/rte_mbuf.c int rte_mbuf_check(const struct rte_mbuf *m, int · line 249

Quoted 2 lines
lib/librte_mbuf/rte_mbuf.c +2 -0
+/**
+ * Size of the array holding mbufs from the same membool to be freed in

bulk.

lib/librte_mbuf/rte_mbuf.c int rte_mbuf_check(const struct rte_mbuf *m, int is_header, · line 251

Quoted 2 lines
lib/librte_mbuf/rte_mbuf.c +2 -0
+ */
+#define RTE_PKTMBUF_FREE_BULK_SZ 64

How is the constant chosen? When we benchmarked similar thing in net/sfc, we finally stick to 32 as the best option.

I took it from the ixgbe driver that was the inspiration:
http://code.dpdk.org/dpdk/latest/source/drivers/net/ixgbe/ixgbe_rxtx.c#L111
http://code.dpdk.org/dpdk/latest/source/drivers/net/ixgbe/ixgbe_rxtx.h#L32

If only DPDK provided a common #define for recommended burst array sizes. However, I vaguely recall a discussion recommending it to be dependent on the application and various drivers due to requirements of 100 Gbps drivers. I guess it probably also depends on the CPU being used. I have no qualified opinion about this constant, so I can change it to anything you recommend.

Quoted 11 lines

lib/librte_mbuf/rte_mbuf.c int rte_mbuf_check(const struct rte_mbuf *m, int is_header,

Quoted 3 lines
lib/librte_mbuf/rte_mbuf.c +3 -0
+
+/**
+ * @internal helper function for freeing a bulk of mbufs via an array

holding

lib/librte_mbuf/rte_mbuf.c int rte_mbuf_check(const struct rte_mbuf *m, int is_header, · line 258

Quoted 4 lines
lib/librte_mbuf/rte_mbuf.c +4 -0
+ * mbufs from the same mempool.
+ */
+static __rte_always_inline void
+rte_pktmbuf_free_seg_via_array(struct rte_mbuf *m,

Other internal functions in the file have __ (two underscore) prefix.

The other internal function is public, i.e. not private (static). However, this might also go public one day, so I'll update it in the next version.

Quoted 5 lines

lib/librte_mbuf/rte_mbuf.c int rte_mbuf_check(const struct rte_mbuf *m, int is_header, · line 259

Quoted 1 line
lib/librte_mbuf/rte_mbuf.c +1 -0
+	struct rte_mbuf ** const free, unsigned int * const nb_free)

free is bad variable name because of libc free() function. It is a bit confusing. Same below.

I agree. I simply took it from the ixgbe driver without thinking further about it. How about "pending" or "bulk", or do you have a better suggestion?

Quoted 8 lines

lib/librte_mbuf/rte_mbuf.c int rte_mbuf_check(const struct rte_mbuf *m, int is_header, · line 262

Quoted 3 lines
lib/librte_mbuf/rte_mbuf.c +3 -0
+{
+	m = rte_pktmbuf_prefree_seg(m);
+	if (likely(m != NULL)) {

I'm not sure about likely() here, but hope that compiler is wise enough to inline rte_pktmbuf_prefree_seg() here and avoid the branch completely.

I somewhat agree with you about this likely() being questionable, and also hope for the compiler to be wise enough anyway.

This line of code in my function stems from unfolding rte_pktmbuf_free_seg(), which has the same likely(), so I kept it.

Apparently, the DPDK mbuf library has a strong preference for single-reference mbufs, with lots of likely()/unlikely() assuming that the m.refcnt is never more than one. rte_pktmbuf_prefree_seg() has the same preference. So I think that we should follow the library's convention, respecting that this function is at the very core of the data plane.

The DPDK rationale behind these likely()/unlikely() hints must be that multicasting, flooding and mirroring packets are rare exceptions. We have previously discussed this internally in our organization, and we tend to agree under normal circumstances. It is just an unfortunate side effect that a common network debugging feature - mirroring - introduces an additional performance penalty of having likely()/unlikely() go in the wrong direction, which might again affect what is being debugged.

Quoted 74 lines

lib/librte_mbuf/rte_mbuf.h static inline void rte_pktmbuf_free(struct

Quoted 43 lines
lib/librte_mbuf/rte_mbuf.c +35 -0
+		if (*nb_free >= RTE_PKTMBUF_FREE_BULK_SZ ||
+		    (*nb_free > 0 && m->pool != free[0]->pool)) {
+			rte_mempool_put_bulk(free[0]->pool, (void **)free,
+					     *nb_free);
+			*nb_free = 0;
+		}
+
+		free[(*nb_free)++] = m;
+	}
+}
+
+/* Free a bulk of mbufs back into their original mempools. */
+void rte_pktmbuf_free_bulk(struct rte_mbuf **mbufs, unsigned int count)
+{
+	struct rte_mbuf *m, *m_next, *free[RTE_PKTMBUF_FREE_BULK_SZ];
+	unsigned int idx, nb_free = 0;
+
+	for (idx = 0; idx < count; idx++) {
+		m = mbufs[idx];
+		if (unlikely(m == NULL))
+			continue;
+
+		__rte_mbuf_sanity_check(m, 1);
+
+		do {
+			m_next = m->next;
+			rte_pktmbuf_free_seg_via_array(m, free, &nb_free);
+			m = m_next;
+		} while (m != NULL);
+	}
+
+	if (nb_free > 0)
+		rte_mempool_put_bulk(free[0]->pool, (void **)free, nb_free);
+}
+
  /* dump a mbuf on console */
  void
  rte_pktmbuf_dump(FILE *f, const struct rte_mbuf *m, unsigned dump_len)
lib/librte_mbuf/rte_mbuf.h +0 -0
index 98225ec80..871145796 100644
@@ -1907,6 +1907,18 @@ static inline void rte_pktmbuf_free(struct

rte_mbuf *m)

Review

Quoted 19 lines
lib/librte_mbuf/rte_mbuf.h +12 -0
  	}
  }
 
+/**
+ * Free a bulk of mbufs back into their original mempools.
+ *
+ *  @param mbufs
+ *    Array of pointers to mbufs.
+ *    The array may contain NULL pointers.
+ *  @param count
+ *    Array size.
+ */
+__rte_experimental
+void rte_pktmbuf_free_bulk(struct rte_mbuf **mbufs, unsigned int count);
+
  /**
   * Creates a "clone" of the given packet mbuf.
   *
(quoted diff) +0 -0

b/lib/librte_mbuf/rte_mbuf_version.map

Quoted 9 lines

index 2662a37bf..cd6154ef2 100644

lib/librte_mbuf/rte_mbuf_version.map +1 -0
@@ -50,4 +50,5 @@ EXPERIMENTAL {
  	global:
 
  	rte_mbuf_check;
+	rte_pktmbuf_free_bulk;
  } DPDK_18.08;
#4 lore raw
Quoted 46 lines · Morten Brørup
Quoted 46 lines

-----Original Message-----
From: dev [mailto:[email protected]] On Behalf Of Andrew Rybchenko
Sent: Tuesday, October 8, 2019 7:26 PM

lib/librte_mbuf/rte_mbuf.c int rte_mbuf_check(const struct rte_mbuf *m, int

Quoted 32 lines · Morten Brørup

Add function for freeing a bulk of mbufs.

v4:
* Marked as experimental by adding __rte_experimental.
* Add function to experimental section of map file.
* Fix source code formatting regarding pointer to pointer.
* Squashed multiple modifications into one.
v3:
* Bugfix: Handle pakets with multiple segments.
* Added inline helper function, mainly for readability.
* Fix source code formatting regarding indentation.
v2:
* Function is not inline.
* Optimized to free multible mbufs belonging to the same mempool in bulk. Inspired by ixgbe_tx_free_bufs(), but allowing NULL pointers in the array, just like rte_pktmbuf_free() can take a NULL pointer.
* Use unsigned int instead of unsigned. Passes checkpatch, but mismatches the original coding style of the modified files.
* Fixed a typo in the description headline: mempools is plural.

---
   lib/librte_mbuf/rte_mbuf.c           | 50 ++++++++++++++++++++++++++++
   lib/librte_mbuf/rte_mbuf.h           | 12 +++++++
   lib/librte_mbuf/rte_mbuf_version.map |  1 +
   3 files changed, 63 insertions(+)
lib/librte_mbuf/rte_mbuf.c +0 -0
index 37718d49c..0088117a3 100644
@@ -245,6 +245,56 @@ int rte_mbuf_check(const struct rte_mbuf *m, int

is_header,

lib/librte_mbuf/rte_mbuf.c int rte_mbuf_check(const struct rte_mbuf *m, int is_header,

Quoted 5 lines
lib/librte_mbuf/rte_mbuf.c +2 -0
   	return 0;
   }
 
+/**
+ * Size of the array holding mbufs from the same membool to be freed in

bulk.

Quoted 2 lines
lib/librte_mbuf/rte_mbuf.c +2 -0
+ */
+#define RTE_PKTMBUF_FREE_BULK_SZ 64
Quoted 8 lines
Quoted 3 lines

How is the constant chosen? When we benchmarked similar thing in net/sfc, we finally stick to 32 as the best option.

I took it from the ixgbe driver that was the inspiration:
http://code.dpdk.org/dpdk/latest/source/drivers/net/ixgbe/ixgbe_rxtx.c#L111
http://code.dpdk.org/dpdk/latest/source/drivers/net/ixgbe/ixgbe_rxtx.h#L32

If only DPDK provided a common #define for recommended burst array sizes. However, I vaguely recall a discussion recommending it to be dependent on the application and various drivers due to requirements of 100 Gbps drivers. I guess it probably also depends on the CPU being used. I have no qualified opinion about this constant, so I can change it to anything you recommend.

No, no, it is OK for me as is. Just curiosity.

Quoted 10 lines
Quoted 10 lines

lib/librte_mbuf/rte_mbuf.c int rte_mbuf_check(const struct rte_mbuf *m, int is_header,

Quoted 3 lines
lib/librte_mbuf/rte_mbuf.c +3 -0
+
+/**
+ * @internal helper function for freeing a bulk of mbufs via an array

holding

lib/librte_mbuf/rte_mbuf.c int rte_mbuf_check(const struct rte_mbuf *m, int is_header, · line 258

Quoted 4 lines
lib/librte_mbuf/rte_mbuf.c +4 -0
+ * mbufs from the same mempool.
+ */
+static __rte_always_inline void
+rte_pktmbuf_free_seg_via_array(struct rte_mbuf *m,

Other internal functions in the file have __ (two underscore) prefix.

Quoted 7 lines

The other internal function is public, i.e. not private (static). However, this might also go public one day, so I'll update it in the next version.

Quoted 4 lines

lib/librte_mbuf/rte_mbuf.c int rte_mbuf_check(const struct rte_mbuf *m, int is_header, · line 259

Quoted 1 line
lib/librte_mbuf/rte_mbuf.c +1 -0
+	struct rte_mbuf ** const free, unsigned int * const nb_free)

free is bad variable name because of libc free() function. It is a bit confusing. Same below.

I agree. I simply took it from the ixgbe driver without thinking further about it. How about "pending" or "bulk", or do you have a better suggestion?

Both "pending" and "bulk" are OK for me. Up to you.

Quoted 7 lines
Quoted 7 lines

lib/librte_mbuf/rte_mbuf.c int rte_mbuf_check(const struct rte_mbuf *m, int is_header, · line 262

Quoted 3 lines
lib/librte_mbuf/rte_mbuf.c +3 -0
+{
+	m = rte_pktmbuf_prefree_seg(m);
+	if (likely(m != NULL)) {

I'm not sure about likely() here, but hope that compiler is wise enough to inline rte_pktmbuf_prefree_seg() here and avoid the branch completely.

Quoted 5 lines

I somewhat agree with you about this likely() being questionable, and also hope for the compiler to be wise enough anyway.

This line of code in my function stems from unfolding rte_pktmbuf_free_seg(), which has the same likely(), so I kept it.

Apparently, the DPDK mbuf library has a strong preference for single-reference mbufs, with lots of likely()/unlikely() assuming that the m.refcnt is never more than one. rte_pktmbuf_prefree_seg() has the same preference. So I think that we should follow the library's convention, respecting that this function is at the very core of the data plane.

Makes sense.

Quoted 1 line

The DPDK rationale behind these likely()/unlikely() hints must be that multicasting, flooding and mirroring packets are rare exceptions. We have previously discussed this internally in our organization, and we tend to agree under normal circumstances. It is just an unfortunate side effect that a common network debugging feature - mirroring - introduces an additional performance penalty of having likely()/unlikely() go in the wrong direction, which might again affect what is being debugged.

Thanks,
Andrew.

#5 lore raw
In reply to Morten Brørup
Quoted 13 lines

Add function for freeing a bulk of mbufs.

v4:
* Marked as experimental by adding __rte_experimental.
* Add function to experimental section of map file.
* Fix source code formatting regarding pointer to pointer.
* Squashed multiple modifications into one.
v3:
* Bugfix: Handle pakets with multiple segments.
* Added inline helper function, mainly for readability.
* Fix source code formatting regarding indentation.

Quoted 8 lines

v2:
* Function is not inline.
* Optimized to free multible mbufs belonging to the same mempool in bulk. Inspired by ixgbe_tx_free_bufs(), but allowing NULL pointers in the array, just like rte_pktmbuf_free() can take a NULL pointer.
* Use unsigned int instead of unsigned. Passes checkpatch, but mismatches the original coding style of the modified files.
* Fixed a typo in the description headline: mempools is plural.

LGTM, one suggestion see below.

Quoted 22 lines
---
 lib/librte_mbuf/rte_mbuf.c           | 50 ++++++++++++++++++++++++++++
 lib/librte_mbuf/rte_mbuf.h           | 12 +++++++
 lib/librte_mbuf/rte_mbuf_version.map |  1 +
 3 files changed, 63 insertions(+)
lib/librte_mbuf/rte_mbuf.c +6 -0
index 37718d49c..0088117a3 100644
@@ -245,6 +245,56 @@ int rte_mbuf_check(const struct rte_mbuf *m, int is_header,
 	return 0;
 }
 
+/**
+ * Size of the array holding mbufs from the same membool to be freed in bulk.
+ */
+#define RTE_PKTMBUF_FREE_BULK_SZ 64
+
+/**

lib/librte_mbuf/rte_mbuf.c int rte_mbuf_check(const struct rte_mbuf *m, int is_header, · line 263

Quoted 10 lines
lib/librte_mbuf/rte_mbuf.c +10 -0
+ * @internal helper function for freeing a bulk of mbufs via an array holding
+ * mbufs from the same mempool.
+ */
+static __rte_always_inline void
+rte_pktmbuf_free_seg_via_array(struct rte_mbuf *m,
+	struct rte_mbuf ** const free, unsigned int * const nb_free)
+{
+	m = rte_pktmbuf_prefree_seg(m);
+	if (likely(m != NULL)) {
+		if (*nb_free >= RTE_PKTMBUF_FREE_BULK_SZ ||

Instead of assuming DIM(free) == RTE_PKTMBUF_FREE_BULK_SZ, probably better to pass it as extra parameter to that function:

rte_pktmbuf_free_seg_via_array(struct rte_mbuf *m,
struct rte_mbuf ** const free, unsigned int * const nb_free, uinsigned int max_free)

{
    ...
    if (*nb_free >= max_free || ...

As this routine is 'static inline' and rte_pktmbuf_free_bulk() uses fixed size array for free[], compiler would be able to figure out that it is a constant value here anyway.

Quoted 72 lines
lib/librte_mbuf/rte_mbuf.c +34 -0
+		    (*nb_free > 0 && m->pool != free[0]->pool)) {
+			rte_mempool_put_bulk(free[0]->pool, (void **)free,
+					     *nb_free);
+			*nb_free = 0;
+		}
+
+		free[(*nb_free)++] = m;
+	}
+}
+
+/* Free a bulk of mbufs back into their original mempools. */
+void rte_pktmbuf_free_bulk(struct rte_mbuf **mbufs, unsigned int count)
+{
+	struct rte_mbuf *m, *m_next, *free[RTE_PKTMBUF_FREE_BULK_SZ];
+	unsigned int idx, nb_free = 0;
+
+	for (idx = 0; idx < count; idx++) {
+		m = mbufs[idx];
+		if (unlikely(m == NULL))
+			continue;
+
+		__rte_mbuf_sanity_check(m, 1);
+
+		do {
+			m_next = m->next;
+			rte_pktmbuf_free_seg_via_array(m, free, &nb_free);
+			m = m_next;
+		} while (m != NULL);
+	}
+
+	if (nb_free > 0)
+		rte_mempool_put_bulk(free[0]->pool, (void **)free, nb_free);
+}
+
 /* dump a mbuf on console */
 void
 rte_pktmbuf_dump(FILE *f, const struct rte_mbuf *m, unsigned dump_len)
lib/librte_mbuf/rte_mbuf.h +12 -0
index 98225ec80..871145796 100644
@@ -1907,6 +1907,18 @@ static inline void rte_pktmbuf_free(struct rte_mbuf *m)
 	}
 }
 
+/**
+ * Free a bulk of mbufs back into their original mempools.
+ *
+ *  @param mbufs
+ *    Array of pointers to mbufs.
+ *    The array may contain NULL pointers.
+ *  @param count
+ *    Array size.
+ */
+__rte_experimental
+void rte_pktmbuf_free_bulk(struct rte_mbuf **mbufs, unsigned int count);
+
 /**
  * Creates a "clone" of the given packet mbuf.
  *
lib/librte_mbuf/rte_mbuf_version.map +1 -1
index 2662a37bf..cd6154ef2 100644
@@ -50,4 +50,5 @@ EXPERIMENTAL {
 	global:
 
 	rte_mbuf_check;
+	rte_pktmbuf_free_bulk;
 } DPDK_18.08;
--

2.17.1