Merge branch 'virtio-net-tx-napi'
Willem de Bruijn says:
====================
virtio-net tx napi
Add napi for virtio-net transmit completion processing.
Changes:
v2 -> v3:
- convert __netif_tx_trylock to __netif_tx_lock on tx napi poll
ensure that the handler always cleans, to avoid deadlock
- unconditionally clean in start_xmit
avoid adding an unnecessary "if (use_napi)" branch
- remove virtqueue_disable_cb in patch 5/5
a noop in the common event_idx based loop
- document affinity_hint_set constraint
v1 -> v2:
- disable by default
- disable unless affinity_hint_set
because cache misses add up to a third higher cycle cost,
e.g., in TCP_RR tests. This is not limited to the patch
that enables tx completion cleaning in rx napi.
- use trylock to avoid contention between tx and rx napi
- keep interrupts masked during xmit_more (new patch 5/5)
this improves cycles especially for multi UDP_STREAM, which
does not benefit from cleaning tx completions on rx napi.
- move free_old_xmit_skbs (new patch 3/5)
to avoid forward declaration
not changed:
- deduplicate virnet_poll_tx and virtnet_poll_txclean
they look similar, but have differ too much to make it
worthwhile.
- delay netif_wake_subqueue for more than 2 + MAX_SKB_FRAGS
evaluated, but made no difference
- patch 1/5
RFC -> v1:
- dropped vhost interrupt moderation patch:
not needed and likely expensive at light load
- remove tx napi weight
- always clean all tx completions
- use boolean to toggle tx-napi, instead
- only clean tx in rx if tx-napi is enabled
- then clean tx before rx
- fix: add missing braces in virtnet_freeze_down
- testing: add 4KB TCP_RR + UDP test results
Based on previous patchsets by Jason Wang:
[RFC V7 PATCH 0/7] enable tx interrupts for virtio-net
http://lkml.iu.edu/hypermail/linux/kernel/1505.3/00245.html
Before commit b0c39dbdc2 ("virtio_net: don't free buffers in xmit
ring") the virtio-net driver would free transmitted packets on
transmission of new packets in ndo_start_xmit and, to catch the edge
case when no new packet is sent, also in a timer at 10HZ.
A timer can cause long stalls. VIRTIO_F_NOTIFY_ON_EMPTY avoids stalls
due to low free descriptor count. It does not address a stalls due to
low socket SO_SNDBUF. Increasing timer frequency decreases that stall
time, but increases interrupt rate and, thus, cycle count.
Currently, with no timer, packets are freed only at ndo_start_xmit.
Latency of consume_skb is now unbounded. To avoid a deadlock if a sock
reaches SO_SNDBUF, packets are orphaned on tx. This breaks TCP small
queues.
Reenable TCP small queues by removing the orphan. Instead of using a
timer, convert the driver to regular tx napi. This does not have the
unresolved stall issue and does not have any frequency to tune.
By keeping interrupts enabled by default, napi increases tx
interrupt rate. VIRTIO_F_EVENT_IDX avoids sending an interrupt if
one is already unacknowledged, so makes this more feasible today.
Combine that with an optimization that brings interrupt rate
back in line with the existing version for most workloads:
Tx completion cleaning on rx interrupts elides most explicit tx
interrupts by relying on the fact that many rx interrupts fire.
Tested by running {1, 10, 100} {TCP, UDP} STREAM, RR, 4K_RR benchmarks
from a guest to a server on the host, on an x86_64 Haswell. The guest
runs 4 vCPUs pinned to 4 cores. vhost and the test server are
pinned to a core each.
All results are the median of 5 runs, with variance well < 10%.
Used neper (github.com/google/neper) as test process.
Napi increases single stream throughput, but increases cycle cost.
The optimizations bring this down. The previous patchset saw a
regression with UDP_STREAM, which does not benefit from cleaning tx
interrupts in rx napi. This regression is now gone for 10x, 100x.
Remaining difference is higher 1x TCP_STREAM, lower 1x UDP_STREAM.
The latest results are with process, rx napi and tx napi affine to
the same core. All numbers are lower than the previous patchset.
upstream napi
TCP_STREAM:
1x:
Mbps 27816 39805
Gcycles 274 285
10x:
Mbps 42947 42531
Gcycles 300 296
100x:
Mbps 31830 28042
Gcycles 279 269
TCP_RR Latency (us):
1x:
p50 21 21
p99 27 27
Gcycles 180 167
10x:
p50 40 39
p99 52 52
Gcycles 214 211
100x:
p50 281 241
p99 411 337
Gcycles 218 226
TCP_RR 4K:
1x:
p50 28 29
p99 34 36
Gcycles 177 167
10x:
p50 70 71
p99 85 134
Gcycles 213 214
100x:
p50 442 611
p99 802 785
Gcycles 237 216
UDP_STREAM:
1x:
Mbps 29468 26800
Gcycles 284 293
10x:
Mbps 29891 29978
Gcycles 285 312
100x:
Mbps 30269 30304
Gcycles 318 316
UDP_RR:
1x:
p50 19 19
p99 23 23
Gcycles 180 173
10x:
p50 35 40
p99 54 64
Gcycles 245 237
100x:
p50 234 286
p99 484 473
Gcycles 224 214
Note that GSO is enabled, so 4K RR still translates to one packet
per request.
Lower throughput at 100x vs 10x can be (at least in part)
explained by looking at bytes per packet sent (nstat). It likely
also explains the lower throughput of 1x for some variants.
upstream:
N=1 bytes/pkt=16581
N=10 bytes/pkt=61513
N=100 bytes/pkt=51558
at_rx:
N=1 bytes/pkt=65204
N=10 bytes/pkt=65148
N=100 bytes/pkt=56840
====================
Acked-by: Michael S. Tsirkin <mst@redhat.com>
hifive-unleashed-5.1
David S. Miller
commit
86a5df1495
|
|
@ -33,9 +33,10 @@
|
|||
static int napi_weight = NAPI_POLL_WEIGHT;
|
||||
module_param(napi_weight, int, 0444);
|
||||
|
||||
static bool csum = true, gso = true;
|
||||
static bool csum = true, gso = true, napi_tx;
|
||||
module_param(csum, bool, 0444);
|
||||
module_param(gso, bool, 0444);
|
||||
module_param(napi_tx, bool, 0644);
|
||||
|
||||
/* FIXME: MTU in config. */
|
||||
#define GOOD_PACKET_LEN (ETH_HLEN + VLAN_HLEN + ETH_DATA_LEN)
|
||||
|
|
@ -86,6 +87,8 @@ struct send_queue {
|
|||
|
||||
/* Name of the send queue: output.$index */
|
||||
char name[40];
|
||||
|
||||
struct napi_struct napi;
|
||||
};
|
||||
|
||||
/* Internal representation of a receive virtqueue */
|
||||
|
|
@ -239,15 +242,39 @@ static struct page *get_a_page(struct receive_queue *rq, gfp_t gfp_mask)
|
|||
return p;
|
||||
}
|
||||
|
||||
static void virtqueue_napi_schedule(struct napi_struct *napi,
|
||||
struct virtqueue *vq)
|
||||
{
|
||||
if (napi_schedule_prep(napi)) {
|
||||
virtqueue_disable_cb(vq);
|
||||
__napi_schedule(napi);
|
||||
}
|
||||
}
|
||||
|
||||
static void virtqueue_napi_complete(struct napi_struct *napi,
|
||||
struct virtqueue *vq, int processed)
|
||||
{
|
||||
int opaque;
|
||||
|
||||
opaque = virtqueue_enable_cb_prepare(vq);
|
||||
if (napi_complete_done(napi, processed) &&
|
||||
unlikely(virtqueue_poll(vq, opaque)))
|
||||
virtqueue_napi_schedule(napi, vq);
|
||||
}
|
||||
|
||||
static void skb_xmit_done(struct virtqueue *vq)
|
||||
{
|
||||
struct virtnet_info *vi = vq->vdev->priv;
|
||||
struct napi_struct *napi = &vi->sq[vq2txq(vq)].napi;
|
||||
|
||||
/* Suppress further interrupts. */
|
||||
virtqueue_disable_cb(vq);
|
||||
|
||||
/* We were probably waiting for more output buffers. */
|
||||
netif_wake_subqueue(vi->dev, vq2txq(vq));
|
||||
if (napi->weight)
|
||||
virtqueue_napi_schedule(napi, vq);
|
||||
else
|
||||
/* We were probably waiting for more output buffers. */
|
||||
netif_wake_subqueue(vi->dev, vq2txq(vq));
|
||||
}
|
||||
|
||||
static unsigned int mergeable_ctx_to_buf_truesize(unsigned long mrg_ctx)
|
||||
|
|
@ -936,27 +963,38 @@ static void skb_recv_done(struct virtqueue *rvq)
|
|||
struct virtnet_info *vi = rvq->vdev->priv;
|
||||
struct receive_queue *rq = &vi->rq[vq2rxq(rvq)];
|
||||
|
||||
/* Schedule NAPI, Suppress further interrupts if successful. */
|
||||
if (napi_schedule_prep(&rq->napi)) {
|
||||
virtqueue_disable_cb(rvq);
|
||||
__napi_schedule(&rq->napi);
|
||||
}
|
||||
virtqueue_napi_schedule(&rq->napi, rvq);
|
||||
}
|
||||
|
||||
static void virtnet_napi_enable(struct receive_queue *rq)
|
||||
static void virtnet_napi_enable(struct virtqueue *vq, struct napi_struct *napi)
|
||||
{
|
||||
napi_enable(&rq->napi);
|
||||
napi_enable(napi);
|
||||
|
||||
/* If all buffers were filled by other side before we napi_enabled, we
|
||||
* won't get another interrupt, so process any outstanding packets
|
||||
* now. virtnet_poll wants re-enable the queue, so we disable here.
|
||||
* We synchronize against interrupts via NAPI_STATE_SCHED */
|
||||
if (napi_schedule_prep(&rq->napi)) {
|
||||
virtqueue_disable_cb(rq->vq);
|
||||
local_bh_disable();
|
||||
__napi_schedule(&rq->napi);
|
||||
local_bh_enable();
|
||||
* won't get another interrupt, so process any outstanding packets now.
|
||||
* Call local_bh_enable after to trigger softIRQ processing.
|
||||
*/
|
||||
local_bh_disable();
|
||||
virtqueue_napi_schedule(napi, vq);
|
||||
local_bh_enable();
|
||||
}
|
||||
|
||||
static void virtnet_napi_tx_enable(struct virtnet_info *vi,
|
||||
struct virtqueue *vq,
|
||||
struct napi_struct *napi)
|
||||
{
|
||||
if (!napi->weight)
|
||||
return;
|
||||
|
||||
/* Tx napi touches cachelines on the cpu handling tx interrupts. Only
|
||||
* enable the feature if this is likely affine with the transmit path.
|
||||
*/
|
||||
if (!vi->affinity_hint_set) {
|
||||
napi->weight = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
return virtnet_napi_enable(vq, napi);
|
||||
}
|
||||
|
||||
static void refill_work(struct work_struct *work)
|
||||
|
|
@ -971,7 +1009,7 @@ static void refill_work(struct work_struct *work)
|
|||
|
||||
napi_disable(&rq->napi);
|
||||
still_empty = !try_fill_recv(vi, rq, GFP_KERNEL);
|
||||
virtnet_napi_enable(rq);
|
||||
virtnet_napi_enable(rq->vq, &rq->napi);
|
||||
|
||||
/* In theory, this can happen: if we don't get any buffers in
|
||||
* we will *never* try to fill again.
|
||||
|
|
@ -1007,45 +1045,6 @@ static int virtnet_receive(struct receive_queue *rq, int budget)
|
|||
return received;
|
||||
}
|
||||
|
||||
static int virtnet_poll(struct napi_struct *napi, int budget)
|
||||
{
|
||||
struct receive_queue *rq =
|
||||
container_of(napi, struct receive_queue, napi);
|
||||
unsigned int r, received;
|
||||
|
||||
received = virtnet_receive(rq, budget);
|
||||
|
||||
/* Out of packets? */
|
||||
if (received < budget) {
|
||||
r = virtqueue_enable_cb_prepare(rq->vq);
|
||||
if (napi_complete_done(napi, received)) {
|
||||
if (unlikely(virtqueue_poll(rq->vq, r)) &&
|
||||
napi_schedule_prep(napi)) {
|
||||
virtqueue_disable_cb(rq->vq);
|
||||
__napi_schedule(napi);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return received;
|
||||
}
|
||||
|
||||
static int virtnet_open(struct net_device *dev)
|
||||
{
|
||||
struct virtnet_info *vi = netdev_priv(dev);
|
||||
int i;
|
||||
|
||||
for (i = 0; i < vi->max_queue_pairs; i++) {
|
||||
if (i < vi->curr_queue_pairs)
|
||||
/* Make sure we have some buffers: if oom use wq. */
|
||||
if (!try_fill_recv(vi, &vi->rq[i], GFP_KERNEL))
|
||||
schedule_delayed_work(&vi->refill, 0);
|
||||
virtnet_napi_enable(&vi->rq[i]);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void free_old_xmit_skbs(struct send_queue *sq)
|
||||
{
|
||||
struct sk_buff *skb;
|
||||
|
|
@ -1076,6 +1075,77 @@ static void free_old_xmit_skbs(struct send_queue *sq)
|
|||
u64_stats_update_end(&stats->tx_syncp);
|
||||
}
|
||||
|
||||
static void virtnet_poll_cleantx(struct receive_queue *rq)
|
||||
{
|
||||
struct virtnet_info *vi = rq->vq->vdev->priv;
|
||||
unsigned int index = vq2rxq(rq->vq);
|
||||
struct send_queue *sq = &vi->sq[index];
|
||||
struct netdev_queue *txq = netdev_get_tx_queue(vi->dev, index);
|
||||
|
||||
if (!sq->napi.weight)
|
||||
return;
|
||||
|
||||
if (__netif_tx_trylock(txq)) {
|
||||
free_old_xmit_skbs(sq);
|
||||
__netif_tx_unlock(txq);
|
||||
}
|
||||
|
||||
if (sq->vq->num_free >= 2 + MAX_SKB_FRAGS)
|
||||
netif_tx_wake_queue(txq);
|
||||
}
|
||||
|
||||
static int virtnet_poll(struct napi_struct *napi, int budget)
|
||||
{
|
||||
struct receive_queue *rq =
|
||||
container_of(napi, struct receive_queue, napi);
|
||||
unsigned int received;
|
||||
|
||||
virtnet_poll_cleantx(rq);
|
||||
|
||||
received = virtnet_receive(rq, budget);
|
||||
|
||||
/* Out of packets? */
|
||||
if (received < budget)
|
||||
virtqueue_napi_complete(napi, rq->vq, received);
|
||||
|
||||
return received;
|
||||
}
|
||||
|
||||
static int virtnet_open(struct net_device *dev)
|
||||
{
|
||||
struct virtnet_info *vi = netdev_priv(dev);
|
||||
int i;
|
||||
|
||||
for (i = 0; i < vi->max_queue_pairs; i++) {
|
||||
if (i < vi->curr_queue_pairs)
|
||||
/* Make sure we have some buffers: if oom use wq. */
|
||||
if (!try_fill_recv(vi, &vi->rq[i], GFP_KERNEL))
|
||||
schedule_delayed_work(&vi->refill, 0);
|
||||
virtnet_napi_enable(vi->rq[i].vq, &vi->rq[i].napi);
|
||||
virtnet_napi_tx_enable(vi, vi->sq[i].vq, &vi->sq[i].napi);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int virtnet_poll_tx(struct napi_struct *napi, int budget)
|
||||
{
|
||||
struct send_queue *sq = container_of(napi, struct send_queue, napi);
|
||||
struct virtnet_info *vi = sq->vq->vdev->priv;
|
||||
struct netdev_queue *txq = netdev_get_tx_queue(vi->dev, vq2txq(sq->vq));
|
||||
|
||||
__netif_tx_lock(txq, raw_smp_processor_id());
|
||||
free_old_xmit_skbs(sq);
|
||||
__netif_tx_unlock(txq);
|
||||
|
||||
virtqueue_napi_complete(napi, sq->vq, 0);
|
||||
|
||||
if (sq->vq->num_free >= 2 + MAX_SKB_FRAGS)
|
||||
netif_tx_wake_queue(txq);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int xmit_skb(struct send_queue *sq, struct sk_buff *skb)
|
||||
{
|
||||
struct virtio_net_hdr_mrg_rxbuf *hdr;
|
||||
|
|
@ -1125,10 +1195,14 @@ static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
|
|||
int err;
|
||||
struct netdev_queue *txq = netdev_get_tx_queue(dev, qnum);
|
||||
bool kick = !skb->xmit_more;
|
||||
bool use_napi = sq->napi.weight;
|
||||
|
||||
/* Free up any pending old buffers before queueing new ones. */
|
||||
free_old_xmit_skbs(sq);
|
||||
|
||||
if (use_napi && kick)
|
||||
virtqueue_enable_cb_delayed(sq->vq);
|
||||
|
||||
/* timestamp packet in software */
|
||||
skb_tx_timestamp(skb);
|
||||
|
||||
|
|
@ -1147,8 +1221,10 @@ static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
|
|||
}
|
||||
|
||||
/* Don't wait up for transmitted skbs to be freed. */
|
||||
skb_orphan(skb);
|
||||
nf_reset(skb);
|
||||
if (!use_napi) {
|
||||
skb_orphan(skb);
|
||||
nf_reset(skb);
|
||||
}
|
||||
|
||||
/* If running out of space, stop queue to avoid getting packets that we
|
||||
* are then unable to transmit.
|
||||
|
|
@ -1162,7 +1238,8 @@ static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
|
|||
*/
|
||||
if (sq->vq->num_free < 2+MAX_SKB_FRAGS) {
|
||||
netif_stop_subqueue(dev, qnum);
|
||||
if (unlikely(!virtqueue_enable_cb_delayed(sq->vq))) {
|
||||
if (!use_napi &&
|
||||
unlikely(!virtqueue_enable_cb_delayed(sq->vq))) {
|
||||
/* More just got used, free them then recheck. */
|
||||
free_old_xmit_skbs(sq);
|
||||
if (sq->vq->num_free >= 2+MAX_SKB_FRAGS) {
|
||||
|
|
@ -1366,8 +1443,10 @@ static int virtnet_close(struct net_device *dev)
|
|||
/* Make sure refill_work doesn't re-enable napi! */
|
||||
cancel_delayed_work_sync(&vi->refill);
|
||||
|
||||
for (i = 0; i < vi->max_queue_pairs; i++)
|
||||
for (i = 0; i < vi->max_queue_pairs; i++) {
|
||||
napi_disable(&vi->rq[i].napi);
|
||||
napi_disable(&vi->sq[i].napi);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1722,8 +1801,10 @@ static void virtnet_freeze_down(struct virtio_device *vdev)
|
|||
cancel_delayed_work_sync(&vi->refill);
|
||||
|
||||
if (netif_running(vi->dev)) {
|
||||
for (i = 0; i < vi->max_queue_pairs; i++)
|
||||
for (i = 0; i < vi->max_queue_pairs; i++) {
|
||||
napi_disable(&vi->rq[i].napi);
|
||||
napi_disable(&vi->sq[i].napi);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1746,8 +1827,11 @@ static int virtnet_restore_up(struct virtio_device *vdev)
|
|||
if (!try_fill_recv(vi, &vi->rq[i], GFP_KERNEL))
|
||||
schedule_delayed_work(&vi->refill, 0);
|
||||
|
||||
for (i = 0; i < vi->max_queue_pairs; i++)
|
||||
virtnet_napi_enable(&vi->rq[i]);
|
||||
for (i = 0; i < vi->max_queue_pairs; i++) {
|
||||
virtnet_napi_enable(vi->rq[i].vq, &vi->rq[i].napi);
|
||||
virtnet_napi_tx_enable(vi, vi->sq[i].vq,
|
||||
&vi->sq[i].napi);
|
||||
}
|
||||
}
|
||||
|
||||
netif_device_attach(vi->dev);
|
||||
|
|
@ -1952,6 +2036,7 @@ static void virtnet_free_queues(struct virtnet_info *vi)
|
|||
for (i = 0; i < vi->max_queue_pairs; i++) {
|
||||
napi_hash_del(&vi->rq[i].napi);
|
||||
netif_napi_del(&vi->rq[i].napi);
|
||||
netif_napi_del(&vi->sq[i].napi);
|
||||
}
|
||||
|
||||
/* We called napi_hash_del() before netif_napi_del(),
|
||||
|
|
@ -2137,6 +2222,8 @@ static int virtnet_alloc_queues(struct virtnet_info *vi)
|
|||
vi->rq[i].pages = NULL;
|
||||
netif_napi_add(vi->dev, &vi->rq[i].napi, virtnet_poll,
|
||||
napi_weight);
|
||||
netif_napi_add(vi->dev, &vi->sq[i].napi, virtnet_poll_tx,
|
||||
napi_tx ? napi_weight : 0);
|
||||
|
||||
sg_init_table(vi->rq[i].sg, ARRAY_SIZE(vi->rq[i].sg));
|
||||
ewma_pkt_len_init(&vi->rq[i].mrg_avg_pkt_len);
|
||||
|
|
|
|||
Loading…
Reference in New Issue