[RFC PATCH v2 0/2] io_uring: add napi busy polling support

[RFC PATCH v2 0/2] io_uring: add napi busy polling support

[Stefan Roesch]

This adds the napi busy polling support in io_uring.c. It adds a new
napi_list to the io_ring_ctx structure. This list contains the list of
napi_id's that are currently enabled for busy polling. This list is
used to determine which napi id's enabled busy polling.

To set the new napi busy poll timeout, a new io-uring api has been
added. It sets the napi busy poll timeout for the corresponding ring.

There is also a corresponding liburing patch series, which enables this
feature. The name of the series is "liburing: add add api for napi busy
poll timeout". It also contains two programs to test the this.

Testing has shown that the round-trip times are reduced to 38us from
55us by enabling napi busy polling with a busy poll timeout of 100us.


Changes:
- v2:
  - Add missing defines if CONFIG_NET_RX_BUSY_POLL is not defined
  - Changes signature of function io_napi_add_list to static inline
    if CONFIG_NET_RX_BUSY_POLL is not defined
  - define some functions as static


Signed-off-by: Stefan Roesch <shr@devkernel.io>


Stefan Roesch (2):
  io_uring: add napi busy polling support
  io_uring: add api to set napi busy poll timeout.

 include/linux/io_uring_types.h |   6 +
 include/uapi/linux/io_uring.h  |   4 +
 io_uring/io_uring.c            | 262 +++++++++++++++++++++++++++++++++
 io_uring/napi.h                |  22 +++
 io_uring/poll.c                |   3 +
 io_uring/sqpoll.c              |   9 ++
 6 files changed, 306 insertions(+)
 create mode 100644 io_uring/napi.h


base-commit: f0c4d9fc9cc9462659728d168387191387e903cc
-- 
2.30.2

[RFC PATCH v2 1/2] io_uring: add napi busy polling support

[Stefan Roesch]

This adds the napi busy polling support in io_uring.c. It adds a new
napi_list to the io_ring_ctx structure. This list contains the list of
napi_id's that are currently enabled for busy polling. The list is
synchronized by the new napi_lock spin lock. The current default napi
busy polling time is stored in napi_busy_poll_to. If napi busy polling
is not enabled, the value is 0.

The busy poll timeout is also stored as part of the io_wait_queue. This
is necessary as for sq polling the poll interval needs to be adjusted
and the napi callback allows only to pass in one value.

Testing has shown that the round-trip times are reduced to 38us from
55us by enabling napi busy polling with a busy poll timeout of 100us.

Signed-off-by: Stefan Roesch <shr@devkernel.io>
Suggested-by: Olivier Langlois <olivier@trillion01.com>
---
 include/linux/io_uring_types.h |   6 +
 io_uring/io_uring.c            | 240 +++++++++++++++++++++++++++++++++
 io_uring/napi.h                |  22 +++
 io_uring/poll.c                |   3 +
 io_uring/sqpoll.c              |   9 ++
 5 files changed, 280 insertions(+)
 create mode 100644 io_uring/napi.h

diff --git a/include/linux/io_uring_types.h b/include/linux/io_uring_types.h
index f5b687a787a3..84b446b0d215 100644
--- a/include/linux/io_uring_types.h
+++ b/include/linux/io_uring_types.h
@@ -270,6 +270,12 @@ struct io_ring_ctx {
 	struct xarray		personalities;
 	u32			pers_next;
 
+#ifdef CONFIG_NET_RX_BUSY_POLL
+	struct list_head	napi_list;	/* track busy poll napi_id */
+	spinlock_t		napi_lock;	/* napi_list lock */
+	unsigned int		napi_busy_poll_to; /* napi busy poll default timeout */
+#endif
+
 	struct {
 		/*
 		 * We cache a range of free CQEs we can use, once exhausted it
diff --git a/io_uring/io_uring.c b/io_uring/io_uring.c
index ac8c488e3077..b02bba4ebcbf 100644
--- a/io_uring/io_uring.c
+++ b/io_uring/io_uring.c
@@ -90,6 +90,7 @@
 #include "rsrc.h"
 #include "cancel.h"
 #include "net.h"
+#include "napi.h"
 #include "notif.h"
 
 #include "timeout.h"
@@ -327,6 +328,13 @@ static __cold struct io_ring_ctx *io_ring_ctx_alloc(struct io_uring_params *p)
 	INIT_WQ_LIST(&ctx->locked_free_list);
 	INIT_DELAYED_WORK(&ctx->fallback_work, io_fallback_req_func);
 	INIT_WQ_LIST(&ctx->submit_state.compl_reqs);
+
+#ifdef CONFIG_NET_RX_BUSY_POLL
+	INIT_LIST_HEAD(&ctx->napi_list);
+	spin_lock_init(&ctx->napi_lock);
+	ctx->napi_busy_poll_to = READ_ONCE(sysctl_net_busy_poll);
+#endif
+
 	return ctx;
 err:
 	kfree(ctx->dummy_ubuf);
@@ -2303,6 +2311,10 @@ struct io_wait_queue {
 	struct io_ring_ctx *ctx;
 	unsigned cq_tail;
 	unsigned nr_timeouts;
+
+#ifdef CONFIG_NET_RX_BUSY_POLL
+	unsigned int busy_poll_to;
+#endif
 };
 
 static inline bool io_has_work(struct io_ring_ctx *ctx)
@@ -2376,6 +2388,198 @@ static inline int io_cqring_wait_schedule(struct io_ring_ctx *ctx,
 	return 1;
 }
 
+#ifdef CONFIG_NET_RX_BUSY_POLL
+#define NAPI_TIMEOUT		(60 * SEC_CONVERSION)
+
+struct io_napi_entry {
+	struct list_head	list;
+	unsigned int		napi_id;
+	unsigned long		timeout;
+};
+
+static bool io_napi_busy_loop_on(struct io_ring_ctx *ctx)
+{
+	return READ_ONCE(ctx->napi_busy_poll_to);
+}
+
+/*
+ * io_napi_add() - Add napi id to the busy poll list
+ * @file: file pointer for socket
+ * @ctx:  io-uring context
+ *
+ * Add the napi id of the socket to the napi busy poll list.
+ */
+void io_napi_add(struct file *file, struct io_ring_ctx *ctx)
+{
+	unsigned int napi_id;
+	struct socket *sock;
+	struct sock *sk;
+	struct io_napi_entry *ne;
+
+	if (!io_napi_busy_loop_on(ctx))
+		return;
+
+	sock = sock_from_file(file);
+	if (!sock)
+		return;
+
+	sk = sock->sk;
+	if (!sk)
+		return;
+
+	napi_id = READ_ONCE(sk->sk_napi_id);
+
+	/* Non-NAPI IDs can be rejected */
+	if (napi_id < MIN_NAPI_ID)
+		return;
+
+	spin_lock(&ctx->napi_lock);
+	list_for_each_entry(ne, &ctx->napi_list, list) {
+		if (ne->napi_id == napi_id) {
+			ne->timeout = jiffies + NAPI_TIMEOUT;
+			goto out;
+		}
+	}
+
+	ne = kmalloc(sizeof(*ne), GFP_NOWAIT);
+	if (!ne)
+		goto out;
+
+	ne->napi_id = napi_id;
+	ne->timeout = jiffies + NAPI_TIMEOUT;
+	list_add_tail(&ne->list, &ctx->napi_list);
+
+out:
+	spin_unlock(&ctx->napi_lock);
+}
+
+static void io_napi_free_list(struct io_ring_ctx *ctx)
+{
+	spin_lock(&ctx->napi_lock);
+	while (!list_empty(&ctx->napi_list)) {
+		struct io_napi_entry *ne =
+			list_first_entry(&ctx->napi_list,
+					struct io_napi_entry, list);
+
+		list_del(&ne->list);
+		kfree(ne);
+	}
+	spin_unlock(&ctx->napi_lock);
+}
+
+static void io_napi_adjust_busy_loop_timeout(unsigned int poll_to,
+					     struct timespec64 *ts,
+					     unsigned int *new_poll_to)
+{
+	struct timespec64 pollto = ns_to_timespec64(1000 * (s64)poll_to);
+
+	if (timespec64_compare(ts, &pollto) > 0) {
+		*ts = timespec64_sub(*ts, pollto);
+		*new_poll_to = poll_to;
+	} else {
+		u64 to = timespec64_to_ns(ts);
+
+		do_div(to, 1000);
+		*new_poll_to = to;
+		ts->tv_sec = 0;
+		ts->tv_nsec = 0;
+	}
+}
+
+static inline bool io_napi_busy_loop_timeout(unsigned long start_time,
+					     unsigned long bp_usec)
+{
+	if (bp_usec) {
+		unsigned long end_time = start_time + bp_usec;
+		unsigned long now = busy_loop_current_time();
+
+		return time_after(now, end_time);
+	}
+	return true;
+}
+
+static inline void io_napi_check_entry_timeout(struct io_napi_entry *ne)
+{
+	if (time_after(jiffies, ne->timeout)) {
+		list_del(&ne->list);
+		kfree(ne);
+	}
+}
+
+/*
+ * io_napi_busy_loop() - napi busy poll loop
+ * @napi_list: list of napi_id's supporting busy polling
+ *
+ * This invokes the napi busy poll loop if sockets have been added to the
+ * napi busy poll list.
+ *
+ * Returns if all napi-id's in the list have been processed.
+ */
+bool io_napi_busy_loop(struct list_head *napi_list)
+{
+	struct io_napi_entry *ne;
+	struct io_napi_entry *n;
+
+	list_for_each_entry_safe(ne, n, napi_list, list) {
+		napi_busy_loop(ne->napi_id, NULL, NULL, true, BUSY_POLL_BUDGET);
+		io_napi_check_entry_timeout(ne);
+	}
+
+	return !list_empty(napi_list);
+}
+
+static bool io_napi_busy_loop_end(void *p, unsigned long start_time)
+{
+	struct io_wait_queue *iowq = p;
+
+	return signal_pending(current) ||
+	       io_should_wake(iowq) ||
+	       io_napi_busy_loop_timeout(start_time, iowq->busy_poll_to);
+}
+
+static void io_napi_blocking_busy_loop(struct list_head *napi_list,
+				       struct io_wait_queue *iowq)
+{
+	unsigned long start_time = list_is_singular(napi_list)
+					? 0
+					: busy_loop_current_time();
+
+	do {
+		if (list_is_singular(napi_list)) {
+			struct io_napi_entry *ne =
+				list_first_entry(napi_list,
+						 struct io_napi_entry, list);
+
+			napi_busy_loop(ne->napi_id, io_napi_busy_loop_end, iowq,
+				       true, BUSY_POLL_BUDGET);
+			io_napi_check_entry_timeout(ne);
+			break;
+		}
+	} while (io_napi_busy_loop(napi_list) &&
+		 !io_napi_busy_loop_end(iowq, start_time));
+}
+
+static void io_napi_putback_list(struct io_ring_ctx *ctx,
+				 struct list_head *napi_list)
+{
+	struct io_napi_entry *cne;
+	struct io_napi_entry *lne;
+
+	spin_lock(&ctx->napi_lock);
+	list_for_each_entry(cne, &ctx->napi_list, list) {
+		list_for_each_entry(lne, napi_list, list) {
+			if (cne->napi_id == lne->napi_id) {
+				list_del(&lne->list);
+				kfree(lne);
+				break;
+			}
+		}
+	}
+	list_splice(napi_list, &ctx->napi_list);
+	spin_unlock(&ctx->napi_lock);
+}
+#endif
+
 /*
  * Wait until events become available, if we don't already have some. The
  * application must reap them itself, as they reside on the shared cq ring.
@@ -2388,6 +2592,9 @@ static int io_cqring_wait(struct io_ring_ctx *ctx, int min_events,
 	struct io_rings *rings = ctx->rings;
 	ktime_t timeout = KTIME_MAX;
 	int ret;
+#ifdef CONFIG_NET_RX_BUSY_POLL
+	LIST_HEAD(local_napi_list);
+#endif
 
 	if (!io_allowed_run_tw(ctx))
 		return -EEXIST;
@@ -2416,13 +2623,34 @@ static int io_cqring_wait(struct io_ring_ctx *ctx, int min_events,
 			return ret;
 	}
 
+#ifdef CONFIG_NET_RX_BUSY_POLL
+	iowq.busy_poll_to = 0;
+	if (!(ctx->flags & IORING_SETUP_SQPOLL)) {
+		spin_lock(&ctx->napi_lock);
+		list_splice_init(&ctx->napi_list, &local_napi_list);
+		spin_unlock(&ctx->napi_lock);
+	}
+#endif
+
 	if (uts) {
 		struct timespec64 ts;
 
 		if (get_timespec64(&ts, uts))
 			return -EFAULT;
+
+#ifdef CONFIG_NET_RX_BUSY_POLL
+		if (!list_empty(&local_napi_list)) {
+			io_napi_adjust_busy_loop_timeout(READ_ONCE(ctx->napi_busy_poll_to),
+						&ts, &iowq.busy_poll_to);
+		}
+#endif
 		timeout = ktime_add_ns(timespec64_to_ktime(ts), ktime_get_ns());
 	}
+#ifdef CONFIG_NET_RX_BUSY_POLL
+	else if (!list_empty(&local_napi_list)) {
+		iowq.busy_poll_to = READ_ONCE(ctx->napi_busy_poll_to);
+	}
+#endif
 
 	init_waitqueue_func_entry(&iowq.wq, io_wake_function);
 	iowq.wq.private = current;
@@ -2432,6 +2660,15 @@ static int io_cqring_wait(struct io_ring_ctx *ctx, int min_events,
 	iowq.cq_tail = READ_ONCE(ctx->rings->cq.head) + min_events;
 
 	trace_io_uring_cqring_wait(ctx, min_events);
+
+#ifdef CONFIG_NET_RX_BUSY_POLL
+	if (iowq.busy_poll_to)
+		io_napi_blocking_busy_loop(&local_napi_list, &iowq);
+
+	if (!list_empty(&local_napi_list))
+		io_napi_putback_list(ctx, &local_napi_list);
+#endif
+
 	do {
 		/* if we can't even flush overflow, don't wait for more */
 		if (!io_cqring_overflow_flush(ctx)) {
@@ -2631,6 +2868,9 @@ static __cold void io_ring_ctx_free(struct io_ring_ctx *ctx)
 	io_req_caches_free(ctx);
 	if (ctx->hash_map)
 		io_wq_put_hash(ctx->hash_map);
+#ifdef CONFIG_NET_RX_BUSY_POLL
+	io_napi_free_list(ctx);
+#endif
 	kfree(ctx->cancel_table.hbs);
 	kfree(ctx->cancel_table_locked.hbs);
 	kfree(ctx->dummy_ubuf);
diff --git a/io_uring/napi.h b/io_uring/napi.h
new file mode 100644
index 000000000000..81ebaff07c68
--- /dev/null
+++ b/io_uring/napi.h
@@ -0,0 +1,22 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+#ifndef IOU_NAPI_H
+#define IOU_NAPI_H
+
+#include <linux/kernel.h>
+#include <linux/io_uring.h>
+#include <net/busy_poll.h>
+
+#ifdef CONFIG_NET_RX_BUSY_POLL
+
+void io_napi_add(struct file *file, struct io_ring_ctx *ctx);
+bool io_napi_busy_loop(struct list_head *napi_list);
+
+#else
+
+static inline void io_napi_add(struct file *file, struct io_ring_ctx *ctx)
+{
+}
+
+#endif
+#endif
diff --git a/io_uring/poll.c b/io_uring/poll.c
index 0d9f49c575e0..38ed9f254075 100644
--- a/io_uring/poll.c
+++ b/io_uring/poll.c
@@ -15,6 +15,7 @@
 
 #include "io_uring.h"
 #include "refs.h"
+#include "napi.h"
 #include "opdef.h"
 #include "kbuf.h"
 #include "poll.h"
@@ -248,6 +249,7 @@ static int io_poll_check_events(struct io_kiocb *req, bool *locked)
 				io_req_set_res(req, mask, 0);
 				return IOU_POLL_REMOVE_POLL_USE_RES;
 			}
+			io_napi_add(req->file, ctx);
 		} else {
 			ret = io_poll_issue(req, locked);
 			if (ret == IOU_STOP_MULTISHOT)
@@ -564,6 +566,7 @@ static int __io_arm_poll_handler(struct io_kiocb *req,
 		__io_poll_execute(req, mask);
 		return 0;
 	}
+	io_napi_add(req->file, req->ctx);
 
 	if (ipt->owning) {
 		/*
diff --git a/io_uring/sqpoll.c b/io_uring/sqpoll.c
index 559652380672..8c0a1c09a9a6 100644
--- a/io_uring/sqpoll.c
+++ b/io_uring/sqpoll.c
@@ -15,6 +15,7 @@
 #include <uapi/linux/io_uring.h>
 
 #include "io_uring.h"
+#include "napi.h"
 #include "sqpoll.h"
 
 #define IORING_SQPOLL_CAP_ENTRIES_VALUE 8
@@ -193,6 +194,14 @@ static int __io_sq_thread(struct io_ring_ctx *ctx, bool cap_entries)
 			ret = io_submit_sqes(ctx, to_submit);
 		mutex_unlock(&ctx->uring_lock);
 
+#ifdef CONFIG_NET_RX_BUSY_POLL
+		spin_lock(&ctx->napi_lock);
+		if (!list_empty(&ctx->napi_list) &&
+		    io_napi_busy_loop(&ctx->napi_list))
+			++ret;
+		spin_unlock(&ctx->napi_lock);
+#endif
+
 		if (to_submit && wq_has_sleeper(&ctx->sqo_sq_wait))
 			wake_up(&ctx->sqo_sq_wait);
 		if (creds)
-- 
2.30.2

Re: [RFC PATCH v2 1/2] io_uring: add napi busy polling support

[Eric Dumazet]

On 11/7/22 09:52, Stefan Roesch wrote:
> This adds the napi busy polling support in io_uring.c. It adds a new
> napi_list to the io_ring_ctx structure. This list contains the list of
> napi_id's that are currently enabled for busy polling. The list is
> synchronized by the new napi_lock spin lock. The current default napi
> busy polling time is stored in napi_busy_poll_to. If napi busy polling
> is not enabled, the value is 0.
>
> The busy poll timeout is also stored as part of the io_wait_queue. This
> is necessary as for sq polling the poll interval needs to be adjusted
> and the napi callback allows only to pass in one value.
>
> Testing has shown that the round-trip times are reduced to 38us from
> 55us by enabling napi busy polling with a busy poll timeout of 100us.
>
> Signed-off-by: Stefan Roesch <shr@devkernel.io>
> Suggested-by: Olivier Langlois <olivier@trillion01.com>
> ---
>   include/linux/io_uring_types.h |   6 +
>   io_uring/io_uring.c            | 240 +++++++++++++++++++++++++++++++++
>   io_uring/napi.h                |  22 +++
>   io_uring/poll.c                |   3 +
>   io_uring/sqpoll.c              |   9 ++
>   5 files changed, 280 insertions(+)
>   create mode 100644 io_uring/napi.h
>
> diff --git a/include/linux/io_uring_types.h b/include/linux/io_uring_types.h
> index f5b687a787a3..84b446b0d215 100644
> --- a/include/linux/io_uring_types.h
> +++ b/include/linux/io_uring_types.h
> @@ -270,6 +270,12 @@ struct io_ring_ctx {
>   	struct xarray		personalities;
>   	u32			pers_next;
>   
> +#ifdef CONFIG_NET_RX_BUSY_POLL
> +	struct list_head	napi_list;	/* track busy poll napi_id */
> +	spinlock_t		napi_lock;	/* napi_list lock */
> +	unsigned int		napi_busy_poll_to; /* napi busy poll default timeout */
> +#endif
> +
>   	struct {
>   		/*
>   		 * We cache a range of free CQEs we can use, once exhausted it
> diff --git a/io_uring/io_uring.c b/io_uring/io_uring.c
> index ac8c488e3077..b02bba4ebcbf 100644
> --- a/io_uring/io_uring.c
> +++ b/io_uring/io_uring.c
> @@ -90,6 +90,7 @@
>   #include "rsrc.h"
>   #include "cancel.h"
>   #include "net.h"
> +#include "napi.h"
>   #include "notif.h"
>   
>   #include "timeout.h"
> @@ -327,6 +328,13 @@ static __cold struct io_ring_ctx *io_ring_ctx_alloc(struct io_uring_params *p)
>   	INIT_WQ_LIST(&ctx->locked_free_list);
>   	INIT_DELAYED_WORK(&ctx->fallback_work, io_fallback_req_func);
>   	INIT_WQ_LIST(&ctx->submit_state.compl_reqs);
> +
> +#ifdef CONFIG_NET_RX_BUSY_POLL
> +	INIT_LIST_HEAD(&ctx->napi_list);
> +	spin_lock_init(&ctx->napi_lock);
> +	ctx->napi_busy_poll_to = READ_ONCE(sysctl_net_busy_poll);
> +#endif
> +
>   	return ctx;
>   err:
>   	kfree(ctx->dummy_ubuf);
> @@ -2303,6 +2311,10 @@ struct io_wait_queue {
>   	struct io_ring_ctx *ctx;
>   	unsigned cq_tail;
>   	unsigned nr_timeouts;
> +
> +#ifdef CONFIG_NET_RX_BUSY_POLL
> +	unsigned int busy_poll_to;
> +#endif
>   };
>   
>   static inline bool io_has_work(struct io_ring_ctx *ctx)
> @@ -2376,6 +2388,198 @@ static inline int io_cqring_wait_schedule(struct io_ring_ctx *ctx,
>   	return 1;
>   }
>   
> +#ifdef CONFIG_NET_RX_BUSY_POLL
> +#define NAPI_TIMEOUT		(60 * SEC_CONVERSION)
> +
> +struct io_napi_entry {
> +	struct list_head	list;
> +	unsigned int		napi_id;
> +	unsigned long		timeout;
> +};
> +
> +static bool io_napi_busy_loop_on(struct io_ring_ctx *ctx)
> +{
> +	return READ_ONCE(ctx->napi_busy_poll_to);
> +}
> +
> +/*
> + * io_napi_add() - Add napi id to the busy poll list
> + * @file: file pointer for socket
> + * @ctx:  io-uring context
> + *
> + * Add the napi id of the socket to the napi busy poll list.
> + */
> +void io_napi_add(struct file *file, struct io_ring_ctx *ctx)
> +{
> +	unsigned int napi_id;
> +	struct socket *sock;
> +	struct sock *sk;
> +	struct io_napi_entry *ne;
> +
> +	if (!io_napi_busy_loop_on(ctx))
> +		return;
> +
> +	sock = sock_from_file(file);
> +	if (!sock)
> +		return;
> +
> +	sk = sock->sk;
> +	if (!sk)
> +		return;
> +
> +	napi_id = READ_ONCE(sk->sk_napi_id);
> +
> +	/* Non-NAPI IDs can be rejected */
> +	if (napi_id < MIN_NAPI_ID)
> +		return;
> +
> +	spin_lock(&ctx->napi_lock);
> +	list_for_each_entry(ne, &ctx->napi_list, list) {
> +		if (ne->napi_id == napi_id) {
> +			ne->timeout = jiffies + NAPI_TIMEOUT;
> +			goto out;
> +		}

This list could become very big, if you do not remove stale napi_id from it.

Device reconfiguration do not recycle napi_id, it creates new ones.


> +	}
> +
> +	ne = kmalloc(sizeof(*ne), GFP_NOWAIT);
> +	if (!ne)
> +		goto out;
> +
> +	ne->napi_id = napi_id;
> +	ne->timeout = jiffies + NAPI_TIMEOUT;
> +	list_add_tail(&ne->list, &ctx->napi_list);
> +
> +out:
> +	spin_unlock(&ctx->napi_lock);
> +}
> +
> +

Re: [RFC PATCH v2 1/2] io_uring: add napi busy polling support

[Stefan Roesch]

Eric Dumazet <eric.dumazet@gmail.com> writes:

> On 11/7/22 09:52, Stefan Roesch wrote:
>> This adds the napi busy polling support in io_uring.c. It adds a new
>> napi_list to the io_ring_ctx structure. This list contains the list of
>> napi_id's that are currently enabled for busy polling. The list is
>> synchronized by the new napi_lock spin lock. The current default napi
>> busy polling time is stored in napi_busy_poll_to. If napi busy polling
>> is not enabled, the value is 0.
>>
>> The busy poll timeout is also stored as part of the io_wait_queue. This
>> is necessary as for sq polling the poll interval needs to be adjusted
>> and the napi callback allows only to pass in one value.
>>
>> Testing has shown that the round-trip times are reduced to 38us from
>> 55us by enabling napi busy polling with a busy poll timeout of 100us.
>>
>> Signed-off-by: Stefan Roesch <shr@devkernel.io>
>> Suggested-by: Olivier Langlois <olivier@trillion01.com>
>> ---
>>   include/linux/io_uring_types.h |   6 +
>>   io_uring/io_uring.c            | 240 +++++++++++++++++++++++++++++++++
>>   io_uring/napi.h                |  22 +++
>>   io_uring/poll.c                |   3 +
>>   io_uring/sqpoll.c              |   9 ++
>>   5 files changed, 280 insertions(+)
>>   create mode 100644 io_uring/napi.h
>>
>> diff --git a/include/linux/io_uring_types.h b/include/linux/io_uring_types.h
>> index f5b687a787a3..84b446b0d215 100644
>> --- a/include/linux/io_uring_types.h
>> +++ b/include/linux/io_uring_types.h
>> @@ -270,6 +270,12 @@ struct io_ring_ctx {
>>   	struct xarray		personalities;
>>   	u32			pers_next;
>>   +#ifdef CONFIG_NET_RX_BUSY_POLL
>> +	struct list_head	napi_list;	/* track busy poll napi_id */
>> +	spinlock_t		napi_lock;	/* napi_list lock */
>> +	unsigned int		napi_busy_poll_to; /* napi busy poll default timeout */
>> +#endif
>> +
>>   	struct {
>>   		/*
>>   		 * We cache a range of free CQEs we can use, once exhausted it
>> diff --git a/io_uring/io_uring.c b/io_uring/io_uring.c
>> index ac8c488e3077..b02bba4ebcbf 100644
>> --- a/io_uring/io_uring.c
>> +++ b/io_uring/io_uring.c
>> @@ -90,6 +90,7 @@
>>   #include "rsrc.h"
>>   #include "cancel.h"
>>   #include "net.h"
>> +#include "napi.h"
>>   #include "notif.h"
>>     #include "timeout.h"
>> @@ -327,6 +328,13 @@ static __cold struct io_ring_ctx *io_ring_ctx_alloc(struct io_uring_params *p)
>>   	INIT_WQ_LIST(&ctx->locked_free_list);
>>   	INIT_DELAYED_WORK(&ctx->fallback_work, io_fallback_req_func);
>>   	INIT_WQ_LIST(&ctx->submit_state.compl_reqs);
>> +
>> +#ifdef CONFIG_NET_RX_BUSY_POLL
>> +	INIT_LIST_HEAD(&ctx->napi_list);
>> +	spin_lock_init(&ctx->napi_lock);
>> +	ctx->napi_busy_poll_to = READ_ONCE(sysctl_net_busy_poll);
>> +#endif
>> +
>>   	return ctx;
>>   err:
>>   	kfree(ctx->dummy_ubuf);
>> @@ -2303,6 +2311,10 @@ struct io_wait_queue {
>>   	struct io_ring_ctx *ctx;
>>   	unsigned cq_tail;
>>   	unsigned nr_timeouts;
>> +
>> +#ifdef CONFIG_NET_RX_BUSY_POLL
>> +	unsigned int busy_poll_to;
>> +#endif
>>   };
>>     static inline bool io_has_work(struct io_ring_ctx *ctx)
>> @@ -2376,6 +2388,198 @@ static inline int io_cqring_wait_schedule(struct io_ring_ctx *ctx,
>>   	return 1;
>>   }
>>   +#ifdef CONFIG_NET_RX_BUSY_POLL
>> +#define NAPI_TIMEOUT		(60 * SEC_CONVERSION)
>> +
>> +struct io_napi_entry {
>> +	struct list_head	list;
>> +	unsigned int		napi_id;
>> +	unsigned long		timeout;
>> +};
>> +
>> +static bool io_napi_busy_loop_on(struct io_ring_ctx *ctx)
>> +{
>> +	return READ_ONCE(ctx->napi_busy_poll_to);
>> +}
>> +
>> +/*
>> + * io_napi_add() - Add napi id to the busy poll list
>> + * @file: file pointer for socket
>> + * @ctx:  io-uring context
>> + *
>> + * Add the napi id of the socket to the napi busy poll list.
>> + */
>> +void io_napi_add(struct file *file, struct io_ring_ctx *ctx)
>> +{
>> +	unsigned int napi_id;
>> +	struct socket *sock;
>> +	struct sock *sk;
>> +	struct io_napi_entry *ne;
>> +
>> +	if (!io_napi_busy_loop_on(ctx))
>> +		return;
>> +
>> +	sock = sock_from_file(file);
>> +	if (!sock)
>> +		return;
>> +
>> +	sk = sock->sk;
>> +	if (!sk)
>> +		return;
>> +
>> +	napi_id = READ_ONCE(sk->sk_napi_id);
>> +
>> +	/* Non-NAPI IDs can be rejected */
>> +	if (napi_id < MIN_NAPI_ID)
>> +		return;
>> +
>> +	spin_lock(&ctx->napi_lock);
>> +	list_for_each_entry(ne, &ctx->napi_list, list) {
>> +		if (ne->napi_id == napi_id) {
>> +			ne->timeout = jiffies + NAPI_TIMEOUT;
>> +			goto out;
>> +		}
>
> This list could become very big, if you do not remove stale napi_id from it.
>
> Device reconfiguration do not recycle napi_id, it creates new ones.
>
>

The timeout is specified by NAPI_TIMEOUT (which is likely too high). The
timeout of an entry is checked in io_napi_check_entry_timeout and might
get deleted if the timeout expired. This function is called from the
busy loop functions.

Are you referring to the fact that the timeout is too high or that device
reconfiguration needs to make changes to the napi list.

>> +	}
>> +
>> +	ne = kmalloc(sizeof(*ne), GFP_NOWAIT);
>> +	if (!ne)
>> +		goto out;
>> +
>> +	ne->napi_id = napi_id;
>> +	ne->timeout = jiffies + NAPI_TIMEOUT;
>> +	list_add_tail(&ne->list, &ctx->napi_list);
>> +
>> +out:
>> +	spin_unlock(&ctx->napi_lock);
>> +}
>> +
>> +

Re: [RFC PATCH v2 1/2] io_uring: add napi busy polling support

[Jakub Kicinski]

On Mon,  7 Nov 2022 09:52:39 -0800 Stefan Roesch wrote:
> This adds the napi busy polling support in io_uring.c. It adds a new
> napi_list to the io_ring_ctx structure. This list contains the list of
> napi_id's that are currently enabled for busy polling. The list is
> synchronized by the new napi_lock spin lock. The current default napi
> busy polling time is stored in napi_busy_poll_to. If napi busy polling
> is not enabled, the value is 0.
> 
> The busy poll timeout is also stored as part of the io_wait_queue. This
> is necessary as for sq polling the poll interval needs to be adjusted
> and the napi callback allows only to pass in one value.
> 
> Testing has shown that the round-trip times are reduced to 38us from
> 55us by enabling napi busy polling with a busy poll timeout of 100us.

What's the test, exactly? What's the network latency? Did you busy poll
on both ends?

I reckon we should either find a real application or not include any
numbers. Most of the quoted win likely comes from skipping IRQ
coalescing. Which can just be set lowered if latency of 30usec is 
a win in itself..

Would it be possible to try to integrate this with Jonathan's WIP
zero-copy work? I presume he has explicit NAPI/queue <> io_uring
instance mapping which is exactly the kind of use case we should 
make a first-class citizen here.

> +	spin_lock(&ctx->napi_lock);
> +	list_for_each_entry(ne, &ctx->napi_list, list) {
> +		if (ne->napi_id == napi_id) {
> +			ne->timeout = jiffies + NAPI_TIMEOUT;

What's the NAPI_TIMEOUT thing? I don't see it mentioned in 
the commit msg.

> +	list_for_each_entry_safe(ne, n, napi_list, list) {
> +		napi_busy_loop(ne->napi_id, NULL, NULL, true, BUSY_POLL_BUDGET);

You can't opt the user into prefer busy poll without the user asking
for it. Default to false and add an explicit knob like patch 2.

>  		timeout = ktime_add_ns(timespec64_to_ktime(ts), ktime_get_ns());
>  	}
> +#ifdef CONFIG_NET_RX_BUSY_POLL
> +	else if (!list_empty(&local_napi_list)) {
> +		iowq.busy_poll_to = READ_ONCE(ctx->napi_busy_poll_to);
> +	}
> +#endif

You don't have to break the normal bracket placement for an ifdef:

	if (something) {
		boring_code();

#ifdef CONFIG_WANT_CHEESE
	} else if (is_gouda) {
		/* mmm */
		nom_nom();
#endif
	}

Re: [RFC PATCH v2 1/2] io_uring: add napi busy polling support

[Stefan Roesch]

Jakub Kicinski <kuba@kernel.org> writes:

> On Mon,  7 Nov 2022 09:52:39 -0800 Stefan Roesch wrote:
>> This adds the napi busy polling support in io_uring.c. It adds a new
>> napi_list to the io_ring_ctx structure. This list contains the list of
>> napi_id's that are currently enabled for busy polling. The list is
>> synchronized by the new napi_lock spin lock. The current default napi
>> busy polling time is stored in napi_busy_poll_to. If napi busy polling
>> is not enabled, the value is 0.
>>
>> The busy poll timeout is also stored as part of the io_wait_queue. This
>> is necessary as for sq polling the poll interval needs to be adjusted
>> and the napi callback allows only to pass in one value.
>>
>> Testing has shown that the round-trip times are reduced to 38us from
>> 55us by enabling napi busy polling with a busy poll timeout of 100us.
>
> What's the test, exactly? What's the network latency? Did you busy poll
> on both ends?
>

The test programs are part of the liburing patches. They consist of a
client and server program. The client sends a request, which has a timestamp
in its payload and the server replies with the same payload. The client
calculates the roundtrip time and stores it to calcualte the results.

The client is running on host1 and the server is running on host 2. The
measured times below are roundtrip times. These are average times over
10 runs each.

If no napi busy polling wait is used                 : 55us
If napi with client busy polling is used             : 44us
If napi busy polling is used on the client and server: 38us

If you think the numbers are not that useful, I can remove them from the
commit message.

> I reckon we should either find a real application or not include any
> numbers. Most of the quoted win likely comes from skipping IRQ
> coalescing. Which can just be set lowered if latency of 30usec is
> a win in itself..
>
> Would it be possible to try to integrate this with Jonathan's WIP
> zero-copy work? I presume he has explicit NAPI/queue <> io_uring
> instance mapping which is exactly the kind of use case we should
> make a first-class citizen here.
>

I'll have a look at Jonathan's patches.

>> +	spin_lock(&ctx->napi_lock);
>> +	list_for_each_entry(ne, &ctx->napi_list, list) {
>> +		if (ne->napi_id == napi_id) {
>> +			ne->timeout = jiffies + NAPI_TIMEOUT;
>
> What's the NAPI_TIMEOUT thing? I don't see it mentioned in
> the commit msg.
>

To make sure that the napi id's are cleaned up, they have a timeout. The
function io_napi_check_entry_timeout checks if the timeout expired. This
has been added to make sure the list does not grow without bound.

>> +	list_for_each_entry_safe(ne, n, napi_list, list) {
>> +		napi_busy_loop(ne->napi_id, NULL, NULL, true, BUSY_POLL_BUDGET);
>
> You can't opt the user into prefer busy poll without the user asking
> for it. Default to false and add an explicit knob like patch 2.
>

The above code is from the function io_napi_blocking_busy_loop().
However this function is only called when a busy poll timeout has been
configured.

#ifdef CONFIG_NET_RX_BUSY_POLL
         if (iowq.busy_poll_to)
                 io_napi_blocking_busy_loop(&local_napi_list, &iowq);

However we don't have that check for sqpoll, so we should add a check
for the napi busy poll timeout in __io_sq_thread.

Do we really need a knob to store if napi busy polling is enabled or is
sufficent to store a napi busy poll timeout value?

>>  		timeout = ktime_add_ns(timespec64_to_ktime(ts), ktime_get_ns());
>>  	}
>> +#ifdef CONFIG_NET_RX_BUSY_POLL
>> +	else if (!list_empty(&local_napi_list)) {
>> +		iowq.busy_poll_to = READ_ONCE(ctx->napi_busy_poll_to);
>> +	}
>> +#endif
>
> You don't have to break the normal bracket placement for an ifdef:
>
> 	if (something) {
> 		boring_code();
>
> #ifdef CONFIG_WANT_CHEESE
> 	} else if (is_gouda) {
> 		/* mmm */
> 		nom_nom();
> #endif
> 	}

I'll fix the above with the next version of the patch.
'

Re: [RFC PATCH v2 1/2] io_uring: add napi busy polling support

[Jakub Kicinski]

On Thu, 10 Nov 2022 15:36:34 -0800 Stefan Roesch wrote:
> Jakub Kicinski <kuba@kernel.org> writes:
> > On Mon,  7 Nov 2022 09:52:39 -0800 Stefan Roesch wrote:  
> >> This adds the napi busy polling support in io_uring.c. It adds a new
> >> napi_list to the io_ring_ctx structure. This list contains the list of
> >> napi_id's that are currently enabled for busy polling. The list is
> >> synchronized by the new napi_lock spin lock. The current default napi
> >> busy polling time is stored in napi_busy_poll_to. If napi busy polling
> >> is not enabled, the value is 0.
> >>
> >> The busy poll timeout is also stored as part of the io_wait_queue. This
> >> is necessary as for sq polling the poll interval needs to be adjusted
> >> and the napi callback allows only to pass in one value.
> >>
> >> Testing has shown that the round-trip times are reduced to 38us from
> >> 55us by enabling napi busy polling with a busy poll timeout of 100us.  
> >
> > What's the test, exactly? What's the network latency? Did you busy poll
> > on both ends?
> 
> The test programs are part of the liburing patches. They consist of a
> client and server program. The client sends a request, which has a timestamp
> in its payload and the server replies with the same payload. The client
> calculates the roundtrip time and stores it to calcualte the results.
> 
> The client is running on host1 and the server is running on host 2. The
> measured times below are roundtrip times. These are average times over
> 10 runs each.
> 
> If no napi busy polling wait is used                 : 55us
> If napi with client busy polling is used             : 44us
> If napi busy polling is used on the client and server: 38us
> 
> If you think the numbers are not that useful, I can remove them from the
> commit message.

The latency numbers are a sum of a few components so you'd need to break
them down a little further. At least for me. I'd anticipate we'll have
networking delay, IRQ/completion coalescing in the NIC, and then SW
processing time. 

I was suspecting you were only busy polling on one end, because the
38us is very close to the default IRQ coalescing "we" have (33us).

Simplest way to provide a clear number would be to test with IRQ coal
set to 0/1, and back-to-back machines (or within a rack).
If that's what you did then just add the info to the msg and the
numbers are good :)

> >> +	list_for_each_entry_safe(ne, n, napi_list, list) {
> >> +		napi_busy_loop(ne->napi_id, NULL, NULL, true, BUSY_POLL_BUDGET);  
> >
> > You can't opt the user into prefer busy poll without the user asking
> > for it. Default to false and add an explicit knob like patch 2.
> >  
> 
> The above code is from the function io_napi_blocking_busy_loop().
> However this function is only called when a busy poll timeout has been
> configured.
> 
> #ifdef CONFIG_NET_RX_BUSY_POLL
>          if (iowq.busy_poll_to)
>                  io_napi_blocking_busy_loop(&local_napi_list, &iowq);
> 
> However we don't have that check for sqpoll, so we should add a check
> for the napi busy poll timeout in __io_sq_thread.
> 
> Do we really need a knob to store if napi busy polling is enabled or is
> sufficent to store a napi busy poll timeout value?

I was asking about *prefer* busy poll, IOW SO_PREFER_BUSY_POLL.
So I'm talking about argument 4 being set to true. 
This feature requires system configuration to arm timers to the correct
values within the netdev code. Normal epoll path always passes false
there, IIRC. We can add the support in iouring but we need an opt-in.

[RFC PATCH v2 2/2] io_uring: add api to set napi busy poll timeout.

[Stefan Roesch]

This adds an api to register and unregister the busy poll timeout from
liburing. To be able to use this functionality, the corresponding
liburing patch is needed.

Signed-off-by: Stefan Roesch <shr@devkernel.io>
---
 include/uapi/linux/io_uring.h |  4 ++++
 io_uring/io_uring.c           | 22 ++++++++++++++++++++++
 2 files changed, 26 insertions(+)

diff --git a/include/uapi/linux/io_uring.h b/include/uapi/linux/io_uring.h
index ab7458033ee3..48670074e1fc 100644
--- a/include/uapi/linux/io_uring.h
+++ b/include/uapi/linux/io_uring.h
@@ -490,6 +490,10 @@ enum {
 	/* register a range of fixed file slots for automatic slot allocation */
 	IORING_REGISTER_FILE_ALLOC_RANGE	= 25,
 
+	/* set/clear busy poll timeout */
+	IORING_REGISTER_NAPI_BUSY_POLL_TIMEOUT	= 26,
+	IORING_UNREGISTER_NAPI_BUSY_POLL_TIMEOUT= 27,
+
 	/* this goes last */
 	IORING_REGISTER_LAST
 };
diff --git a/io_uring/io_uring.c b/io_uring/io_uring.c
index b02bba4ebcbf..b685af668641 100644
--- a/io_uring/io_uring.c
+++ b/io_uring/io_uring.c
@@ -4111,6 +4111,16 @@ static __cold int io_register_iowq_max_workers(struct io_ring_ctx *ctx,
 	return ret;
 }
 
+static int io_register_napi_busy_poll_timeout(struct io_ring_ctx *ctx, unsigned int to)
+{
+#ifdef CONFIG_NET_RX_BUSY_POLL
+	WRITE_ONCE(ctx->napi_busy_poll_to, to);
+	return 0;
+#else
+	return -EINVAL;
+#endif
+}
+
 static int __io_uring_register(struct io_ring_ctx *ctx, unsigned opcode,
 			       void __user *arg, unsigned nr_args)
 	__releases(ctx->uring_lock)
@@ -4271,6 +4281,18 @@ static int __io_uring_register(struct io_ring_ctx *ctx, unsigned opcode,
 			break;
 		ret = io_register_file_alloc_range(ctx, arg);
 		break;
+	case IORING_REGISTER_NAPI_BUSY_POLL_TIMEOUT:
+		ret = -EINVAL;
+		if (arg || !nr_args)
+			break;
+		ret = io_register_napi_busy_poll_timeout(ctx, nr_args);
+		break;
+	case IORING_UNREGISTER_NAPI_BUSY_POLL_TIMEOUT:
+		ret = -EINVAL;
+		if (arg || nr_args)
+			break;
+		ret = io_register_napi_busy_poll_timeout(ctx, nr_args);
+		break;
 	default:
 		ret = -EINVAL;
 		break;
-- 
2.30.2