io_uring: add napi busy polling support

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 <[email protected]>

Suggested-by Olivier Langlois <[email protected]>

---
  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

include/linux/io_uring_types.h +6 -0

index f5b687a787a3..84b446b0d215 100644
@@ -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

io_uring/io_uring.c +53 -0

index ac8c488e3077..b02bba4ebcbf 100644
@@ -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);
+

io_uring/io_uring.c +15 -0

+	}
+
+	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);
+}
+
+

Quoted 120 lines · 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 <[email protected]>

Suggested-by Olivier Langlois <[email protected]>

---
  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

include/linux/io_uring_types.h +5 -0

index f5b687a787a3..84b446b0d215 100644
@@ -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

io_uring/io_uring.c +52 -0

index ac8c488e3077..b02bba4ebcbf 100644
@@ -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);
+

io_uring/io_uring.c static inline int io_cqring_wait_schedule(struct io_ring_ctx *ctx, · line 2440

Quoted 10 lines

io_uring/io_uring.c +10 -0

+	/* 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.

Quoted 15 lines

io_uring/io_uring.c +15 -0

+	}
+
+	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);
+}
+
+

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.

Quoted 11 lines · 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.

Quoted 2 lines

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.

io_uring/io_uring.c static inline int io_cqring_wait_schedule(struct io_ring_ctx *ctx, · line 2439

Quoted 4 lines

io_uring/io_uring.c +4 -0

+	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.

io_uring/io_uring.c static inline int io_cqring_wait_schedule(struct io_ring_ctx *ctx, · line 2524

Quoted 2 lines

io_uring/io_uring.c +2 -0

+	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.

io_uring/io_uring.c static int io_cqring_wait(struct io_ring_ctx *ctx, int min_events, · line 2653

Quoted 7 lines

io_uring/io_uring.c +5 -0

 		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
	}

Quoted 12 lines · Jakub Kicinski

Quoted 11 lines · 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.

Quoted 5 lines

Quoted 2 lines

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.

Quoted 6 lines

io_uring/io_uring.c static inline int io_cqring_wait_schedule(struct io_ring_ctx *ctx, · line 2524

Quoted 2 lines

io_uring/io_uring.c +2 -0

+	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?