* [PATCH net-next 1/4] net: xdp: introduce bulking for xdp tx return path
2020-10-27 19:04 [PATCH net-next 0/4] xdp: introduce bulking for page_pool tx return path Lorenzo Bianconi
@ 2020-10-27 19:04 ` Lorenzo Bianconi
2020-10-28 9:27 ` Ilias Apalodimas
` (2 more replies)
2020-10-27 19:04 ` [PATCH net-next 2/4] net: page_pool: add bulk support for ptr_ring Lorenzo Bianconi
` (2 subsequent siblings)
3 siblings, 3 replies; 23+ messages in thread
From: Lorenzo Bianconi @ 2020-10-27 19:04 UTC (permalink / raw)
To: netdev; +Cc: bpf, lorenzo.bianconi, davem, kuba, brouer, ilias.apalodimas
Introduce bulking capability in xdp tx return path (XDP_REDIRECT).
xdp_return_frame is usually run inside the driver NAPI tx completion
loop so it is possible batch it.
Current implementation considers only page_pool memory model.
Convert mvneta driver to xdp_return_frame_bulk APIs.
Suggested-by: Jesper Dangaard Brouer <brouer@redhat.com>
Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
---
drivers/net/ethernet/marvell/mvneta.c | 5 ++-
include/net/xdp.h | 9 +++++
net/core/xdp.c | 51 +++++++++++++++++++++++++++
3 files changed, 64 insertions(+), 1 deletion(-)
diff --git a/drivers/net/ethernet/marvell/mvneta.c b/drivers/net/ethernet/marvell/mvneta.c
index 54b0bf574c05..43ab8a73900e 100644
--- a/drivers/net/ethernet/marvell/mvneta.c
+++ b/drivers/net/ethernet/marvell/mvneta.c
@@ -1834,8 +1834,10 @@ static void mvneta_txq_bufs_free(struct mvneta_port *pp,
struct netdev_queue *nq, bool napi)
{
unsigned int bytes_compl = 0, pkts_compl = 0;
+ struct xdp_frame_bulk bq;
int i;
+ bq.xa = NULL;
for (i = 0; i < num; i++) {
struct mvneta_tx_buf *buf = &txq->buf[txq->txq_get_index];
struct mvneta_tx_desc *tx_desc = txq->descs +
@@ -1857,9 +1859,10 @@ static void mvneta_txq_bufs_free(struct mvneta_port *pp,
if (napi && buf->type == MVNETA_TYPE_XDP_TX)
xdp_return_frame_rx_napi(buf->xdpf);
else
- xdp_return_frame(buf->xdpf);
+ xdp_return_frame_bulk(buf->xdpf, &bq);
}
}
+ xdp_flush_frame_bulk(&bq);
netdev_tx_completed_queue(nq, pkts_compl, bytes_compl);
}
diff --git a/include/net/xdp.h b/include/net/xdp.h
index 3814fb631d52..9567110845ef 100644
--- a/include/net/xdp.h
+++ b/include/net/xdp.h
@@ -104,6 +104,12 @@ struct xdp_frame {
struct net_device *dev_rx; /* used by cpumap */
};
+#define XDP_BULK_QUEUE_SIZE 16
+struct xdp_frame_bulk {
+ void *q[XDP_BULK_QUEUE_SIZE];
+ int count;
+ void *xa;
+};
static inline struct skb_shared_info *
xdp_get_shared_info_from_frame(struct xdp_frame *frame)
@@ -194,6 +200,9 @@ struct xdp_frame *xdp_convert_buff_to_frame(struct xdp_buff *xdp)
void xdp_return_frame(struct xdp_frame *xdpf);
void xdp_return_frame_rx_napi(struct xdp_frame *xdpf);
void xdp_return_buff(struct xdp_buff *xdp);
+void xdp_flush_frame_bulk(struct xdp_frame_bulk *bq);
+void xdp_return_frame_bulk(struct xdp_frame *xdpf,
+ struct xdp_frame_bulk *bq);
/* When sending xdp_frame into the network stack, then there is no
* return point callback, which is needed to release e.g. DMA-mapping
diff --git a/net/core/xdp.c b/net/core/xdp.c
index 48aba933a5a8..93eabd789246 100644
--- a/net/core/xdp.c
+++ b/net/core/xdp.c
@@ -380,6 +380,57 @@ void xdp_return_frame_rx_napi(struct xdp_frame *xdpf)
}
EXPORT_SYMBOL_GPL(xdp_return_frame_rx_napi);
+void xdp_flush_frame_bulk(struct xdp_frame_bulk *bq)
+{
+ struct xdp_mem_allocator *xa = bq->xa;
+ int i;
+
+ if (unlikely(!xa))
+ return;
+
+ for (i = 0; i < bq->count; i++) {
+ struct page *page = virt_to_head_page(bq->q[i]);
+
+ page_pool_put_full_page(xa->page_pool, page, false);
+ }
+ bq->count = 0;
+}
+EXPORT_SYMBOL_GPL(xdp_flush_frame_bulk);
+
+void xdp_return_frame_bulk(struct xdp_frame *xdpf,
+ struct xdp_frame_bulk *bq)
+{
+ struct xdp_mem_info *mem = &xdpf->mem;
+ struct xdp_mem_allocator *xa, *nxa;
+
+ if (mem->type != MEM_TYPE_PAGE_POOL) {
+ __xdp_return(xdpf->data, &xdpf->mem, false);
+ return;
+ }
+
+ rcu_read_lock();
+
+ xa = bq->xa;
+ if (unlikely(!xa || mem->id != xa->mem.id)) {
+ nxa = rhashtable_lookup(mem_id_ht, &mem->id, mem_id_rht_params);
+ if (unlikely(!xa)) {
+ bq->count = 0;
+ bq->xa = nxa;
+ xa = nxa;
+ }
+ }
+
+ if (mem->id != xa->mem.id || bq->count == XDP_BULK_QUEUE_SIZE)
+ xdp_flush_frame_bulk(bq);
+
+ bq->q[bq->count++] = xdpf->data;
+ if (mem->id != xa->mem.id)
+ bq->xa = nxa;
+
+ rcu_read_unlock();
+}
+EXPORT_SYMBOL_GPL(xdp_return_frame_bulk);
+
void xdp_return_buff(struct xdp_buff *xdp)
{
__xdp_return(xdp->data, &xdp->rxq->mem, true);
--
2.26.2
^ permalink raw reply related [flat|nested] 23+ messages in thread* Re: [PATCH net-next 1/4] net: xdp: introduce bulking for xdp tx return path
2020-10-27 19:04 ` [PATCH net-next 1/4] net: xdp: introduce bulking for xdp " Lorenzo Bianconi
@ 2020-10-28 9:27 ` Ilias Apalodimas
2020-10-28 10:23 ` Lorenzo Bianconi
2020-10-28 11:34 ` Jesper Dangaard Brouer
2020-10-29 13:52 ` Jesper Dangaard Brouer
2 siblings, 1 reply; 23+ messages in thread
From: Ilias Apalodimas @ 2020-10-28 9:27 UTC (permalink / raw)
To: Lorenzo Bianconi; +Cc: netdev, bpf, lorenzo.bianconi, davem, kuba, brouer
Hi Lorenzo,
On Tue, Oct 27, 2020 at 08:04:07PM +0100, Lorenzo Bianconi wrote:
> Introduce bulking capability in xdp tx return path (XDP_REDIRECT).
> xdp_return_frame is usually run inside the driver NAPI tx completion
> loop so it is possible batch it.
> Current implementation considers only page_pool memory model.
> Convert mvneta driver to xdp_return_frame_bulk APIs.
>
> Suggested-by: Jesper Dangaard Brouer <brouer@redhat.com>
> Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
> ---
> drivers/net/ethernet/marvell/mvneta.c | 5 ++-
> include/net/xdp.h | 9 +++++
> net/core/xdp.c | 51 +++++++++++++++++++++++++++
> 3 files changed, 64 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/net/ethernet/marvell/mvneta.c b/drivers/net/ethernet/marvell/mvneta.c
> index 54b0bf574c05..43ab8a73900e 100644
> --- a/drivers/net/ethernet/marvell/mvneta.c
> +++ b/drivers/net/ethernet/marvell/mvneta.c
> @@ -1834,8 +1834,10 @@ static void mvneta_txq_bufs_free(struct mvneta_port *pp,
> struct netdev_queue *nq, bool napi)
> {
> unsigned int bytes_compl = 0, pkts_compl = 0;
> + struct xdp_frame_bulk bq;
> int i;
>
> + bq.xa = NULL;
> for (i = 0; i < num; i++) {
> struct mvneta_tx_buf *buf = &txq->buf[txq->txq_get_index];
> struct mvneta_tx_desc *tx_desc = txq->descs +
> @@ -1857,9 +1859,10 @@ static void mvneta_txq_bufs_free(struct mvneta_port *pp,
> if (napi && buf->type == MVNETA_TYPE_XDP_TX)
> xdp_return_frame_rx_napi(buf->xdpf);
> else
> - xdp_return_frame(buf->xdpf);
> + xdp_return_frame_bulk(buf->xdpf, &bq);
> }
> }
> + xdp_flush_frame_bulk(&bq);
>
> netdev_tx_completed_queue(nq, pkts_compl, bytes_compl);
> }
> diff --git a/include/net/xdp.h b/include/net/xdp.h
> index 3814fb631d52..9567110845ef 100644
> --- a/include/net/xdp.h
> +++ b/include/net/xdp.h
> @@ -104,6 +104,12 @@ struct xdp_frame {
> struct net_device *dev_rx; /* used by cpumap */
> };
>
> +#define XDP_BULK_QUEUE_SIZE 16
> +struct xdp_frame_bulk {
> + void *q[XDP_BULK_QUEUE_SIZE];
> + int count;
> + void *xa;
> +};
>
> static inline struct skb_shared_info *
> xdp_get_shared_info_from_frame(struct xdp_frame *frame)
> @@ -194,6 +200,9 @@ struct xdp_frame *xdp_convert_buff_to_frame(struct xdp_buff *xdp)
> void xdp_return_frame(struct xdp_frame *xdpf);
> void xdp_return_frame_rx_napi(struct xdp_frame *xdpf);
> void xdp_return_buff(struct xdp_buff *xdp);
> +void xdp_flush_frame_bulk(struct xdp_frame_bulk *bq);
> +void xdp_return_frame_bulk(struct xdp_frame *xdpf,
> + struct xdp_frame_bulk *bq);
>
> /* When sending xdp_frame into the network stack, then there is no
> * return point callback, which is needed to release e.g. DMA-mapping
> diff --git a/net/core/xdp.c b/net/core/xdp.c
> index 48aba933a5a8..93eabd789246 100644
> --- a/net/core/xdp.c
> +++ b/net/core/xdp.c
> @@ -380,6 +380,57 @@ void xdp_return_frame_rx_napi(struct xdp_frame *xdpf)
> }
> EXPORT_SYMBOL_GPL(xdp_return_frame_rx_napi);
>
> +void xdp_flush_frame_bulk(struct xdp_frame_bulk *bq)
> +{
> + struct xdp_mem_allocator *xa = bq->xa;
> + int i;
> +
> + if (unlikely(!xa))
> + return;
> +
> + for (i = 0; i < bq->count; i++) {
> + struct page *page = virt_to_head_page(bq->q[i]);
> +
> + page_pool_put_full_page(xa->page_pool, page, false);
> + }
> + bq->count = 0;
> +}
> +EXPORT_SYMBOL_GPL(xdp_flush_frame_bulk);
> +
> +void xdp_return_frame_bulk(struct xdp_frame *xdpf,
> + struct xdp_frame_bulk *bq)
> +{
> + struct xdp_mem_info *mem = &xdpf->mem;
> + struct xdp_mem_allocator *xa, *nxa;
> +
> + if (mem->type != MEM_TYPE_PAGE_POOL) {
> + __xdp_return(xdpf->data, &xdpf->mem, false);
> + return;
> + }
> +
> + rcu_read_lock();
> +
> + xa = bq->xa;
> + if (unlikely(!xa || mem->id != xa->mem.id)) {
Why is this marked as unlikely? The driver passes it as NULL. Should unlikely be
checked on both xa and the comparison?
> + nxa = rhashtable_lookup(mem_id_ht, &mem->id, mem_id_rht_params);
Is there a chance nxa can be NULL?
> + if (unlikely(!xa)) {
Same here, driver passes it as NULL
> + bq->count = 0;
> + bq->xa = nxa;
> + xa = nxa;
> + }
> + }
> +
> + if (mem->id != xa->mem.id || bq->count == XDP_BULK_QUEUE_SIZE)
> + xdp_flush_frame_bulk(bq);
> +
> + bq->q[bq->count++] = xdpf->data;
> + if (mem->id != xa->mem.id)
> + bq->xa = nxa;
> +
> + rcu_read_unlock();
> +}
> +EXPORT_SYMBOL_GPL(xdp_return_frame_bulk);
> +
> void xdp_return_buff(struct xdp_buff *xdp)
> {
> __xdp_return(xdp->data, &xdp->rxq->mem, true);
> --
> 2.26.2
>
Cheers
/Ilias
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH net-next 1/4] net: xdp: introduce bulking for xdp tx return path
2020-10-28 9:27 ` Ilias Apalodimas
@ 2020-10-28 10:23 ` Lorenzo Bianconi
2020-10-28 10:59 ` Ilias Apalodimas
0 siblings, 1 reply; 23+ messages in thread
From: Lorenzo Bianconi @ 2020-10-28 10:23 UTC (permalink / raw)
To: Ilias Apalodimas; +Cc: netdev, bpf, lorenzo.bianconi, davem, kuba, brouer
[-- Attachment #1: Type: text/plain, Size: 1716 bytes --]
> Hi Lorenzo,
Hi Ilias,
thx for the review.
>
> On Tue, Oct 27, 2020 at 08:04:07PM +0100, Lorenzo Bianconi wrote:
[...]
> > +void xdp_return_frame_bulk(struct xdp_frame *xdpf,
> > + struct xdp_frame_bulk *bq)
> > +{
> > + struct xdp_mem_info *mem = &xdpf->mem;
> > + struct xdp_mem_allocator *xa, *nxa;
> > +
> > + if (mem->type != MEM_TYPE_PAGE_POOL) {
> > + __xdp_return(xdpf->data, &xdpf->mem, false);
> > + return;
> > + }
> > +
> > + rcu_read_lock();
> > +
> > + xa = bq->xa;
> > + if (unlikely(!xa || mem->id != xa->mem.id)) {
>
> Why is this marked as unlikely? The driver passes it as NULL. Should unlikely be
> checked on both xa and the comparison?
xa is NULL only for the first xdp_frame in the burst while it is set for
subsequent ones. Do you think it is better to remove it?
>
> > + nxa = rhashtable_lookup(mem_id_ht, &mem->id, mem_id_rht_params);
>
> Is there a chance nxa can be NULL?
I do not think so since the page_pool is not destroyed while there are
in-flight pages, right?
Regards,
Lorenzo
>
> > + if (unlikely(!xa)) {
>
> Same here, driver passes it as NULL
>
> > + bq->count = 0;
> > + bq->xa = nxa;
> > + xa = nxa;
> > + }
> > + }
> > +
> > + if (mem->id != xa->mem.id || bq->count == XDP_BULK_QUEUE_SIZE)
> > + xdp_flush_frame_bulk(bq);
> > +
> > + bq->q[bq->count++] = xdpf->data;
> > + if (mem->id != xa->mem.id)
> > + bq->xa = nxa;
> > +
> > + rcu_read_unlock();
> > +}
> > +EXPORT_SYMBOL_GPL(xdp_return_frame_bulk);
> > +
> > void xdp_return_buff(struct xdp_buff *xdp)
> > {
> > __xdp_return(xdp->data, &xdp->rxq->mem, true);
> > --
> > 2.26.2
> >
>
> Cheers
> /Ilias
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH net-next 1/4] net: xdp: introduce bulking for xdp tx return path
2020-10-28 10:23 ` Lorenzo Bianconi
@ 2020-10-28 10:59 ` Ilias Apalodimas
2020-10-28 11:28 ` Lorenzo Bianconi
0 siblings, 1 reply; 23+ messages in thread
From: Ilias Apalodimas @ 2020-10-28 10:59 UTC (permalink / raw)
To: Lorenzo Bianconi; +Cc: netdev, bpf, lorenzo.bianconi, davem, kuba, brouer
On Wed, Oct 28, 2020 at 11:23:04AM +0100, Lorenzo Bianconi wrote:
> > Hi Lorenzo,
>
> Hi Ilias,
>
> thx for the review.
>
> >
> > On Tue, Oct 27, 2020 at 08:04:07PM +0100, Lorenzo Bianconi wrote:
>
> [...]
>
> > > +void xdp_return_frame_bulk(struct xdp_frame *xdpf,
> > > + struct xdp_frame_bulk *bq)
> > > +{
> > > + struct xdp_mem_info *mem = &xdpf->mem;
> > > + struct xdp_mem_allocator *xa, *nxa;
> > > +
> > > + if (mem->type != MEM_TYPE_PAGE_POOL) {
> > > + __xdp_return(xdpf->data, &xdpf->mem, false);
> > > + return;
> > > + }
> > > +
> > > + rcu_read_lock();
> > > +
> > > + xa = bq->xa;
> > > + if (unlikely(!xa || mem->id != xa->mem.id)) {
> >
> > Why is this marked as unlikely? The driver passes it as NULL. Should unlikely be
> > checked on both xa and the comparison?
>
> xa is NULL only for the first xdp_frame in the burst while it is set for
> subsequent ones. Do you think it is better to remove it?
Ah correct, missed the general context of the driver this runs in.
>
> >
> > > + nxa = rhashtable_lookup(mem_id_ht, &mem->id, mem_id_rht_params);
> >
> > Is there a chance nxa can be NULL?
>
> I do not think so since the page_pool is not destroyed while there are
> in-flight pages, right?
I think so but I am not 100% sure. I'll apply the patch and have a closer look
Cheers
/Ilias
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH net-next 1/4] net: xdp: introduce bulking for xdp tx return path
2020-10-28 10:59 ` Ilias Apalodimas
@ 2020-10-28 11:28 ` Lorenzo Bianconi
0 siblings, 0 replies; 23+ messages in thread
From: Lorenzo Bianconi @ 2020-10-28 11:28 UTC (permalink / raw)
To: Ilias Apalodimas; +Cc: netdev, bpf, lorenzo.bianconi, davem, kuba, brouer
[-- Attachment #1: Type: text/plain, Size: 1749 bytes --]
> On Wed, Oct 28, 2020 at 11:23:04AM +0100, Lorenzo Bianconi wrote:
> > > Hi Lorenzo,
> >
> > Hi Ilias,
> >
> > thx for the review.
> >
> > >
> > > On Tue, Oct 27, 2020 at 08:04:07PM +0100, Lorenzo Bianconi wrote:
> >
> > [...]
> >
> > > > +void xdp_return_frame_bulk(struct xdp_frame *xdpf,
> > > > + struct xdp_frame_bulk *bq)
> > > > +{
> > > > + struct xdp_mem_info *mem = &xdpf->mem;
> > > > + struct xdp_mem_allocator *xa, *nxa;
> > > > +
> > > > + if (mem->type != MEM_TYPE_PAGE_POOL) {
> > > > + __xdp_return(xdpf->data, &xdpf->mem, false);
> > > > + return;
> > > > + }
> > > > +
> > > > + rcu_read_lock();
> > > > +
> > > > + xa = bq->xa;
> > > > + if (unlikely(!xa || mem->id != xa->mem.id)) {
> > >
> > > Why is this marked as unlikely? The driver passes it as NULL. Should unlikely be
> > > checked on both xa and the comparison?
> >
> > xa is NULL only for the first xdp_frame in the burst while it is set for
> > subsequent ones. Do you think it is better to remove it?
>
> Ah correct, missed the general context of the driver this runs in.
>
> >
> > >
> > > > + nxa = rhashtable_lookup(mem_id_ht, &mem->id, mem_id_rht_params);
> > >
> > > Is there a chance nxa can be NULL?
> >
> > I do not think so since the page_pool is not destroyed while there are
> > in-flight pages, right?
>
> I think so but I am not 100% sure. I'll apply the patch and have a closer look
ack, thx. I converted socionext driver to bulking APIs but I have not posted the
patch since I have not been able to test it. The code is available here:
https://github.com/LorenzoBianconi/net-next/commit/88c2995bca051fa38860acf7b915c90768460d37
Regards,
Lorenzo
>
> Cheers
> /Ilias
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH net-next 1/4] net: xdp: introduce bulking for xdp tx return path
2020-10-27 19:04 ` [PATCH net-next 1/4] net: xdp: introduce bulking for xdp " Lorenzo Bianconi
2020-10-28 9:27 ` Ilias Apalodimas
@ 2020-10-28 11:34 ` Jesper Dangaard Brouer
2020-10-28 11:43 ` Lorenzo Bianconi
2020-10-29 13:52 ` Jesper Dangaard Brouer
2 siblings, 1 reply; 23+ messages in thread
From: Jesper Dangaard Brouer @ 2020-10-28 11:34 UTC (permalink / raw)
To: Lorenzo Bianconi
Cc: netdev, bpf, lorenzo.bianconi, davem, kuba, ilias.apalodimas, brouer
On Tue, 27 Oct 2020 20:04:07 +0100
Lorenzo Bianconi <lorenzo@kernel.org> wrote:
> Introduce bulking capability in xdp tx return path (XDP_REDIRECT).
> xdp_return_frame is usually run inside the driver NAPI tx completion
> loop so it is possible batch it.
> Current implementation considers only page_pool memory model.
> Convert mvneta driver to xdp_return_frame_bulk APIs.
>
> Suggested-by: Jesper Dangaard Brouer <brouer@redhat.com>
I think you/we have to explain better in this commit message, what the
idea/concept behind this bulk return is. Or even explain this as a
comment above "xdp_return_frame_bulk".
Maybe add/append text to commit below:
The bulk API introduced is a defer and flush API, that will defer
the return if the xdp_mem_allocator object is the same, identified
via the mem.id field (xdp_mem_info). Thus, the flush operation will
operate on the same xdp_mem_allocator object.
The bulk queue size of 16 is no coincident. This is connected to how
XDP redirect will bulk xmit (upto 16) frames. Thus, the idea is for the
API to find these boundaries (via mem.id match), which is optimal for
both the I-cache and D-cache for the memory allocator code and object.
The data structure (xdp_frame_bulk) used for deferred elements is
stored/allocated on the function call-stack, which allows lockfree
access.
> Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
> ---
[...]
> diff --git a/include/net/xdp.h b/include/net/xdp.h
> index 3814fb631d52..9567110845ef 100644
> --- a/include/net/xdp.h
> +++ b/include/net/xdp.h
> @@ -104,6 +104,12 @@ struct xdp_frame {
> struct net_device *dev_rx; /* used by cpumap */
> };
>
> +#define XDP_BULK_QUEUE_SIZE 16
Maybe "#define DEV_MAP_BULK_SIZE 16" should be def to
XDP_BULK_QUEUE_SIZE, to express the described connection.
> +struct xdp_frame_bulk {
> + void *q[XDP_BULK_QUEUE_SIZE];
> + int count;
> + void *xa;
Just a hunch (not benchmarked), but I think it will be more optimal to
place 'count' and '*xa' above the '*q' array. (It might not matter at
all, as we cannot control the start alignment, when this is on the
stack.)
> +};
[...]
> diff --git a/net/core/xdp.c b/net/core/xdp.c
> index 48aba933a5a8..93eabd789246 100644
> --- a/net/core/xdp.c
> +++ b/net/core/xdp.c
> @@ -380,6 +380,57 @@ void xdp_return_frame_rx_napi(struct xdp_frame *xdpf)
> }
> EXPORT_SYMBOL_GPL(xdp_return_frame_rx_napi);
>
> +void xdp_flush_frame_bulk(struct xdp_frame_bulk *bq)
> +{
> + struct xdp_mem_allocator *xa = bq->xa;
> + int i;
> +
> + if (unlikely(!xa))
> + return;
> +
> + for (i = 0; i < bq->count; i++) {
> + struct page *page = virt_to_head_page(bq->q[i]);
> +
> + page_pool_put_full_page(xa->page_pool, page, false);
> + }
> + bq->count = 0;
> +}
> +EXPORT_SYMBOL_GPL(xdp_flush_frame_bulk);
> +
Wondering if we should have a comment that explains the intent and idea
behind this function?
/* Defers return when frame belongs to same mem.id as previous frame */
> +void xdp_return_frame_bulk(struct xdp_frame *xdpf,
> + struct xdp_frame_bulk *bq)
> +{
> + struct xdp_mem_info *mem = &xdpf->mem;
> + struct xdp_mem_allocator *xa, *nxa;
> +
> + if (mem->type != MEM_TYPE_PAGE_POOL) {
> + __xdp_return(xdpf->data, &xdpf->mem, false);
> + return;
> + }
> +
> + rcu_read_lock();
> +
> + xa = bq->xa;
> + if (unlikely(!xa || mem->id != xa->mem.id)) {
> + nxa = rhashtable_lookup(mem_id_ht, &mem->id, mem_id_rht_params);
> + if (unlikely(!xa)) {
> + bq->count = 0;
> + bq->xa = nxa;
> + xa = nxa;
> + }
> + }
> +
> + if (mem->id != xa->mem.id || bq->count == XDP_BULK_QUEUE_SIZE)
> + xdp_flush_frame_bulk(bq);
> +
> + bq->q[bq->count++] = xdpf->data;
> + if (mem->id != xa->mem.id)
> + bq->xa = nxa;
> +
> + rcu_read_unlock();
> +}
> +EXPORT_SYMBOL_GPL(xdp_return_frame_bulk);
--
Best regards,
Jesper Dangaard Brouer
MSc.CS, Principal Kernel Engineer at Red Hat
LinkedIn: http://www.linkedin.com/in/brouer
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH net-next 1/4] net: xdp: introduce bulking for xdp tx return path
2020-10-28 11:34 ` Jesper Dangaard Brouer
@ 2020-10-28 11:43 ` Lorenzo Bianconi
0 siblings, 0 replies; 23+ messages in thread
From: Lorenzo Bianconi @ 2020-10-28 11:43 UTC (permalink / raw)
To: Jesper Dangaard Brouer
Cc: netdev, bpf, lorenzo.bianconi, davem, kuba, ilias.apalodimas
[-- Attachment #1: Type: text/plain, Size: 4495 bytes --]
> On Tue, 27 Oct 2020 20:04:07 +0100
> Lorenzo Bianconi <lorenzo@kernel.org> wrote:
>
> > Introduce bulking capability in xdp tx return path (XDP_REDIRECT).
> > xdp_return_frame is usually run inside the driver NAPI tx completion
> > loop so it is possible batch it.
> > Current implementation considers only page_pool memory model.
> > Convert mvneta driver to xdp_return_frame_bulk APIs.
> >
> > Suggested-by: Jesper Dangaard Brouer <brouer@redhat.com>
Hi Jesper,
thx for the review.
>
> I think you/we have to explain better in this commit message, what the
> idea/concept behind this bulk return is. Or even explain this as a
> comment above "xdp_return_frame_bulk".
>
> Maybe add/append text to commit below:
>
> The bulk API introduced is a defer and flush API, that will defer
> the return if the xdp_mem_allocator object is the same, identified
> via the mem.id field (xdp_mem_info). Thus, the flush operation will
> operate on the same xdp_mem_allocator object.
>
> The bulk queue size of 16 is no coincident. This is connected to how
> XDP redirect will bulk xmit (upto 16) frames. Thus, the idea is for the
> API to find these boundaries (via mem.id match), which is optimal for
> both the I-cache and D-cache for the memory allocator code and object.
>
> The data structure (xdp_frame_bulk) used for deferred elements is
> stored/allocated on the function call-stack, which allows lockfree
> access.
ack, I will add it in v2
>
>
> > Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
> > ---
> [...]
> > diff --git a/include/net/xdp.h b/include/net/xdp.h
> > index 3814fb631d52..9567110845ef 100644
> > --- a/include/net/xdp.h
> > +++ b/include/net/xdp.h
> > @@ -104,6 +104,12 @@ struct xdp_frame {
> > struct net_device *dev_rx; /* used by cpumap */
> > };
> >
> > +#define XDP_BULK_QUEUE_SIZE 16
>
> Maybe "#define DEV_MAP_BULK_SIZE 16" should be def to
> XDP_BULK_QUEUE_SIZE, to express the described connection.
ack, I guess we can fix it in a following patch
>
> > +struct xdp_frame_bulk {
> > + void *q[XDP_BULK_QUEUE_SIZE];
> > + int count;
> > + void *xa;
>
> Just a hunch (not benchmarked), but I think it will be more optimal to
> place 'count' and '*xa' above the '*q' array. (It might not matter at
> all, as we cannot control the start alignment, when this is on the
> stack.)
ack. I will fix in v2.
>
> > +};
> [...]
>
> > diff --git a/net/core/xdp.c b/net/core/xdp.c
> > index 48aba933a5a8..93eabd789246 100644
> > --- a/net/core/xdp.c
> > +++ b/net/core/xdp.c
> > @@ -380,6 +380,57 @@ void xdp_return_frame_rx_napi(struct xdp_frame *xdpf)
> > }
> > EXPORT_SYMBOL_GPL(xdp_return_frame_rx_napi);
> >
> > +void xdp_flush_frame_bulk(struct xdp_frame_bulk *bq)
> > +{
> > + struct xdp_mem_allocator *xa = bq->xa;
> > + int i;
> > +
> > + if (unlikely(!xa))
> > + return;
> > +
> > + for (i = 0; i < bq->count; i++) {
> > + struct page *page = virt_to_head_page(bq->q[i]);
> > +
> > + page_pool_put_full_page(xa->page_pool, page, false);
> > + }
> > + bq->count = 0;
> > +}
> > +EXPORT_SYMBOL_GPL(xdp_flush_frame_bulk);
> > +
>
> Wondering if we should have a comment that explains the intent and idea
> behind this function?
>
> /* Defers return when frame belongs to same mem.id as previous frame */
>
ack.
Regards,
Lorenzo
> > +void xdp_return_frame_bulk(struct xdp_frame *xdpf,
> > + struct xdp_frame_bulk *bq)
> > +{
> > + struct xdp_mem_info *mem = &xdpf->mem;
> > + struct xdp_mem_allocator *xa, *nxa;
> > +
> > + if (mem->type != MEM_TYPE_PAGE_POOL) {
> > + __xdp_return(xdpf->data, &xdpf->mem, false);
> > + return;
> > + }
> > +
> > + rcu_read_lock();
> > +
> > + xa = bq->xa;
> > + if (unlikely(!xa || mem->id != xa->mem.id)) {
> > + nxa = rhashtable_lookup(mem_id_ht, &mem->id, mem_id_rht_params);
> > + if (unlikely(!xa)) {
> > + bq->count = 0;
> > + bq->xa = nxa;
> > + xa = nxa;
> > + }
> > + }
> > +
> > + if (mem->id != xa->mem.id || bq->count == XDP_BULK_QUEUE_SIZE)
> > + xdp_flush_frame_bulk(bq);
> > +
> > + bq->q[bq->count++] = xdpf->data;
> > + if (mem->id != xa->mem.id)
> > + bq->xa = nxa;
> > +
> > + rcu_read_unlock();
> > +}
> > +EXPORT_SYMBOL_GPL(xdp_return_frame_bulk);
>
>
> --
> Best regards,
> Jesper Dangaard Brouer
> MSc.CS, Principal Kernel Engineer at Red Hat
> LinkedIn: http://www.linkedin.com/in/brouer
>
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH net-next 1/4] net: xdp: introduce bulking for xdp tx return path
2020-10-27 19:04 ` [PATCH net-next 1/4] net: xdp: introduce bulking for xdp " Lorenzo Bianconi
2020-10-28 9:27 ` Ilias Apalodimas
2020-10-28 11:34 ` Jesper Dangaard Brouer
@ 2020-10-29 13:52 ` Jesper Dangaard Brouer
2020-10-29 14:02 ` Lorenzo Bianconi
2 siblings, 1 reply; 23+ messages in thread
From: Jesper Dangaard Brouer @ 2020-10-29 13:52 UTC (permalink / raw)
To: Lorenzo Bianconi
Cc: netdev, bpf, lorenzo.bianconi, davem, kuba, ilias.apalodimas, brouer
On Tue, 27 Oct 2020 20:04:07 +0100
Lorenzo Bianconi <lorenzo@kernel.org> wrote:
> diff --git a/net/core/xdp.c b/net/core/xdp.c
> index 48aba933a5a8..93eabd789246 100644
> --- a/net/core/xdp.c
> +++ b/net/core/xdp.c
> @@ -380,6 +380,57 @@ void xdp_return_frame_rx_napi(struct xdp_frame *xdpf)
> }
> EXPORT_SYMBOL_GPL(xdp_return_frame_rx_napi);
>
> +void xdp_flush_frame_bulk(struct xdp_frame_bulk *bq)
> +{
> + struct xdp_mem_allocator *xa = bq->xa;
> + int i;
> +
> + if (unlikely(!xa))
> + return;
> +
> + for (i = 0; i < bq->count; i++) {
> + struct page *page = virt_to_head_page(bq->q[i]);
> +
> + page_pool_put_full_page(xa->page_pool, page, false);
> + }
> + bq->count = 0;
> +}
> +EXPORT_SYMBOL_GPL(xdp_flush_frame_bulk);
> +
> +void xdp_return_frame_bulk(struct xdp_frame *xdpf,
> + struct xdp_frame_bulk *bq)
> +{
> + struct xdp_mem_info *mem = &xdpf->mem;
> + struct xdp_mem_allocator *xa, *nxa;
> +
> + if (mem->type != MEM_TYPE_PAGE_POOL) {
> + __xdp_return(xdpf->data, &xdpf->mem, false);
> + return;
> + }
> +
> + rcu_read_lock();
> +
> + xa = bq->xa;
> + if (unlikely(!xa || mem->id != xa->mem.id)) {
> + nxa = rhashtable_lookup(mem_id_ht, &mem->id, mem_id_rht_params);
> + if (unlikely(!xa)) {
> + bq->count = 0;
> + bq->xa = nxa;
> + xa = nxa;
> + }
> + }
> +
> + if (mem->id != xa->mem.id || bq->count == XDP_BULK_QUEUE_SIZE)
> + xdp_flush_frame_bulk(bq);
> +
> + bq->q[bq->count++] = xdpf->data;
> + if (mem->id != xa->mem.id)
> + bq->xa = nxa;
> +
> + rcu_read_unlock();
> +}
> +EXPORT_SYMBOL_GPL(xdp_return_frame_bulk);
We (Ilias my co-maintainer and I) think above code is hard to read and
understand (as a reader you need to keep too many cases in your head).
I think we both have proposals to improve this, here is mine:
/* Defers return when frame belongs to same mem.id as previous frame */
void xdp_return_frame_bulk(struct xdp_frame *xdpf,
struct xdp_frame_bulk *bq)
{
struct xdp_mem_info *mem = &xdpf->mem;
struct xdp_mem_allocator *xa;
if (mem->type != MEM_TYPE_PAGE_POOL) {
__xdp_return(xdpf->data, &xdpf->mem, false);
return;
}
rcu_read_lock();
xa = bq->xa;
if (unlikely(!xa)) {
xa = rhashtable_lookup(mem_id_ht, &mem->id, mem_id_rht_params);
bq->count = 0;
bq->xa = xa;
}
if (bq->count == XDP_BULK_QUEUE_SIZE)
xdp_flush_frame_bulk(bq);
if (mem->id != xa->mem.id) {
xdp_flush_frame_bulk(bq);
bq->xa = rhashtable_lookup(mem_id_ht, &mem->id, mem_id_rht_params);
}
bq->q[bq->count++] = xdpf->data;
rcu_read_unlock();
}
Please review for correctness, and also for readability.
--
Best regards,
Jesper Dangaard Brouer
MSc.CS, Principal Kernel Engineer at Red Hat
LinkedIn: http://www.linkedin.com/in/brouer
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH net-next 1/4] net: xdp: introduce bulking for xdp tx return path
2020-10-29 13:52 ` Jesper Dangaard Brouer
@ 2020-10-29 14:02 ` Lorenzo Bianconi
2020-10-29 14:08 ` Ilias Apalodimas
0 siblings, 1 reply; 23+ messages in thread
From: Lorenzo Bianconi @ 2020-10-29 14:02 UTC (permalink / raw)
To: Jesper Dangaard Brouer
Cc: Lorenzo Bianconi, netdev, bpf, davem, kuba, ilias.apalodimas
[-- Attachment #1: Type: text/plain, Size: 3343 bytes --]
> On Tue, 27 Oct 2020 20:04:07 +0100
> Lorenzo Bianconi <lorenzo@kernel.org> wrote:
>
> > diff --git a/net/core/xdp.c b/net/core/xdp.c
> > index 48aba933a5a8..93eabd789246 100644
> > --- a/net/core/xdp.c
> > +++ b/net/core/xdp.c
> > @@ -380,6 +380,57 @@ void xdp_return_frame_rx_napi(struct xdp_frame *xdpf)
> > }
> > EXPORT_SYMBOL_GPL(xdp_return_frame_rx_napi);
> >
> > +void xdp_flush_frame_bulk(struct xdp_frame_bulk *bq)
> > +{
> > + struct xdp_mem_allocator *xa = bq->xa;
> > + int i;
> > +
> > + if (unlikely(!xa))
> > + return;
> > +
> > + for (i = 0; i < bq->count; i++) {
> > + struct page *page = virt_to_head_page(bq->q[i]);
> > +
> > + page_pool_put_full_page(xa->page_pool, page, false);
> > + }
> > + bq->count = 0;
> > +}
> > +EXPORT_SYMBOL_GPL(xdp_flush_frame_bulk);
> > +
> > +void xdp_return_frame_bulk(struct xdp_frame *xdpf,
> > + struct xdp_frame_bulk *bq)
> > +{
> > + struct xdp_mem_info *mem = &xdpf->mem;
> > + struct xdp_mem_allocator *xa, *nxa;
> > +
> > + if (mem->type != MEM_TYPE_PAGE_POOL) {
> > + __xdp_return(xdpf->data, &xdpf->mem, false);
> > + return;
> > + }
> > +
> > + rcu_read_lock();
> > +
> > + xa = bq->xa;
> > + if (unlikely(!xa || mem->id != xa->mem.id)) {
> > + nxa = rhashtable_lookup(mem_id_ht, &mem->id, mem_id_rht_params);
> > + if (unlikely(!xa)) {
> > + bq->count = 0;
> > + bq->xa = nxa;
> > + xa = nxa;
> > + }
> > + }
> > +
> > + if (mem->id != xa->mem.id || bq->count == XDP_BULK_QUEUE_SIZE)
> > + xdp_flush_frame_bulk(bq);
> > +
> > + bq->q[bq->count++] = xdpf->data;
> > + if (mem->id != xa->mem.id)
> > + bq->xa = nxa;
> > +
> > + rcu_read_unlock();
> > +}
> > +EXPORT_SYMBOL_GPL(xdp_return_frame_bulk);
>
> We (Ilias my co-maintainer and I) think above code is hard to read and
> understand (as a reader you need to keep too many cases in your head).
>
> I think we both have proposals to improve this, here is mine:
>
> /* Defers return when frame belongs to same mem.id as previous frame */
> void xdp_return_frame_bulk(struct xdp_frame *xdpf,
> struct xdp_frame_bulk *bq)
> {
> struct xdp_mem_info *mem = &xdpf->mem;
> struct xdp_mem_allocator *xa;
>
> if (mem->type != MEM_TYPE_PAGE_POOL) {
> __xdp_return(xdpf->data, &xdpf->mem, false);
> return;
> }
>
> rcu_read_lock();
>
> xa = bq->xa;
> if (unlikely(!xa)) {
> xa = rhashtable_lookup(mem_id_ht, &mem->id, mem_id_rht_params);
> bq->count = 0;
> bq->xa = xa;
> }
>
> if (bq->count == XDP_BULK_QUEUE_SIZE)
> xdp_flush_frame_bulk(bq);
>
> if (mem->id != xa->mem.id) {
> xdp_flush_frame_bulk(bq);
> bq->xa = rhashtable_lookup(mem_id_ht, &mem->id, mem_id_rht_params);
> }
>
> bq->q[bq->count++] = xdpf->data;
>
> rcu_read_unlock();
> }
>
> Please review for correctness, and also for readability.
the code seems fine to me (and even easier to read :)).
I will update v2 using this approach. Thx.
Regards,
Lorenzo
>
> --
> Best regards,
> Jesper Dangaard Brouer
> MSc.CS, Principal Kernel Engineer at Red Hat
> LinkedIn: http://www.linkedin.com/in/brouer
>
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH net-next 1/4] net: xdp: introduce bulking for xdp tx return path
2020-10-29 14:02 ` Lorenzo Bianconi
@ 2020-10-29 14:08 ` Ilias Apalodimas
0 siblings, 0 replies; 23+ messages in thread
From: Ilias Apalodimas @ 2020-10-29 14:08 UTC (permalink / raw)
To: Lorenzo Bianconi
Cc: Jesper Dangaard Brouer, Lorenzo Bianconi, netdev, bpf, davem, kuba
On Thu, Oct 29, 2020 at 03:02:16PM +0100, Lorenzo Bianconi wrote:
> > On Tue, 27 Oct 2020 20:04:07 +0100
> > Lorenzo Bianconi <lorenzo@kernel.org> wrote:
> >
> > > diff --git a/net/core/xdp.c b/net/core/xdp.c
> > > index 48aba933a5a8..93eabd789246 100644
> > > --- a/net/core/xdp.c
> > > +++ b/net/core/xdp.c
> > > @@ -380,6 +380,57 @@ void xdp_return_frame_rx_napi(struct xdp_frame *xdpf)
> > > }
> > > EXPORT_SYMBOL_GPL(xdp_return_frame_rx_napi);
> > >
> > > +void xdp_flush_frame_bulk(struct xdp_frame_bulk *bq)
> > > +{
> > > + struct xdp_mem_allocator *xa = bq->xa;
> > > + int i;
> > > +
> > > + if (unlikely(!xa))
> > > + return;
> > > +
> > > + for (i = 0; i < bq->count; i++) {
> > > + struct page *page = virt_to_head_page(bq->q[i]);
> > > +
> > > + page_pool_put_full_page(xa->page_pool, page, false);
> > > + }
> > > + bq->count = 0;
> > > +}
> > > +EXPORT_SYMBOL_GPL(xdp_flush_frame_bulk);
> > > +
> > > +void xdp_return_frame_bulk(struct xdp_frame *xdpf,
> > > + struct xdp_frame_bulk *bq)
> > > +{
> > > + struct xdp_mem_info *mem = &xdpf->mem;
> > > + struct xdp_mem_allocator *xa, *nxa;
> > > +
> > > + if (mem->type != MEM_TYPE_PAGE_POOL) {
> > > + __xdp_return(xdpf->data, &xdpf->mem, false);
> > > + return;
> > > + }
> > > +
> > > + rcu_read_lock();
> > > +
> > > + xa = bq->xa;
> > > + if (unlikely(!xa || mem->id != xa->mem.id)) {
> > > + nxa = rhashtable_lookup(mem_id_ht, &mem->id, mem_id_rht_params);
> > > + if (unlikely(!xa)) {
> > > + bq->count = 0;
> > > + bq->xa = nxa;
> > > + xa = nxa;
> > > + }
> > > + }
> > > +
> > > + if (mem->id != xa->mem.id || bq->count == XDP_BULK_QUEUE_SIZE)
> > > + xdp_flush_frame_bulk(bq);
> > > +
> > > + bq->q[bq->count++] = xdpf->data;
> > > + if (mem->id != xa->mem.id)
> > > + bq->xa = nxa;
> > > +
> > > + rcu_read_unlock();
> > > +}
> > > +EXPORT_SYMBOL_GPL(xdp_return_frame_bulk);
> >
> > We (Ilias my co-maintainer and I) think above code is hard to read and
> > understand (as a reader you need to keep too many cases in your head).
> >
> > I think we both have proposals to improve this, here is mine:
> >
> > /* Defers return when frame belongs to same mem.id as previous frame */
> > void xdp_return_frame_bulk(struct xdp_frame *xdpf,
> > struct xdp_frame_bulk *bq)
> > {
> > struct xdp_mem_info *mem = &xdpf->mem;
> > struct xdp_mem_allocator *xa;
> >
> > if (mem->type != MEM_TYPE_PAGE_POOL) {
> > __xdp_return(xdpf->data, &xdpf->mem, false);
> > return;
> > }
> >
> > rcu_read_lock();
> >
> > xa = bq->xa;
> > if (unlikely(!xa)) {
> > xa = rhashtable_lookup(mem_id_ht, &mem->id, mem_id_rht_params);
> > bq->count = 0;
> > bq->xa = xa;
> > }
> >
> > if (bq->count == XDP_BULK_QUEUE_SIZE)
> > xdp_flush_frame_bulk(bq);
> >
> > if (mem->id != xa->mem.id) {
> > xdp_flush_frame_bulk(bq);
> > bq->xa = rhashtable_lookup(mem_id_ht, &mem->id, mem_id_rht_params);
> > }
> >
> > bq->q[bq->count++] = xdpf->data;
> >
> > rcu_read_unlock();
> > }
> >
> > Please review for correctness, and also for readability.
>
> the code seems fine to me (and even easier to read :)).
> I will update v2 using this approach. Thx.
+1 this is close to what we discussed this morning and it detangles 1 more 'weird'
if case
Thanks
/Ilias
>
> Regards,
> Lorenzo
>
> >
> > --
> > Best regards,
> > Jesper Dangaard Brouer
> > MSc.CS, Principal Kernel Engineer at Red Hat
> > LinkedIn: http://www.linkedin.com/in/brouer
> >
^ permalink raw reply [flat|nested] 23+ messages in thread
* [PATCH net-next 2/4] net: page_pool: add bulk support for ptr_ring
2020-10-27 19:04 [PATCH net-next 0/4] xdp: introduce bulking for page_pool tx return path Lorenzo Bianconi
2020-10-27 19:04 ` [PATCH net-next 1/4] net: xdp: introduce bulking for xdp " Lorenzo Bianconi
@ 2020-10-27 19:04 ` Lorenzo Bianconi
2020-10-29 7:08 ` Ilias Apalodimas
` (2 more replies)
2020-10-27 19:04 ` [PATCH net-next 3/4] net: mvpp2: add xdp tx return bulking support Lorenzo Bianconi
2020-10-27 19:04 ` [PATCH net-next 4/4] net: mlx5: " Lorenzo Bianconi
3 siblings, 3 replies; 23+ messages in thread
From: Lorenzo Bianconi @ 2020-10-27 19:04 UTC (permalink / raw)
To: netdev; +Cc: bpf, lorenzo.bianconi, davem, kuba, brouer, ilias.apalodimas
Introduce the capability to batch page_pool ptr_ring refill since it is
usually run inside the driver NAPI tx completion loop.
Suggested-by: Jesper Dangaard Brouer <brouer@redhat.com>
Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
---
include/net/page_pool.h | 26 ++++++++++++++++++++++++++
net/core/page_pool.c | 33 +++++++++++++++++++++++++++++++++
net/core/xdp.c | 9 ++-------
3 files changed, 61 insertions(+), 7 deletions(-)
diff --git a/include/net/page_pool.h b/include/net/page_pool.h
index 81d7773f96cd..b5b195305346 100644
--- a/include/net/page_pool.h
+++ b/include/net/page_pool.h
@@ -152,6 +152,8 @@ struct page_pool *page_pool_create(const struct page_pool_params *params);
void page_pool_destroy(struct page_pool *pool);
void page_pool_use_xdp_mem(struct page_pool *pool, void (*disconnect)(void *));
void page_pool_release_page(struct page_pool *pool, struct page *page);
+void page_pool_put_page_bulk(struct page_pool *pool, void **data,
+ int count);
#else
static inline void page_pool_destroy(struct page_pool *pool)
{
@@ -165,6 +167,11 @@ static inline void page_pool_release_page(struct page_pool *pool,
struct page *page)
{
}
+
+static inline void page_pool_put_page_bulk(struct page_pool *pool, void **data,
+ int count)
+{
+}
#endif
void page_pool_put_page(struct page_pool *pool, struct page *page,
@@ -215,4 +222,23 @@ static inline void page_pool_nid_changed(struct page_pool *pool, int new_nid)
if (unlikely(pool->p.nid != new_nid))
page_pool_update_nid(pool, new_nid);
}
+
+static inline void page_pool_ring_lock(struct page_pool *pool)
+ __acquires(&pool->ring.producer_lock)
+{
+ if (in_serving_softirq())
+ spin_lock(&pool->ring.producer_lock);
+ else
+ spin_lock_bh(&pool->ring.producer_lock);
+}
+
+static inline void page_pool_ring_unlock(struct page_pool *pool)
+ __releases(&pool->ring.producer_lock)
+{
+ if (in_serving_softirq())
+ spin_unlock(&pool->ring.producer_lock);
+ else
+ spin_unlock_bh(&pool->ring.producer_lock);
+}
+
#endif /* _NET_PAGE_POOL_H */
diff --git a/net/core/page_pool.c b/net/core/page_pool.c
index ef98372facf6..84fb21f8865e 100644
--- a/net/core/page_pool.c
+++ b/net/core/page_pool.c
@@ -11,6 +11,8 @@
#include <linux/device.h>
#include <net/page_pool.h>
+#include <net/xdp.h>
+
#include <linux/dma-direction.h>
#include <linux/dma-mapping.h>
#include <linux/page-flags.h>
@@ -408,6 +410,37 @@ void page_pool_put_page(struct page_pool *pool, struct page *page,
}
EXPORT_SYMBOL(page_pool_put_page);
+void page_pool_put_page_bulk(struct page_pool *pool, void **data,
+ int count)
+{
+ struct page *page_ring[XDP_BULK_QUEUE_SIZE];
+ int i, len = 0;
+
+ for (i = 0; i < count; i++) {
+ struct page *page = virt_to_head_page(data[i]);
+
+ if (unlikely(page_ref_count(page) != 1 ||
+ !pool_page_reusable(pool, page))) {
+ page_pool_release_page(pool, page);
+ put_page(page);
+ continue;
+ }
+
+ if (pool->p.flags & PP_FLAG_DMA_SYNC_DEV)
+ page_pool_dma_sync_for_device(pool, page, -1);
+
+ page_ring[len++] = page;
+ }
+
+ page_pool_ring_lock(pool);
+ for (i = 0; i < len; i++) {
+ if (__ptr_ring_produce(&pool->ring, page_ring[i]))
+ page_pool_return_page(pool, page_ring[i]);
+ }
+ page_pool_ring_unlock(pool);
+}
+EXPORT_SYMBOL(page_pool_put_page_bulk);
+
static void page_pool_empty_ring(struct page_pool *pool)
{
struct page *page;
diff --git a/net/core/xdp.c b/net/core/xdp.c
index 93eabd789246..9f9a8d14df38 100644
--- a/net/core/xdp.c
+++ b/net/core/xdp.c
@@ -383,16 +383,11 @@ EXPORT_SYMBOL_GPL(xdp_return_frame_rx_napi);
void xdp_flush_frame_bulk(struct xdp_frame_bulk *bq)
{
struct xdp_mem_allocator *xa = bq->xa;
- int i;
- if (unlikely(!xa))
+ if (unlikely(!xa || !bq->count))
return;
- for (i = 0; i < bq->count; i++) {
- struct page *page = virt_to_head_page(bq->q[i]);
-
- page_pool_put_full_page(xa->page_pool, page, false);
- }
+ page_pool_put_page_bulk(xa->page_pool, bq->q, bq->count);
bq->count = 0;
}
EXPORT_SYMBOL_GPL(xdp_flush_frame_bulk);
--
2.26.2
^ permalink raw reply related [flat|nested] 23+ messages in thread* Re: [PATCH net-next 2/4] net: page_pool: add bulk support for ptr_ring
2020-10-27 19:04 ` [PATCH net-next 2/4] net: page_pool: add bulk support for ptr_ring Lorenzo Bianconi
@ 2020-10-29 7:08 ` Ilias Apalodimas
2020-10-29 10:36 ` Lorenzo Bianconi
2020-10-29 7:25 ` Ilias Apalodimas
2020-10-29 10:13 ` Jesper Dangaard Brouer
2 siblings, 1 reply; 23+ messages in thread
From: Ilias Apalodimas @ 2020-10-29 7:08 UTC (permalink / raw)
To: Lorenzo Bianconi; +Cc: netdev, bpf, lorenzo.bianconi, davem, kuba, brouer
Hi Lorenzo,
On Tue, Oct 27, 2020 at 08:04:08PM +0100, Lorenzo Bianconi wrote:
> Introduce the capability to batch page_pool ptr_ring refill since it is
> usually run inside the driver NAPI tx completion loop.
>
> Suggested-by: Jesper Dangaard Brouer <brouer@redhat.com>
> Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
> ---
> include/net/page_pool.h | 26 ++++++++++++++++++++++++++
> net/core/page_pool.c | 33 +++++++++++++++++++++++++++++++++
> net/core/xdp.c | 9 ++-------
> 3 files changed, 61 insertions(+), 7 deletions(-)
>
> diff --git a/include/net/page_pool.h b/include/net/page_pool.h
> index 81d7773f96cd..b5b195305346 100644
> --- a/include/net/page_pool.h
> +++ b/include/net/page_pool.h
> @@ -152,6 +152,8 @@ struct page_pool *page_pool_create(const struct page_pool_params *params);
> void page_pool_destroy(struct page_pool *pool);
> void page_pool_use_xdp_mem(struct page_pool *pool, void (*disconnect)(void *));
> void page_pool_release_page(struct page_pool *pool, struct page *page);
> +void page_pool_put_page_bulk(struct page_pool *pool, void **data,
> + int count);
> #else
> static inline void page_pool_destroy(struct page_pool *pool)
> {
> @@ -165,6 +167,11 @@ static inline void page_pool_release_page(struct page_pool *pool,
> struct page *page)
> {
> }
> +
> +static inline void page_pool_put_page_bulk(struct page_pool *pool, void **data,
> + int count)
> +{
> +}
> #endif
>
> void page_pool_put_page(struct page_pool *pool, struct page *page,
> @@ -215,4 +222,23 @@ static inline void page_pool_nid_changed(struct page_pool *pool, int new_nid)
> if (unlikely(pool->p.nid != new_nid))
> page_pool_update_nid(pool, new_nid);
> }
> +
> +static inline void page_pool_ring_lock(struct page_pool *pool)
> + __acquires(&pool->ring.producer_lock)
> +{
> + if (in_serving_softirq())
> + spin_lock(&pool->ring.producer_lock);
> + else
> + spin_lock_bh(&pool->ring.producer_lock);
> +}
> +
> +static inline void page_pool_ring_unlock(struct page_pool *pool)
> + __releases(&pool->ring.producer_lock)
> +{
> + if (in_serving_softirq())
> + spin_unlock(&pool->ring.producer_lock);
> + else
> + spin_unlock_bh(&pool->ring.producer_lock);
> +}
> +
> #endif /* _NET_PAGE_POOL_H */
> diff --git a/net/core/page_pool.c b/net/core/page_pool.c
> index ef98372facf6..84fb21f8865e 100644
> --- a/net/core/page_pool.c
> +++ b/net/core/page_pool.c
> @@ -11,6 +11,8 @@
> #include <linux/device.h>
>
> #include <net/page_pool.h>
> +#include <net/xdp.h>
> +
> #include <linux/dma-direction.h>
> #include <linux/dma-mapping.h>
> #include <linux/page-flags.h>
> @@ -408,6 +410,37 @@ void page_pool_put_page(struct page_pool *pool, struct page *page,
> }
> EXPORT_SYMBOL(page_pool_put_page);
>
> +void page_pool_put_page_bulk(struct page_pool *pool, void **data,
> + int count)
> +{
> + struct page *page_ring[XDP_BULK_QUEUE_SIZE];
> + int i, len = 0;
> +
> + for (i = 0; i < count; i++) {
> + struct page *page = virt_to_head_page(data[i]);
> +
> + if (unlikely(page_ref_count(page) != 1 ||
> + !pool_page_reusable(pool, page))) {
> + page_pool_release_page(pool, page);
Mind switching this similarly to how page_pool_put_page() is using it?
unlikely -> likely and remove the !
> + put_page(page);
> + continue;
> + }
> +
> + if (pool->p.flags & PP_FLAG_DMA_SYNC_DEV)
> + page_pool_dma_sync_for_device(pool, page, -1);
> +
> + page_ring[len++] = page;
> + }
> +
> + page_pool_ring_lock(pool);
> + for (i = 0; i < len; i++) {
> + if (__ptr_ring_produce(&pool->ring, page_ring[i]))
> + page_pool_return_page(pool, page_ring[i]);
> + }
> + page_pool_ring_unlock(pool);
> +}
> +EXPORT_SYMBOL(page_pool_put_page_bulk);
> +
> static void page_pool_empty_ring(struct page_pool *pool)
> {
> struct page *page;
> diff --git a/net/core/xdp.c b/net/core/xdp.c
> index 93eabd789246..9f9a8d14df38 100644
> --- a/net/core/xdp.c
> +++ b/net/core/xdp.c
> @@ -383,16 +383,11 @@ EXPORT_SYMBOL_GPL(xdp_return_frame_rx_napi);
> void xdp_flush_frame_bulk(struct xdp_frame_bulk *bq)
> {
> struct xdp_mem_allocator *xa = bq->xa;
> - int i;
>
> - if (unlikely(!xa))
> + if (unlikely(!xa || !bq->count))
> return;
>
> - for (i = 0; i < bq->count; i++) {
> - struct page *page = virt_to_head_page(bq->q[i]);
> -
> - page_pool_put_full_page(xa->page_pool, page, false);
> - }
> + page_pool_put_page_bulk(xa->page_pool, bq->q, bq->count);
> bq->count = 0;
> }
> EXPORT_SYMBOL_GPL(xdp_flush_frame_bulk);
> --
> 2.26.2
>
Cheers
/Ilias
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH net-next 2/4] net: page_pool: add bulk support for ptr_ring
2020-10-29 7:08 ` Ilias Apalodimas
@ 2020-10-29 10:36 ` Lorenzo Bianconi
0 siblings, 0 replies; 23+ messages in thread
From: Lorenzo Bianconi @ 2020-10-29 10:36 UTC (permalink / raw)
To: Ilias Apalodimas; +Cc: Lorenzo Bianconi, netdev, bpf, davem, kuba, brouer
[-- Attachment #1: Type: text/plain, Size: 5074 bytes --]
> Hi Lorenzo,
>
> On Tue, Oct 27, 2020 at 08:04:08PM +0100, Lorenzo Bianconi wrote:
> > Introduce the capability to batch page_pool ptr_ring refill since it is
> > usually run inside the driver NAPI tx completion loop.
> >
> > Suggested-by: Jesper Dangaard Brouer <brouer@redhat.com>
> > Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
> > ---
> > include/net/page_pool.h | 26 ++++++++++++++++++++++++++
> > net/core/page_pool.c | 33 +++++++++++++++++++++++++++++++++
> > net/core/xdp.c | 9 ++-------
> > 3 files changed, 61 insertions(+), 7 deletions(-)
> >
> > diff --git a/include/net/page_pool.h b/include/net/page_pool.h
> > index 81d7773f96cd..b5b195305346 100644
> > --- a/include/net/page_pool.h
> > +++ b/include/net/page_pool.h
> > @@ -152,6 +152,8 @@ struct page_pool *page_pool_create(const struct page_pool_params *params);
> > void page_pool_destroy(struct page_pool *pool);
> > void page_pool_use_xdp_mem(struct page_pool *pool, void (*disconnect)(void *));
> > void page_pool_release_page(struct page_pool *pool, struct page *page);
> > +void page_pool_put_page_bulk(struct page_pool *pool, void **data,
> > + int count);
> > #else
> > static inline void page_pool_destroy(struct page_pool *pool)
> > {
> > @@ -165,6 +167,11 @@ static inline void page_pool_release_page(struct page_pool *pool,
> > struct page *page)
> > {
> > }
> > +
> > +static inline void page_pool_put_page_bulk(struct page_pool *pool, void **data,
> > + int count)
> > +{
> > +}
> > #endif
> >
> > void page_pool_put_page(struct page_pool *pool, struct page *page,
> > @@ -215,4 +222,23 @@ static inline void page_pool_nid_changed(struct page_pool *pool, int new_nid)
> > if (unlikely(pool->p.nid != new_nid))
> > page_pool_update_nid(pool, new_nid);
> > }
> > +
> > +static inline void page_pool_ring_lock(struct page_pool *pool)
> > + __acquires(&pool->ring.producer_lock)
> > +{
> > + if (in_serving_softirq())
> > + spin_lock(&pool->ring.producer_lock);
> > + else
> > + spin_lock_bh(&pool->ring.producer_lock);
> > +}
> > +
> > +static inline void page_pool_ring_unlock(struct page_pool *pool)
> > + __releases(&pool->ring.producer_lock)
> > +{
> > + if (in_serving_softirq())
> > + spin_unlock(&pool->ring.producer_lock);
> > + else
> > + spin_unlock_bh(&pool->ring.producer_lock);
> > +}
> > +
> > #endif /* _NET_PAGE_POOL_H */
> > diff --git a/net/core/page_pool.c b/net/core/page_pool.c
> > index ef98372facf6..84fb21f8865e 100644
> > --- a/net/core/page_pool.c
> > +++ b/net/core/page_pool.c
> > @@ -11,6 +11,8 @@
> > #include <linux/device.h>
> >
> > #include <net/page_pool.h>
> > +#include <net/xdp.h>
> > +
> > #include <linux/dma-direction.h>
> > #include <linux/dma-mapping.h>
> > #include <linux/page-flags.h>
> > @@ -408,6 +410,37 @@ void page_pool_put_page(struct page_pool *pool, struct page *page,
> > }
> > EXPORT_SYMBOL(page_pool_put_page);
> >
> > +void page_pool_put_page_bulk(struct page_pool *pool, void **data,
> > + int count)
> > +{
> > + struct page *page_ring[XDP_BULK_QUEUE_SIZE];
> > + int i, len = 0;
> > +
> > + for (i = 0; i < count; i++) {
> > + struct page *page = virt_to_head_page(data[i]);
> > +
> > + if (unlikely(page_ref_count(page) != 1 ||
> > + !pool_page_reusable(pool, page))) {
> > + page_pool_release_page(pool, page);
>
> Mind switching this similarly to how page_pool_put_page() is using it?
> unlikely -> likely and remove the !
Hi Ilias,
thx for the review. ack, I will do it in v2
Regards,
Lorenzo
>
> > + put_page(page);
> > + continue;
> > + }
> > +
> > + if (pool->p.flags & PP_FLAG_DMA_SYNC_DEV)
> > + page_pool_dma_sync_for_device(pool, page, -1);
> > +
> > + page_ring[len++] = page;
> > + }
> > +
> > + page_pool_ring_lock(pool);
> > + for (i = 0; i < len; i++) {
> > + if (__ptr_ring_produce(&pool->ring, page_ring[i]))
> > + page_pool_return_page(pool, page_ring[i]);
> > + }
> > + page_pool_ring_unlock(pool);
> > +}
> > +EXPORT_SYMBOL(page_pool_put_page_bulk);
> > +
> > static void page_pool_empty_ring(struct page_pool *pool)
> > {
> > struct page *page;
> > diff --git a/net/core/xdp.c b/net/core/xdp.c
> > index 93eabd789246..9f9a8d14df38 100644
> > --- a/net/core/xdp.c
> > +++ b/net/core/xdp.c
> > @@ -383,16 +383,11 @@ EXPORT_SYMBOL_GPL(xdp_return_frame_rx_napi);
> > void xdp_flush_frame_bulk(struct xdp_frame_bulk *bq)
> > {
> > struct xdp_mem_allocator *xa = bq->xa;
> > - int i;
> >
> > - if (unlikely(!xa))
> > + if (unlikely(!xa || !bq->count))
> > return;
> >
> > - for (i = 0; i < bq->count; i++) {
> > - struct page *page = virt_to_head_page(bq->q[i]);
> > -
> > - page_pool_put_full_page(xa->page_pool, page, false);
> > - }
> > + page_pool_put_page_bulk(xa->page_pool, bq->q, bq->count);
> > bq->count = 0;
> > }
> > EXPORT_SYMBOL_GPL(xdp_flush_frame_bulk);
> > --
> > 2.26.2
> >
>
> Cheers
> /Ilias
>
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH net-next 2/4] net: page_pool: add bulk support for ptr_ring
2020-10-27 19:04 ` [PATCH net-next 2/4] net: page_pool: add bulk support for ptr_ring Lorenzo Bianconi
2020-10-29 7:08 ` Ilias Apalodimas
@ 2020-10-29 7:25 ` Ilias Apalodimas
2020-10-29 10:37 ` Lorenzo Bianconi
2020-10-29 10:13 ` Jesper Dangaard Brouer
2 siblings, 1 reply; 23+ messages in thread
From: Ilias Apalodimas @ 2020-10-29 7:25 UTC (permalink / raw)
To: Lorenzo Bianconi; +Cc: netdev, bpf, lorenzo.bianconi, davem, kuba, brouer
On Tue, Oct 27, 2020 at 08:04:08PM +0100, Lorenzo Bianconi wrote:
> Introduce the capability to batch page_pool ptr_ring refill since it is
> usually run inside the driver NAPI tx completion loop.
>
> Suggested-by: Jesper Dangaard Brouer <brouer@redhat.com>
> Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
> ---
> include/net/page_pool.h | 26 ++++++++++++++++++++++++++
> net/core/page_pool.c | 33 +++++++++++++++++++++++++++++++++
> net/core/xdp.c | 9 ++-------
> 3 files changed, 61 insertions(+), 7 deletions(-)
>
> diff --git a/include/net/page_pool.h b/include/net/page_pool.h
> index 81d7773f96cd..b5b195305346 100644
> --- a/include/net/page_pool.h
> +++ b/include/net/page_pool.h
> @@ -152,6 +152,8 @@ struct page_pool *page_pool_create(const struct page_pool_params *params);
> void page_pool_destroy(struct page_pool *pool);
> void page_pool_use_xdp_mem(struct page_pool *pool, void (*disconnect)(void *));
> void page_pool_release_page(struct page_pool *pool, struct page *page);
> +void page_pool_put_page_bulk(struct page_pool *pool, void **data,
> + int count);
> #else
> static inline void page_pool_destroy(struct page_pool *pool)
> {
> @@ -165,6 +167,11 @@ static inline void page_pool_release_page(struct page_pool *pool,
> struct page *page)
> {
> }
> +
> +static inline void page_pool_put_page_bulk(struct page_pool *pool, void **data,
> + int count)
> +{
> +}
> #endif
>
> void page_pool_put_page(struct page_pool *pool, struct page *page,
> @@ -215,4 +222,23 @@ static inline void page_pool_nid_changed(struct page_pool *pool, int new_nid)
> if (unlikely(pool->p.nid != new_nid))
> page_pool_update_nid(pool, new_nid);
> }
> +
> +static inline void page_pool_ring_lock(struct page_pool *pool)
> + __acquires(&pool->ring.producer_lock)
> +{
> + if (in_serving_softirq())
> + spin_lock(&pool->ring.producer_lock);
> + else
> + spin_lock_bh(&pool->ring.producer_lock);
> +}
> +
> +static inline void page_pool_ring_unlock(struct page_pool *pool)
> + __releases(&pool->ring.producer_lock)
> +{
> + if (in_serving_softirq())
> + spin_unlock(&pool->ring.producer_lock);
> + else
> + spin_unlock_bh(&pool->ring.producer_lock);
> +}
> +
> #endif /* _NET_PAGE_POOL_H */
> diff --git a/net/core/page_pool.c b/net/core/page_pool.c
> index ef98372facf6..84fb21f8865e 100644
> --- a/net/core/page_pool.c
> +++ b/net/core/page_pool.c
> @@ -11,6 +11,8 @@
> #include <linux/device.h>
>
> #include <net/page_pool.h>
> +#include <net/xdp.h>
> +
> #include <linux/dma-direction.h>
> #include <linux/dma-mapping.h>
> #include <linux/page-flags.h>
> @@ -408,6 +410,37 @@ void page_pool_put_page(struct page_pool *pool, struct page *page,
> }
> EXPORT_SYMBOL(page_pool_put_page);
>
> +void page_pool_put_page_bulk(struct page_pool *pool, void **data,
> + int count)
> +{
> + struct page *page_ring[XDP_BULK_QUEUE_SIZE];
> + int i, len = 0;
> +
> + for (i = 0; i < count; i++) {
> + struct page *page = virt_to_head_page(data[i]);
> +
> + if (unlikely(page_ref_count(page) != 1 ||
> + !pool_page_reusable(pool, page))) {
> + page_pool_release_page(pool, page);
> + put_page(page);
> + continue;
> + }
> +
> + if (pool->p.flags & PP_FLAG_DMA_SYNC_DEV)
> + page_pool_dma_sync_for_device(pool, page, -1);
> +
> + page_ring[len++] = page;
> + }
> +
> + page_pool_ring_lock(pool);
> + for (i = 0; i < len; i++) {
> + if (__ptr_ring_produce(&pool->ring, page_ring[i]))
> + page_pool_return_page(pool, page_ring[i]);
Can we add a comment here on why the explicit spinlock needs to protect
page_pool_return_page() as well instead of just using ptr_ring_produce()?
> + }
> + page_pool_ring_unlock(pool);
> +}
> +EXPORT_SYMBOL(page_pool_put_page_bulk);
> +
> static void page_pool_empty_ring(struct page_pool *pool)
> {
> struct page *page;
> diff --git a/net/core/xdp.c b/net/core/xdp.c
> index 93eabd789246..9f9a8d14df38 100644
> --- a/net/core/xdp.c
> +++ b/net/core/xdp.c
> @@ -383,16 +383,11 @@ EXPORT_SYMBOL_GPL(xdp_return_frame_rx_napi);
> void xdp_flush_frame_bulk(struct xdp_frame_bulk *bq)
> {
> struct xdp_mem_allocator *xa = bq->xa;
> - int i;
>
> - if (unlikely(!xa))
> + if (unlikely(!xa || !bq->count))
> return;
>
> - for (i = 0; i < bq->count; i++) {
> - struct page *page = virt_to_head_page(bq->q[i]);
> -
> - page_pool_put_full_page(xa->page_pool, page, false);
> - }
> + page_pool_put_page_bulk(xa->page_pool, bq->q, bq->count);
> bq->count = 0;
> }
> EXPORT_SYMBOL_GPL(xdp_flush_frame_bulk);
> --
> 2.26.2
>
Thanks
/Ilias
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH net-next 2/4] net: page_pool: add bulk support for ptr_ring
2020-10-29 7:25 ` Ilias Apalodimas
@ 2020-10-29 10:37 ` Lorenzo Bianconi
0 siblings, 0 replies; 23+ messages in thread
From: Lorenzo Bianconi @ 2020-10-29 10:37 UTC (permalink / raw)
To: Ilias Apalodimas; +Cc: Lorenzo Bianconi, netdev, bpf, davem, kuba, brouer
[-- Attachment #1: Type: text/plain, Size: 2762 bytes --]
> On Tue, Oct 27, 2020 at 08:04:08PM +0100, Lorenzo Bianconi wrote:
> > Introduce the capability to batch page_pool ptr_ring refill since it is
> > usually run inside the driver NAPI tx completion loop.
> >
> > Suggested-by: Jesper Dangaard Brouer <brouer@redhat.com>
> > Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
> > ---
> > include/net/page_pool.h | 26 ++++++++++++++++++++++++++
> > net/core/page_pool.c | 33 +++++++++++++++++++++++++++++++++
> > net/core/xdp.c | 9 ++-------
> > 3 files changed, 61 insertions(+), 7 deletions(-)
> >
> > diff --git a/include/net/page_pool.h b/include/net/page_pool.h
> > index 81d7773f96cd..b5b195305346 100644
[...]
> > +void page_pool_put_page_bulk(struct page_pool *pool, void **data,
> > + int count)
> > +{
> > + struct page *page_ring[XDP_BULK_QUEUE_SIZE];
> > + int i, len = 0;
> > +
> > + for (i = 0; i < count; i++) {
> > + struct page *page = virt_to_head_page(data[i]);
> > +
> > + if (unlikely(page_ref_count(page) != 1 ||
> > + !pool_page_reusable(pool, page))) {
> > + page_pool_release_page(pool, page);
> > + put_page(page);
> > + continue;
> > + }
> > +
> > + if (pool->p.flags & PP_FLAG_DMA_SYNC_DEV)
> > + page_pool_dma_sync_for_device(pool, page, -1);
> > +
> > + page_ring[len++] = page;
> > + }
> > +
> > + page_pool_ring_lock(pool);
> > + for (i = 0; i < len; i++) {
> > + if (__ptr_ring_produce(&pool->ring, page_ring[i]))
> > + page_pool_return_page(pool, page_ring[i]);
>
> Can we add a comment here on why the explicit spinlock needs to protect
> page_pool_return_page() as well instead of just using ptr_ring_produce()?
ack, will do in v2.
Regards,
Lorenzo
>
> > + }
> > + page_pool_ring_unlock(pool);
> > +}
> > +EXPORT_SYMBOL(page_pool_put_page_bulk);
> > +
> > static void page_pool_empty_ring(struct page_pool *pool)
> > {
> > struct page *page;
> > diff --git a/net/core/xdp.c b/net/core/xdp.c
> > index 93eabd789246..9f9a8d14df38 100644
> > --- a/net/core/xdp.c
> > +++ b/net/core/xdp.c
> > @@ -383,16 +383,11 @@ EXPORT_SYMBOL_GPL(xdp_return_frame_rx_napi);
> > void xdp_flush_frame_bulk(struct xdp_frame_bulk *bq)
> > {
> > struct xdp_mem_allocator *xa = bq->xa;
> > - int i;
> >
> > - if (unlikely(!xa))
> > + if (unlikely(!xa || !bq->count))
> > return;
> >
> > - for (i = 0; i < bq->count; i++) {
> > - struct page *page = virt_to_head_page(bq->q[i]);
> > -
> > - page_pool_put_full_page(xa->page_pool, page, false);
> > - }
> > + page_pool_put_page_bulk(xa->page_pool, bq->q, bq->count);
> > bq->count = 0;
> > }
> > EXPORT_SYMBOL_GPL(xdp_flush_frame_bulk);
> > --
> > 2.26.2
> >
>
> Thanks
> /Ilias
>
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH net-next 2/4] net: page_pool: add bulk support for ptr_ring
2020-10-27 19:04 ` [PATCH net-next 2/4] net: page_pool: add bulk support for ptr_ring Lorenzo Bianconi
2020-10-29 7:08 ` Ilias Apalodimas
2020-10-29 7:25 ` Ilias Apalodimas
@ 2020-10-29 10:13 ` Jesper Dangaard Brouer
2020-10-29 10:31 ` Lorenzo Bianconi
2 siblings, 1 reply; 23+ messages in thread
From: Jesper Dangaard Brouer @ 2020-10-29 10:13 UTC (permalink / raw)
To: Lorenzo Bianconi
Cc: netdev, bpf, lorenzo.bianconi, davem, kuba, ilias.apalodimas, brouer
On Tue, 27 Oct 2020 20:04:08 +0100
Lorenzo Bianconi <lorenzo@kernel.org> wrote:
> +void page_pool_put_page_bulk(struct page_pool *pool, void **data,
> + int count)
> +{
> + struct page *page_ring[XDP_BULK_QUEUE_SIZE];
Maybe we could reuse the 'data' array instead of creating a new array
(2 cache-lines long) for the array of pages?
> + int i, len = 0;
> +
> + for (i = 0; i < count; i++) {
> + struct page *page = virt_to_head_page(data[i]);
> +
> + if (unlikely(page_ref_count(page) != 1 ||
> + !pool_page_reusable(pool, page))) {
> + page_pool_release_page(pool, page);
> + put_page(page);
> + continue;
> + }
> +
> + if (pool->p.flags & PP_FLAG_DMA_SYNC_DEV)
> + page_pool_dma_sync_for_device(pool, page, -1);
Here we sync the entire DMA area (-1), which have a *huge* cost for
mvneta (especially on EspressoBin HW). For this xdp_frame->len is
unfortunately not enough. We will need the *maximum* length touch by
(1) CPU and (2) remote device DMA engine. DMA-TX completion knows the
length for (2). The CPU length (1) is max of original xdp_buff size
and xdp_frame->len, because BPF-helpers could have shrinked the size.
(tricky part is that xdp_frame->len isn't correct in-case of header
adjustments, thus like mvneta_run_xdp we to calc dma_sync size, and
store this in xdp_frame, maybe via param to xdp_do_redirect). Well, not
sure if it is too much work to transfer this info, for this use-case.
> +
> + page_ring[len++] = page;
> + }
> +
> + page_pool_ring_lock(pool);
> + for (i = 0; i < len; i++) {
> + if (__ptr_ring_produce(&pool->ring, page_ring[i]))
> + page_pool_return_page(pool, page_ring[i]);
> + }
> + page_pool_ring_unlock(pool);
> +}
> +EXPORT_SYMBOL(page_pool_put_page_bulk);
--
Best regards,
Jesper Dangaard Brouer
MSc.CS, Principal Kernel Engineer at Red Hat
LinkedIn: http://www.linkedin.com/in/brouer
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH net-next 2/4] net: page_pool: add bulk support for ptr_ring
2020-10-29 10:13 ` Jesper Dangaard Brouer
@ 2020-10-29 10:31 ` Lorenzo Bianconi
2020-10-29 13:40 ` Jesper Dangaard Brouer
0 siblings, 1 reply; 23+ messages in thread
From: Lorenzo Bianconi @ 2020-10-29 10:31 UTC (permalink / raw)
To: Jesper Dangaard Brouer
Cc: Lorenzo Bianconi, netdev, bpf, davem, kuba, ilias.apalodimas
[-- Attachment #1: Type: text/plain, Size: 2386 bytes --]
> On Tue, 27 Oct 2020 20:04:08 +0100
> Lorenzo Bianconi <lorenzo@kernel.org> wrote:
>
> > +void page_pool_put_page_bulk(struct page_pool *pool, void **data,
> > + int count)
> > +{
> > + struct page *page_ring[XDP_BULK_QUEUE_SIZE];
>
> Maybe we could reuse the 'data' array instead of creating a new array
> (2 cache-lines long) for the array of pages?
I agree, I will try to reuse the data array for that
>
> > + int i, len = 0;
> > +
> > + for (i = 0; i < count; i++) {
> > + struct page *page = virt_to_head_page(data[i]);
> > +
> > + if (unlikely(page_ref_count(page) != 1 ||
> > + !pool_page_reusable(pool, page))) {
> > + page_pool_release_page(pool, page);
> > + put_page(page);
> > + continue;
> > + }
> > +
> > + if (pool->p.flags & PP_FLAG_DMA_SYNC_DEV)
> > + page_pool_dma_sync_for_device(pool, page, -1);
>
> Here we sync the entire DMA area (-1), which have a *huge* cost for
> mvneta (especially on EspressoBin HW). For this xdp_frame->len is
> unfortunately not enough. We will need the *maximum* length touch by
> (1) CPU and (2) remote device DMA engine. DMA-TX completion knows the
> length for (2). The CPU length (1) is max of original xdp_buff size
> and xdp_frame->len, because BPF-helpers could have shrinked the size.
> (tricky part is that xdp_frame->len isn't correct in-case of header
> adjustments, thus like mvneta_run_xdp we to calc dma_sync size, and
> store this in xdp_frame, maybe via param to xdp_do_redirect). Well, not
> sure if it is too much work to transfer this info, for this use-case.
I was thinking about that but I guess point (1) is tricky since "cpu length"
can be changed even in the middle by devmaps or cpumaps (not just in the driver
rx napi loop). I guess we can try to address this point in a subsequent series.
Agree?
Regards,
Lorenzo
>
> > +
> > + page_ring[len++] = page;
>
> > + }
> > +
> > + page_pool_ring_lock(pool);
> > + for (i = 0; i < len; i++) {
> > + if (__ptr_ring_produce(&pool->ring, page_ring[i]))
> > + page_pool_return_page(pool, page_ring[i]);
> > + }
> > + page_pool_ring_unlock(pool);
> > +}
> > +EXPORT_SYMBOL(page_pool_put_page_bulk);
>
>
>
> --
> Best regards,
> Jesper Dangaard Brouer
> MSc.CS, Principal Kernel Engineer at Red Hat
> LinkedIn: http://www.linkedin.com/in/brouer
>
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH net-next 2/4] net: page_pool: add bulk support for ptr_ring
2020-10-29 10:31 ` Lorenzo Bianconi
@ 2020-10-29 13:40 ` Jesper Dangaard Brouer
0 siblings, 0 replies; 23+ messages in thread
From: Jesper Dangaard Brouer @ 2020-10-29 13:40 UTC (permalink / raw)
To: Lorenzo Bianconi
Cc: Lorenzo Bianconi, netdev, bpf, davem, kuba, ilias.apalodimas, brouer
On Thu, 29 Oct 2020 11:31:48 +0100
Lorenzo Bianconi <lorenzo.bianconi@redhat.com> wrote:
> > On Tue, 27 Oct 2020 20:04:08 +0100
> > Lorenzo Bianconi <lorenzo@kernel.org> wrote:
> >
> > > +void page_pool_put_page_bulk(struct page_pool *pool, void **data,
> > > + int count)
> > > +{
> > > + struct page *page_ring[XDP_BULK_QUEUE_SIZE];
> >
> > Maybe we could reuse the 'data' array instead of creating a new array
> > (2 cache-lines long) for the array of pages?
>
> I agree, I will try to reuse the data array for that
>
> >
> > > + int i, len = 0;
> > > +
> > > + for (i = 0; i < count; i++) {
> > > + struct page *page = virt_to_head_page(data[i]);
> > > +
> > > + if (unlikely(page_ref_count(page) != 1 ||
> > > + !pool_page_reusable(pool, page))) {
> > > + page_pool_release_page(pool, page);
> > > + put_page(page);
> > > + continue;
> > > + }
> > > +
> > > + if (pool->p.flags & PP_FLAG_DMA_SYNC_DEV)
> > > + page_pool_dma_sync_for_device(pool, page, -1);
> >
> > Here we sync the entire DMA area (-1), which have a *huge* cost for
> > mvneta (especially on EspressoBin HW). For this xdp_frame->len is
> > unfortunately not enough. We will need the *maximum* length touch by
> > (1) CPU and (2) remote device DMA engine. DMA-TX completion knows the
> > length for (2). The CPU length (1) is max of original xdp_buff size
> > and xdp_frame->len, because BPF-helpers could have shrinked the size.
> > (tricky part is that xdp_frame->len isn't correct in-case of header
> > adjustments, thus like mvneta_run_xdp we to calc dma_sync size, and
> > store this in xdp_frame, maybe via param to xdp_do_redirect). Well, not
> > sure if it is too much work to transfer this info, for this use-case.
>
> I was thinking about that but I guess point (1) is tricky since "cpu length"
> can be changed even in the middle by devmaps or cpumaps (not just in the driver
> rx napi loop). I guess we can try to address this point in a subsequent series.
> Agree?
I agree, that this change request goes beyond this series. But it
becomes harder and harder to add later when this API is getting used in
more and more drivers. Looking at 1/4 is can be extended later, as you
just pass down xdpf in API driver use (and then queue xdpf->data).
--
Best regards,
Jesper Dangaard Brouer
MSc.CS, Principal Kernel Engineer at Red Hat
LinkedIn: http://www.linkedin.com/in/brouer
^ permalink raw reply [flat|nested] 23+ messages in thread
* [PATCH net-next 3/4] net: mvpp2: add xdp tx return bulking support
2020-10-27 19:04 [PATCH net-next 0/4] xdp: introduce bulking for page_pool tx return path Lorenzo Bianconi
2020-10-27 19:04 ` [PATCH net-next 1/4] net: xdp: introduce bulking for xdp " Lorenzo Bianconi
2020-10-27 19:04 ` [PATCH net-next 2/4] net: page_pool: add bulk support for ptr_ring Lorenzo Bianconi
@ 2020-10-27 19:04 ` Lorenzo Bianconi
2020-10-27 19:04 ` [PATCH net-next 4/4] net: mlx5: " Lorenzo Bianconi
3 siblings, 0 replies; 23+ messages in thread
From: Lorenzo Bianconi @ 2020-10-27 19:04 UTC (permalink / raw)
To: netdev; +Cc: bpf, lorenzo.bianconi, davem, kuba, brouer, ilias.apalodimas
Convert mvpp2 driver to xdp_return_frame_bulk APIs.
XDP_REDIRECT (upstream codepath): 1.79Mpps
XDP_REDIRECT (upstream codepath + bulking APIs): 1.93Mpps
Tested-by: Matteo Croce <mcroce@microsoft.com>
Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
---
drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c b/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
index f6616c8933ca..04f24d1d72ab 100644
--- a/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
+++ b/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
@@ -2440,8 +2440,10 @@ static void mvpp2_txq_bufs_free(struct mvpp2_port *port,
struct mvpp2_tx_queue *txq,
struct mvpp2_txq_pcpu *txq_pcpu, int num)
{
+ struct xdp_frame_bulk bq;
int i;
+ bq.xa = NULL;
for (i = 0; i < num; i++) {
struct mvpp2_txq_pcpu_buf *tx_buf =
txq_pcpu->buffs + txq_pcpu->txq_get_index;
@@ -2454,10 +2456,11 @@ static void mvpp2_txq_bufs_free(struct mvpp2_port *port,
dev_kfree_skb_any(tx_buf->skb);
else if (tx_buf->type == MVPP2_TYPE_XDP_TX ||
tx_buf->type == MVPP2_TYPE_XDP_NDO)
- xdp_return_frame(tx_buf->xdpf);
+ xdp_return_frame_bulk(tx_buf->xdpf, &bq);
mvpp2_txq_inc_get(txq_pcpu);
}
+ xdp_flush_frame_bulk(&bq);
}
static inline struct mvpp2_rx_queue *mvpp2_get_rx_queue(struct mvpp2_port *port,
--
2.26.2
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH net-next 4/4] net: mlx5: add xdp tx return bulking support
2020-10-27 19:04 [PATCH net-next 0/4] xdp: introduce bulking for page_pool tx return path Lorenzo Bianconi
` (2 preceding siblings ...)
2020-10-27 19:04 ` [PATCH net-next 3/4] net: mvpp2: add xdp tx return bulking support Lorenzo Bianconi
@ 2020-10-27 19:04 ` Lorenzo Bianconi
2020-10-29 11:42 ` Shay Agroskin
3 siblings, 1 reply; 23+ messages in thread
From: Lorenzo Bianconi @ 2020-10-27 19:04 UTC (permalink / raw)
To: netdev; +Cc: bpf, lorenzo.bianconi, davem, kuba, brouer, ilias.apalodimas
Convert mlx5 driver to xdp_return_frame_bulk APIs.
XDP_REDIRECT (upstream codepath): 8.5Mpps
XDP_REDIRECT (upstream codepath + bulking APIs): 10.1Mpps
Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
---
drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c b/drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c
index ae90d533a350..5fdfbf390d5c 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c
@@ -369,8 +369,10 @@ static void mlx5e_free_xdpsq_desc(struct mlx5e_xdpsq *sq,
bool recycle)
{
struct mlx5e_xdp_info_fifo *xdpi_fifo = &sq->db.xdpi_fifo;
+ struct xdp_frame_bulk bq;
u16 i;
+ bq.xa = NULL;
for (i = 0; i < wi->num_pkts; i++) {
struct mlx5e_xdp_info xdpi = mlx5e_xdpi_fifo_pop(xdpi_fifo);
@@ -379,7 +381,7 @@ static void mlx5e_free_xdpsq_desc(struct mlx5e_xdpsq *sq,
/* XDP_TX from the XSK RQ and XDP_REDIRECT */
dma_unmap_single(sq->pdev, xdpi.frame.dma_addr,
xdpi.frame.xdpf->len, DMA_TO_DEVICE);
- xdp_return_frame(xdpi.frame.xdpf);
+ xdp_return_frame_bulk(xdpi.frame.xdpf, &bq);
break;
case MLX5E_XDP_XMIT_MODE_PAGE:
/* XDP_TX from the regular RQ */
@@ -393,6 +395,7 @@ static void mlx5e_free_xdpsq_desc(struct mlx5e_xdpsq *sq,
WARN_ON_ONCE(true);
}
}
+ xdp_flush_frame_bulk(&bq);
}
bool mlx5e_poll_xdpsq_cq(struct mlx5e_cq *cq)
--
2.26.2
^ permalink raw reply related [flat|nested] 23+ messages in thread* Re: [PATCH net-next 4/4] net: mlx5: add xdp tx return bulking support
2020-10-27 19:04 ` [PATCH net-next 4/4] net: mlx5: " Lorenzo Bianconi
@ 2020-10-29 11:42 ` Shay Agroskin
2020-10-29 13:15 ` Lorenzo Bianconi
0 siblings, 1 reply; 23+ messages in thread
From: Shay Agroskin @ 2020-10-29 11:42 UTC (permalink / raw)
To: Lorenzo Bianconi
Cc: netdev, bpf, lorenzo.bianconi, davem, kuba, brouer, ilias.apalodimas
Lorenzo Bianconi <lorenzo@kernel.org> writes:
> Convert mlx5 driver to xdp_return_frame_bulk APIs.
>
> XDP_REDIRECT (upstream codepath): 8.5Mpps
> XDP_REDIRECT (upstream codepath + bulking APIs): 10.1Mpps
>
> Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
> ---
> drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c | 5 ++++-
> 1 file changed, 4 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c
> b/drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c
> index ae90d533a350..5fdfbf390d5c 100644
> --- a/drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c
> +++ b/drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c
> @@ -369,8 +369,10 @@ static void mlx5e_free_xdpsq_desc(struct
> mlx5e_xdpsq *sq,
> bool recycle)
> {
> struct mlx5e_xdp_info_fifo *xdpi_fifo = &sq->db.xdpi_fifo;
> + struct xdp_frame_bulk bq;
> u16 i;
>
> + bq.xa = NULL;
> for (i = 0; i < wi->num_pkts; i++) {
> struct mlx5e_xdp_info xdpi =
> mlx5e_xdpi_fifo_pop(xdpi_fifo);
>
> @@ -379,7 +381,7 @@ static void mlx5e_free_xdpsq_desc(struct
> mlx5e_xdpsq *sq,
> /* XDP_TX from the XSK RQ and XDP_REDIRECT
> */
> dma_unmap_single(sq->pdev,
> xdpi.frame.dma_addr,
> xdpi.frame.xdpf->len,
> DMA_TO_DEVICE);
> - xdp_return_frame(xdpi.frame.xdpf);
> + xdp_return_frame_bulk(xdpi.frame.xdpf,
> &bq);
> break;
> case MLX5E_XDP_XMIT_MODE_PAGE:
> /* XDP_TX from the regular RQ */
> @@ -393,6 +395,7 @@ static void mlx5e_free_xdpsq_desc(struct
> mlx5e_xdpsq *sq,
> WARN_ON_ONCE(true);
> }
> }
> + xdp_flush_frame_bulk(&bq);
While I understand the rational behind this patchset, using an
intermediate buffer
void *q[XDP_BULK_QUEUE_SIZE];
means more pressure on the data cache.
At the time I ran performance tests on mlx5 to see whether
batching skbs before passing them to GRO would improve
performance. On some flows I got worse performance.
This function seems to have less Dcache contention than RX flow,
but maybe some performance testing are needed here.
> }
>
> bool mlx5e_poll_xdpsq_cq(struct mlx5e_cq *cq)
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH net-next 4/4] net: mlx5: add xdp tx return bulking support
2020-10-29 11:42 ` Shay Agroskin
@ 2020-10-29 13:15 ` Lorenzo Bianconi
0 siblings, 0 replies; 23+ messages in thread
From: Lorenzo Bianconi @ 2020-10-29 13:15 UTC (permalink / raw)
To: Shay Agroskin
Cc: Lorenzo Bianconi, netdev, bpf, davem, kuba, brouer, ilias.apalodimas
[-- Attachment #1: Type: text/plain, Size: 2594 bytes --]
>
> Lorenzo Bianconi <lorenzo@kernel.org> writes:
>
> > Convert mlx5 driver to xdp_return_frame_bulk APIs.
> >
> > XDP_REDIRECT (upstream codepath): 8.5Mpps
> > XDP_REDIRECT (upstream codepath + bulking APIs): 10.1Mpps
> >
> > Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
> > ---
> > drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c | 5 ++++-
> > 1 file changed, 4 insertions(+), 1 deletion(-)
> >
> > diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c
> > b/drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c
> > index ae90d533a350..5fdfbf390d5c 100644
> > --- a/drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c
> > +++ b/drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c
> > @@ -369,8 +369,10 @@ static void mlx5e_free_xdpsq_desc(struct
> > mlx5e_xdpsq *sq,
> > bool recycle)
> > {
> > struct mlx5e_xdp_info_fifo *xdpi_fifo = &sq->db.xdpi_fifo;
> > + struct xdp_frame_bulk bq;
> > u16 i;
> > + bq.xa = NULL;
> > for (i = 0; i < wi->num_pkts; i++) {
> > struct mlx5e_xdp_info xdpi = mlx5e_xdpi_fifo_pop(xdpi_fifo);
> > @@ -379,7 +381,7 @@ static void mlx5e_free_xdpsq_desc(struct
> > mlx5e_xdpsq *sq,
> > /* XDP_TX from the XSK RQ and XDP_REDIRECT */
> > dma_unmap_single(sq->pdev, xdpi.frame.dma_addr,
> > xdpi.frame.xdpf->len, DMA_TO_DEVICE);
> > - xdp_return_frame(xdpi.frame.xdpf);
> > + xdp_return_frame_bulk(xdpi.frame.xdpf, &bq);
> > break;
> > case MLX5E_XDP_XMIT_MODE_PAGE:
> > /* XDP_TX from the regular RQ */
> > @@ -393,6 +395,7 @@ static void mlx5e_free_xdpsq_desc(struct mlx5e_xdpsq
> > *sq,
> > WARN_ON_ONCE(true);
> > }
> > }
> > + xdp_flush_frame_bulk(&bq);
>
> While I understand the rational behind this patchset, using an intermediate
> buffer
> void *q[XDP_BULK_QUEUE_SIZE];
> means more pressure on the data cache.
>
> At the time I ran performance tests on mlx5 to see whether batching skbs
> before passing them to GRO would improve performance. On some flows I got
> worse performance.
> This function seems to have less Dcache contention than RX flow, but maybe
> some performance testing are needed here.
Hi Shay,
this codepath is only activated for "redirected" frames (not for packets
forwarded to networking stack). We run performance comparisons with the
upstream code for this particular use-case and we reported a nice
improvements (8.5Mpps vs 10.1Mpps).
Do you have in mind other possible performance tests to run?
Regards,
Lorenzo
>
> > }
> > bool mlx5e_poll_xdpsq_cq(struct mlx5e_cq *cq)
>
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]
^ permalink raw reply [flat|nested] 23+ messages in thread