On 2021/5/12 7:30, Jakub Kicinski wrote:

On Tue, 11 May 2021 20:13:56 +0800 Yunsheng Lin wrote:

quoted

On 2021/5/11 17:04, Yunsheng Lin wrote:

quoted

On 2021/5/11 12:22, Jakub Kicinski wrote:  

quoted

The queues are woken asynchronously without holding any locks via
netif_tx_wake_queue(). Theoretically we can have a situation where:

CPU 0                            CPU 1   
  .                                .
dequeue_skb()                      .
  netif_xmit_frozen..() # true     .
  .                              [IRQ]
  .                              netif_tx_wake_queue()
  .                              <end of IRQ>
  .                              netif_tx_action()
  .                              set MISSED
  clear MISSED
  return NULL
ret from qdisc_restart()
ret from __qdisc_run()
qdisc_run_end()  

 [...]  

quoted

Yes, the above does seems to have the above data race.

As my understanding, there is two ways to fix the above data race:
1. do not clear the STATE_MISSED for netif_xmit_frozen_or_stopped()
   case, just check the netif_xmit_frozen_or_stopped() before
   calling __netif_schedule() at the end of qdisc_run_end(). This seems
   to only work with qdisc with TCQ_F_ONETXQUEUE flag because it seems
   we can only check the netif_xmit_frozen_or_stopped() with q->dev_queue,
   I am not sure q->dev_queue is pointint to which netdev queue when qdisc
   is not set with TCQ_F_ONETXQUEUE flag.

Isn't the case where we have a NOLOCK qdisc without TCQ_F_ONETXQUEUE
rather unexpected? It'd have to be a single pfifo on multi-queue
netdev, right? Sounds not worth optimizing for. How about:

 static inline void qdisc_run_end(struct Qdisc *qdisc)
 {
 	write_seqcount_end(&qdisc->running);
	if (qdisc->flags & TCQ_F_NOLOCK) {
 		spin_unlock(&qdisc->seqlock);

		if (unlikely(test_bit(__QDISC_STATE_MISSED,
				      &qdisc->state))) {
			clear_bit(__QDISC_STATE_MISSED, &qdisc->state);
			if (!(q->flags & TCQ_F_ONETXQUEUE) ||
			    !netif_xmit_frozen_or_stopped(q->dev_queue))
				__netif_schedule(qdisc);
		}
	}
 }

For the strange non-ONETXQUEUE case we'd have an occasional unnecessary
net_tx_action, but no infinite loop possible.

quoted

quoted

2. clearing the STATE_MISSED for netif_xmit_frozen_or_stopped() case
   as this patch does, and protect the __netif_schedule() with q->seqlock
   for netif_tx_wake_queue(), which might bring unnecessary overhead for
   non-stopped queue case

Any better idea?  

3. Or check the netif_xmit_frozen_or_stopped() again after clearing
   STATE_MISSED, like below:

   if (netif_xmit_frozen_or_stopped(txq)) {
	  clear_bit(__QDISC_STATE_MISSED, &q->state);

	  /* Make sure the below netif_xmit_frozen_or_stopped()
	   * checking happens after clearing STATE_MISSED.
	   */
	  smp_mb__after_atomic();

	  /* Checking netif_xmit_frozen_or_stopped() again to
	   * make sure __QDISC_STATE_MISSED is set if the
	   * __QDISC_STATE_MISSED set by netif_tx_wake_queue()'s
	   * rescheduling of net_tx_action() is cleared by the
	   * above clear_bit().
	   */
	  if (!netif_xmit_frozen_or_stopped(txq))
	  	set_bit(__QDISC_STATE_MISSED, &q->state);
  }

  It is kind of ugly, but it does seem to fix the above data race too.
  And it seems like a common pattern to deal with the concurrency between
  xmit and NAPI polling, as below:

https://elixir.bootlin.com/linux/v5.12-rc2/source/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c#L1409

This is indeed the idiomatic way of dealing with Tx queue stopping race,
but it's a bit of code to sprinkle around. My vote would be option 1.

I had done some performance testing to see which is better, tested using
pktgen and dummy netdev with pfifo_fast qdisc attached:

unit: Mpps

threads    V6         V6 + option 1     V6 + option 3
  1       2.60          2.54               2.60
  2       3.86          3.84               3.84
  4       5.56          5.50               5.51
  8       2.79          2.77               2.77
  16      2.23          2.24               2.22

So it seems the netif_xmit_frozen_or_stopped checking overhead for non-stopped queue
is noticable for 1 pktgen thread.

And the performance increase for V6 + option 1 with 16 pktgen threads is because of
"clear_bit(__QDISC_STATE_MISSED, &qdisc->state)" at the end of qdisc_run_end(), which
may avoid the another round of dequeuing in the pfifo_fast_dequeue(). And adding the
"clear_bit(__QDISC_STATE_MISSED, &qdisc->state)"  for V6 + option 3, the data for
16 pktgen thread also go up to 2.24Mpps.


So it seems V6 + option 3 with "clear_bit(__QDISC_STATE_MISSED, &qdisc->state)" at
the end of qdisc_run_end() is better?

_______________________________________________
Linuxarm mailing list -- linuxarm@openeuler.org
To unsubscribe send an email to linuxarm-leave@openeuler.org