[2/3] xsk: change the tx writeable condition

Modify the tx writeable condition from the queue is not full to the
number of remaining tx queues is less than the half of the total number
of queues. Because the tx queue not full is a very short time, this will
cause a large number of EPOLLOUT events, and cause a large number of
process wake up.

Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
---
 net/xdp/xsk.c       | 20 +++++++++++++++++---
 net/xdp/xsk_queue.h |  6 ++++++
 2 files changed, 23 insertions(+), 3 deletions(-)

On Wed, Nov 18, 2020 at 9:25 AM Xuan Zhuo <xuanzhuo@linux.alibaba.com> wrote:
>

> Modify the tx writeable condition from the queue is not full to the

> number of remaining tx queues is less than the half of the total number

> of queues. Because the tx queue not full is a very short time, this will

> cause a large number of EPOLLOUT events, and cause a large number of

> process wake up.

>

> Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>

> ---

>  net/xdp/xsk.c       | 20 +++++++++++++++++---

>  net/xdp/xsk_queue.h |  6 ++++++

>  2 files changed, 23 insertions(+), 3 deletions(-)

>

> diff --git a/net/xdp/xsk.c b/net/xdp/xsk.c

> index 7f0353e..bc3d4ece 100644

> --- a/net/xdp/xsk.c

> +++ b/net/xdp/xsk.c

> @@ -211,6 +211,17 @@ static int __xsk_rcv(struct xdp_sock *xs, struct xdp_buff *xdp, u32 len,

>         return 0;

>  }

>

> +static bool xsk_writeable(struct xdp_sock *xs)


Not clear what this function does from the name. How about
xsk_tx_half_free() or maybe xsk_tx_writeable()?

> +{

> +       if (!xs->tx)

> +               return false;


Skip this test as it will slow down the code. It is only needed in one
place below.

> +       if (xskq_cons_left(xs->tx) > xs->tx->nentries / 2)

> +               return false;

> +

> +       return true;

> +}

> +

>  static bool xsk_is_bound(struct xdp_sock *xs)

>  {

>         if (READ_ONCE(xs->state) == XSK_BOUND) {

> @@ -296,7 +307,8 @@ void xsk_tx_release(struct xsk_buff_pool *pool)

>         rcu_read_lock();

>         list_for_each_entry_rcu(xs, &pool->xsk_tx_list, tx_list) {

>                 __xskq_cons_release(xs->tx);

> -               xs->sk.sk_write_space(&xs->sk);

> +               if (xsk_writeable(xs))

> +                       xs->sk.sk_write_space(&xs->sk);

>         }

>         rcu_read_unlock();

>  }

> @@ -442,7 +454,8 @@ static int xsk_generic_xmit(struct sock *sk)

>

>  out:

>         if (sent_frame)

> -               sk->sk_write_space(sk);

> +               if (xsk_writeable(xs))

> +                       sk->sk_write_space(sk);

>

>         mutex_unlock(&xs->mutex);

>         return err;

> @@ -499,7 +512,8 @@ static __poll_t xsk_poll(struct file *file, struct socket *sock,

>

>         if (xs->rx && !xskq_prod_is_empty(xs->rx))

>                 mask |= EPOLLIN | EPOLLRDNORM;

> -       if (xs->tx && !xskq_cons_is_full(xs->tx))

> +


No reason to introduce a newline here.

> +       if (xsk_writeable(xs))


Add an explicit "xs->tx &&" in the if statement here as we removed the
test in xsk_writeable.

>                 mask |= EPOLLOUT | EPOLLWRNORM;

>

>         return mask;

> diff --git a/net/xdp/xsk_queue.h b/net/xdp/xsk_queue.h

> index cdb9cf3..82a5228 100644

> --- a/net/xdp/xsk_queue.h

> +++ b/net/xdp/xsk_queue.h

> @@ -264,6 +264,12 @@ static inline bool xskq_cons_is_full(struct xsk_queue *q)

>                 q->nentries;

>  }

>

> +static inline __u64 xskq_cons_left(struct xsk_queue *q)


Let us call this xskq_cons_entries_present() or
xskq_cons_filled_entries(). The word "left" has the connotation that I
still have stuff left to do. While this is kind of true for this case,
it might not be for other cases that can use your function. The
function provides how many (filled) entries that are present in the
ring. Can you come up with a better name as I am not super fond of my
suggestions? It would have been nice to call it xskq_cons_nb_entries()
but there is already such a function that is lazy in nature and that
allows access to the entries.

> +{

> +       /* No barriers needed since data is not accessed */

> +       return READ_ONCE(q->ring->producer) - READ_ONCE(q->ring->consumer);

> +}

> +

>  /* Functions for producers */

>

>  static inline bool xskq_prod_is_full(struct xsk_queue *q)

> --

> 1.8.3.1

>