vhost: support async copy free segmentations
PATCH 1/1 vhost: support async copy free segmentations
From: Patrick Fu <[email protected]>
Vhost async enqueue assumes that all async copies should break at packet boundary. i.e. if a packet is splited into multiple copy segments, the async engine should always report copy completion when entire packet is finished. This patch removes the assumption.
--- lib/librte_vhost/vhost.h | 3 +++ lib/librte_vhost/virtio_net.c | 12 ++++++++---- 2 files changed, 11 insertions(+), 4 deletions(-)
lib/librte_vhost/vhost.h +3 -0
@@ -46,6 +46,8 @@#define MAX_PKT_BURST 32 +#define ASYNC_MAX_POLL_SEG 255 +#define VHOST_MAX_ASYNC_IT (MAX_PKT_BURST * 2)#define VHOST_MAX_ASYNC_VEC (BUF_VECTOR_MAX * 2)
@@ -225,6 +227,7 @@ struct vhost_virtqueue {uint64_t *async_pending_info;uint16_t async_pkts_idx;uint16_t async_pkts_inflight_n; +uint16_t async_last_seg_n;/* vq async features */ bool async_inorder;
lib/librte_vhost/virtio_net.c +8 -4
@@ -1652,12 +1652,14 @@ uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id, start_idx =virtio_dev_rx_async_get_info_idx (pkts_idx, vq_size, vq->async_pkts_inflight_n); - n_pkts_cpl = - vq->async_ops.check_completed_copies (vid, queue_id,0 , count); + n_pkts_cpl = vq->async_ops.check_completed_copies (vid, queue_id, +0 ,ASYNC_MAX_POLL_SEG - vq->async_last_seg_n) + + vq->async_last_seg_n;rte_smp_wmb (); -while (likely (((start_idx + n_pkts_put) & (vq_size -1 )) != pkts_idx)) { +while (likely ((n_pkts_put < count) && + (((start_idx + n_pkts_put) & (vq_size -1 )) != pkts_idx))) {uint64_t info = async_pending_info[ (start_idx + n_pkts_put) & (vq_size -1 )];uint64_t n_segs;
@@ -1666,7 +1668,7 @@ uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id, n_segs = info >>ASYNC_PENDING_INFO_N_SFT ;if (n_segs) { -if (!n_pkts_cpl || n_pkts_cpl < n_segs) { +if (unlikely (n_pkts_cpl < n_segs)) { n_pkts_put--; n_descs -= info &ASYNC_PENDING_INFO_N_MSK ;if (n_pkts_cpl) {
@@ -1684,6 +1686,8 @@ uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id, } } + vq->async_last_seg_n = n_pkts_cpl; +if (n_pkts_put) { vq->async_pkts_inflight_n -= n_pkts_put;__atomic_add_fetch (&vq->used->idx, n_descs, __ATOMIC_RELEASE);
Signature · 1 line
2.18.4
PATCH v2 1/1 vhost: support async copy free segmentations
From: Patrick Fu <[email protected]>
Vhost async enqueue assumes that all async copies should break at packet boundary. i.e. if a packet is splited into multiple copy segments, the async engine should always report copy completion when entire packet is finished. This patch removes the assumption.
---
v2:
- fix an issue that can stuck async poll when packets buffer is full
- rename a local variable to better reflect its usage
lib/librte_vhost/vhost.h | 3 +++ lib/librte_vhost/virtio_net.c | 17 ++++++++++++----- 2 files changed, 15 insertions(+), 5 deletions(-)
lib/librte_vhost/vhost.h +3 -0
@@ -46,6 +46,8 @@#define MAX_PKT_BURST 32 +#define ASYNC_MAX_POLL_SEG 255 +#define VHOST_MAX_ASYNC_IT (MAX_PKT_BURST * 2)#define VHOST_MAX_ASYNC_VEC (BUF_VECTOR_MAX * 2)
@@ -225,6 +227,7 @@ struct vhost_virtqueue {uint64_t *async_pending_info;uint16_t async_pkts_idx;uint16_t async_pkts_inflight_n; +uint16_t async_last_seg_n;/* vq async features */ bool async_inorder;
lib/librte_vhost/virtio_net.c +12 -5
@@ -1633,6 +1633,7 @@ uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id,struct vhost_virtqueue *vq;uint16_t n_pkts_cpl, n_pkts_put =0 , n_descs =0 ;uint16_t start_idx, pkts_idx, vq_size; +uint16_t n_inflight;uint64_t *async_pending_info;VHOST_LOG_DATA (DEBUG ,"(%d) %s\n" , dev->vid, __func__);
@@ -1646,28 +1647,32 @@ uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id,rte_spinlock_lock (&vq->access_lock); + n_inflight = vq->async_pkts_inflight_n; pkts_idx = vq->async_pkts_idx; async_pending_info = vq->async_pending_info; vq_size = vq->size; start_idx =virtio_dev_rx_async_get_info_idx (pkts_idx, vq_size, vq->async_pkts_inflight_n); - n_pkts_cpl = - vq->async_ops.check_completed_copies (vid, queue_id,0 , count); + n_pkts_cpl = vq->async_ops.check_completed_copies (vid, queue_id, +0 ,ASYNC_MAX_POLL_SEG - vq->async_last_seg_n) + + vq->async_last_seg_n;rte_smp_wmb (); -while (likely (((start_idx + n_pkts_put) & (vq_size -1 )) != pkts_idx)) { +while (likely ((n_pkts_put < count) && n_inflight)) {uint64_t info = async_pending_info[ (start_idx + n_pkts_put) & (vq_size -1 )];uint64_t n_segs; n_pkts_put++; + n_inflight--; n_descs += info &ASYNC_PENDING_INFO_N_MSK ; n_segs = info >>ASYNC_PENDING_INFO_N_SFT ;if (n_segs) { -if (!n_pkts_cpl || n_pkts_cpl < n_segs) { +if (unlikely (n_pkts_cpl < n_segs)) { n_pkts_put--; + n_inflight++; n_descs -= info &ASYNC_PENDING_INFO_N_MSK ;if (n_pkts_cpl) { async_pending_info[
@@ -1684,8 +1689,10 @@ uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id, } } + vq->async_last_seg_n = n_pkts_cpl; +if (n_pkts_put) { - vq->async_pkts_inflight_n -= n_pkts_put; + vq->async_pkts_inflight_n = n_inflight;__atomic_add_fetch (&vq->used->idx, n_descs, __ATOMIC_RELEASE);vhost_vring_call_split (dev, vq);
Signature · 1 line
2.18.4
Quoted 115 lines
-----Original Message-----
From: Fu, Patrick <[email protected]>
Sent: Wednesday, July 15, 2020 7:15 PM
To: [email protected]; [email protected]; Xia, Chenbo <[email protected]>
Cc: Fu, Patrick <[email protected]>; Wang, Yinan <[email protected]>
Subject: [PATCH v2] vhost: support async copy free segmentationsFrom: Patrick Fu <[email protected]>
Vhost async enqueue assumes that all async copies should break at packet boundary. i.e. if a packet is splited into multiple copy segments, the async engine should always report copy completion when entire packet is finished. This patch removes the assumption.
Fixes cd6760da1076 ("vhost: introduce async enqueue for split ring")Signed-off-by Patrick Fu <[email protected]>---
v2:
- fix an issue that can stuck async poll when packets buffer is full
- rename a local variable to better reflect its usagelib/librte_vhost/vhost.h | 3 +++ lib/librte_vhost/virtio_net.c | 17 ++++++++++++----- 2 files changed, 15 insertions(+), 5 deletions(-)lib/librte_vhost/vhost.h index renamed from lib/librte_vhost/vhost.h +0
-0
8c01cee42..0f7212f88100644lib/librte_vhost/vhost.h +3
-0@@ -46,6 +46,8 @@#define MAX_PKT_BURST 32 +#define ASYNC_MAX_POLL_SEG 255 +#define VHOST_MAX_ASYNC_IT (MAX_PKT_BURST * 2) #defineVHOST_MAX_ASYNC_VEC (BUF_VECTOR_MAX *2 )@@ -225,6 +227,7 @@ struct vhost_virtqueue {uint64_t *async_pending_info;uint16_t async_pkts_idx;uint16_t async_pkts_inflight_n; +uint16_t async_last_seg_n;/* vq async features */ bool async_inorder;lib/librte_vhost/virtio_net.c index renamed from lib/librte_vhost/virtio_net.c +0
-0
1d0be3dd4..17808ab29100644lib/librte_vhost/virtio_net.c +1
-0@@ -1633,6 +1633,7 @@ uint16_t rte_vhost_poll_enqueue_completed(int vid,uint16_t queue_id, struct vhost_virtqueue *vq;uint16_t n_pkts_cpl, n_pkts_put =0 , n_descs =0 ;uint16_t start_idx, pkts_idx, vq_size; +uint16_t n_inflight;uint64_t *async_pending_info;
VHOST_LOG_DATA(DEBUG, "(%d) %s\n", dev->vid, __func__); @@ -
1646,28 +1647,32 @@uint16_trte_vhost_poll_enqueue_completed(int vid,uint16_tqueue_id,lib/librte_vhost/virtio_net.c +1
-2rte_spinlock_lock (&vq->access_lock); + n_inflight = vq->async_pkts_inflight_n; pkts_idx = vq->async_pkts_idx; async_pending_info = vq->async_pending_info; vq_size = vq->size; start_idx =virtio_dev_rx_async_get_info_idx (pkts_idx, vq_size, vq->async_pkts_inflight_n); - n_pkts_cpl = - vq->async_ops.check_completed_copies(vid, queue_id, 0,count);
lib/librte_vhost/virtio_net.c +7
-2+ n_pkts_cpl = vq->async_ops.check_completed_copies (vid, queue_id, +0 ,ASYNC_MAX_POLL_SEG - vq->async_last_seg_n) + + vq->async_last_seg_n;rte_smp_wmb (); -while (likely (((start_idx + n_pkts_put) & (vq_size -1 )) != pkts_idx)) { +while (likely ((n_pkts_put < count) && n_inflight)) {uint64_t info = async_pending_info[ (start_idx + n_pkts_put) & (vq_size -1 )];uint64_t n_segs; n_pkts_put++; + n_inflight--; n_descs += info &ASYNC_PENDING_INFO_N_MSK ; n_segs = info >>ASYNC_PENDING_INFO_N_SFT ;if (n_segs) { -if (!n_pkts_cpl || n_pkts_cpl < n_segs) { +if (unlikely (n_pkts_cpl < n_segs)) { n_pkts_put--; + n_inflight++; n_descs -= info &
ASYNC_PENDING_INFO_N_MSK;lib/librte_vhost/virtio_net.c +3
-1if (n_pkts_cpl) { async_pending_info[@@ -1684,8 +1689,10 @@ uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id, } } + vq->async_last_seg_n = n_pkts_cpl; +if (n_pkts_put) { - vq->async_pkts_inflight_n -= n_pkts_put; + vq->async_pkts_inflight_n = n_inflight;__atomic_add_fetch (&vq->used->idx, n_descs, __ATOMIC_RELEASE);
Quoted 3 lines
vhost_vring_call_split(dev, vq);
--
2.18.4
Ferruh Yigit
AppliedQuoted 16 lines · Chenbo
Quoted 16 lines
-----Original Message-----
From: Fu, Patrick <[email protected]>
Sent: Wednesday, July 15, 2020 7:15 PM
To: [email protected]; [email protected]; Xia, Chenbo <[email protected]>
Cc: Fu, Patrick <[email protected]>; Wang, Yinan <[email protected]>
Subject: [PATCH v2] vhost: support async copy free segmentationsFrom: Patrick Fu <[email protected]>
Vhost async enqueue assumes that all async copies should break at packet boundary. i.e. if a packet is splited into multiple copy segments, the async engine should always report copy completion when entire packet is finished. This patch removes the assumption.
Quoted 6 lines
Quoted 3 lines
Fixes cd6760da1076 ("vhost: introduce async enqueue for split ring")Signed-off-by Patrick Fu <[email protected]>Reviewed-by Chenbo Xia <[email protected]>
Applied to dpdk-next-net/master, thanks.
Hi Patrick,
Quoted 6 lines · On 7/15/20 1:15 PM, [email protected] wrote:
From: Patrick Fu <[email protected]>
Vhost async enqueue assumes that all async copies should break at packet boundary. i.e. if a packet is splited into multiple copy segments, the async engine should always report copy completion when entire packet is finished. This patch removes the assumption.
Could you please rework the commit message and title? It is hard to understand what the patch is doing and why.
Thanks in advance,
Maxime
Quoted 95 lines
Fixes cd6760da1076 ("vhost: introduce async enqueue for split ring")Signed-off-by Patrick Fu <[email protected]>---
v2:
- fix an issue that can stuck async poll when packets buffer is full
- rename a local variable to better reflect its usagelib/librte_vhost/vhost.h | 3 +++ lib/librte_vhost/virtio_net.c | 17 ++++++++++++----- 2 files changed, 15 insertions(+), 5 deletions(-)lib/librte_vhost/vhost.h +3
-0@@ -46,6 +46,8 @@#define MAX_PKT_BURST 32 +#define ASYNC_MAX_POLL_SEG 255 +#define VHOST_MAX_ASYNC_IT (MAX_PKT_BURST * 2)#define VHOST_MAX_ASYNC_VEC (BUF_VECTOR_MAX * 2)@@ -225,6 +227,7 @@ struct vhost_virtqueue {uint64_t *async_pending_info;uint16_t async_pkts_idx;uint16_t async_pkts_inflight_n; +uint16_t async_last_seg_n;/* vq async features */ bool async_inorder;lib/librte_vhost/virtio_net.c +12
-5@@ -1633,6 +1633,7 @@ uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id,struct vhost_virtqueue *vq;uint16_t n_pkts_cpl, n_pkts_put =0 , n_descs =0 ;uint16_t start_idx, pkts_idx, vq_size; +uint16_t n_inflight;uint64_t *async_pending_info;VHOST_LOG_DATA (DEBUG ,"(%d) %s\n" , dev->vid, __func__);@@ -1646,28 +1647,32 @@ uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id,rte_spinlock_lock (&vq->access_lock); + n_inflight = vq->async_pkts_inflight_n; pkts_idx = vq->async_pkts_idx; async_pending_info = vq->async_pending_info; vq_size = vq->size; start_idx =virtio_dev_rx_async_get_info_idx (pkts_idx, vq_size, vq->async_pkts_inflight_n); - n_pkts_cpl = - vq->async_ops.check_completed_copies (vid, queue_id,0 , count); + n_pkts_cpl = vq->async_ops.check_completed_copies (vid, queue_id, +0 ,ASYNC_MAX_POLL_SEG - vq->async_last_seg_n) + + vq->async_last_seg_n;rte_smp_wmb (); -while (likely (((start_idx + n_pkts_put) & (vq_size -1 )) != pkts_idx)) { +while (likely ((n_pkts_put < count) && n_inflight)) {uint64_t info = async_pending_info[ (start_idx + n_pkts_put) & (vq_size -1 )];uint64_t n_segs; n_pkts_put++; + n_inflight--; n_descs += info &ASYNC_PENDING_INFO_N_MSK ; n_segs = info >>ASYNC_PENDING_INFO_N_SFT ;if (n_segs) { -if (!n_pkts_cpl || n_pkts_cpl < n_segs) { +if (unlikely (n_pkts_cpl < n_segs)) { n_pkts_put--; + n_inflight++; n_descs -= info &ASYNC_PENDING_INFO_N_MSK ;if (n_pkts_cpl) { async_pending_info[@@ -1684,8 +1689,10 @@ uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id, } } + vq->async_last_seg_n = n_pkts_cpl; +if (n_pkts_put) { - vq->async_pkts_inflight_n -= n_pkts_put; + vq->async_pkts_inflight_n = n_inflight;__atomic_add_fetch (&vq->used->idx, n_descs, __ATOMIC_RELEASE);vhost_vring_call_split (dev, vq);
Quoted 5 lines · Maxime Coquelin
Hi Patrick,
Quoted 2 lines · On 7/15/20 1:15 PM, [email protected] wrote:
From: Patrick Fu <[email protected]>
Quoted 7 lines
Quoted 4 lines
Vhost async enqueue assumes that all async copies should break at packet boundary. i.e. if a packet is splited into multiple copy segments, the async engine should always report copy completion when entire packet is finished. This patch removes the assumption.
Could you please rework the commit message and title? It is hard to understand what the patch is doing and why.
Existing commit dropped from next-net and patchwork status updated.
Quoted 7 lines
Thanks in advance,
MaximeQuoted 3 lines
Fixes cd6760da1076 ("vhost: introduce async enqueue for split ring")Signed-off-by Patrick Fu <[email protected]>
<...>
Hi Maxime,
Quoted 13 lines
-----Original Message-----
From: Maxime Coquelin <[email protected]>
Sent: Monday, July 20, 2020 10:58 PM
To: Fu, Patrick <[email protected]>; [email protected]; Xia, Chenbo <[email protected]>
Cc: Wang, Yinan <[email protected]>
Subject: Re: [PATCH v2] vhost: support async copy free segmentationsHi Patrick,
Quoted 2 lines · On 7/15/20 1:15 PM, [email protected] wrote:
From: Patrick Fu <[email protected]>
Quoted 7 lines
Quoted 4 lines
Vhost async enqueue assumes that all async copies should break at packet boundary. i.e. if a packet is splited into multiple copy segments, the async engine should always report copy completion when entire packet is finished. This patch removes the assumption.
Could you please rework the commit message and title? It is hard to understand what the patch is doing and why.
I revise the commit message and title in my v3 patch. Hope that one will be more clear.
Thanks,
Patrick
PATCH v3 1/1 vhost: fix wrong async completion of multi-seg packets
In reply to [email protected]From: Patrick Fu <[email protected]>
In async enqueue copy, a packet could be split into multiple copy segments. When polling the copy completion status, current async data path assumes the async device callbacks are aware of the packet boundary and return completed segments only if all segments belonging to the same packet are done. Such assumption are not generic to common async devices and may degrees the copy performance if async callbacks have to implement it in software manner.
This patch adds tracking of the completed copy segments at vhost side. If async copy device reports partial completion of a packets, only vhost internal record is updated and vring status keeps unchanged until remaining segments of the packet are also finished. The async copy device is no longer necessary to care about the packet boundary.
---
v2:
- fix an issue that can stuck async poll when packets buffer is full
v3:
- revise commit message and title
- rename a local variable to better reflect its usage
lib/librte_vhost/vhost.h | 3 +++ lib/librte_vhost/virtio_net.c | 27 +++++++++++++++++---------- 2 files changed, 20 insertions(+), 10 deletions(-)
lib/librte_vhost/vhost.h +3 -0
@@ -46,6 +46,8 @@#define MAX_PKT_BURST 32 +#define ASYNC_MAX_POLL_SEG 255 +#define VHOST_MAX_ASYNC_IT (MAX_PKT_BURST * 2)#define VHOST_MAX_ASYNC_VEC (BUF_VECTOR_MAX * 2)
@@ -225,6 +227,7 @@ struct vhost_virtqueue {uint64_t *async_pending_info;uint16_t async_pkts_idx;uint16_t async_pkts_inflight_n; +uint16_t async_last_seg_n;/* vq async features */ bool async_inorder;
lib/librte_vhost/virtio_net.c +17 -10
@@ -1631,8 +1631,9 @@ uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id, {struct virtio_net *dev =get_device (vid);struct vhost_virtqueue *vq; -uint16_t n_pkts_cpl, n_pkts_put =0 , n_descs =0 ; +uint16_t n_segs_cpl, n_pkts_put =0 , n_descs =0 ;uint16_t start_idx, pkts_idx, vq_size; +uint16_t n_inflight;uint64_t *async_pending_info;VHOST_LOG_DATA (DEBUG ,"(%d) %s\n" , dev->vid, __func__);
@@ -1646,46 +1647,52 @@ uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id,rte_spinlock_lock (&vq->access_lock); + n_inflight = vq->async_pkts_inflight_n; pkts_idx = vq->async_pkts_idx; async_pending_info = vq->async_pending_info; vq_size = vq->size; start_idx =virtio_dev_rx_async_get_info_idx (pkts_idx, vq_size, vq->async_pkts_inflight_n); - n_pkts_cpl = - vq->async_ops.check_completed_copies (vid, queue_id,0 , count); + n_segs_cpl = vq->async_ops.check_completed_copies (vid, queue_id, +0 ,ASYNC_MAX_POLL_SEG - vq->async_last_seg_n) + + vq->async_last_seg_n;rte_smp_wmb (); -while (likely (((start_idx + n_pkts_put) & (vq_size -1 )) != pkts_idx)) { +while (likely ((n_pkts_put < count) && n_inflight)) {uint64_t info = async_pending_info[ (start_idx + n_pkts_put) & (vq_size -1 )];uint64_t n_segs; n_pkts_put++; + n_inflight--; n_descs += info &ASYNC_PENDING_INFO_N_MSK ; n_segs = info >>ASYNC_PENDING_INFO_N_SFT ;if (n_segs) { -if (!n_pkts_cpl || n_pkts_cpl < n_segs) { +if (unlikely (n_segs_cpl < n_segs)) { n_pkts_put--; + n_inflight++; n_descs -= info &ASYNC_PENDING_INFO_N_MSK ; -if (n_pkts_cpl) { +if (n_segs_cpl) { async_pending_info[ (start_idx + n_pkts_put) & (vq_size -1 )] = - ((n_segs - n_pkts_cpl) << + ((n_segs - n_segs_cpl) <<ASYNC_PENDING_INFO_N_SFT ) | (info &ASYNC_PENDING_INFO_N_MSK ); - n_pkts_cpl =0 ; + n_segs_cpl =0 ; }break ; } - n_pkts_cpl -= n_segs; + n_segs_cpl -= n_segs; } } + vq->async_last_seg_n = n_segs_cpl; +if (n_pkts_put) { - vq->async_pkts_inflight_n -= n_pkts_put; + vq->async_pkts_inflight_n = n_inflight;__atomic_add_fetch (&vq->used->idx, n_descs, __ATOMIC_RELEASE);vhost_vring_call_split (dev, vq);
Signature · 1 line
2.18.4
Re: [dpdk-dev] [PATCH v3] vhost: fix wrong async completion of multi-seg packets
Quoted 8 lines · On 7/21/20 7:47 AM, [email protected] wrote:
From: Patrick Fu <[email protected]>
In async enqueue copy, a packet could be split into multiple copy segments. When polling the copy completion status, current async data path assumes the async device callbacks are aware of the packet boundary and return completed segments only if all segments belonging to the same packet are done. Such assumption are not generic to common async devices and may degrees the copy performance if async callbacks
s/degrees/degrades/
Quoted 18 lines
have to implement it in software manner.
This patch adds tracking of the completed copy segments at vhost side. If async copy device reports partial completion of a packets, only vhost internal record is updated and vring status keeps unchanged until remaining segments of the packet are also finished. The async copy device is no longer necessary to care about the packet boundary.
Fixes cd6760da1076 ("vhost: introduce async enqueue for split ring")Signed-off-by Patrick Fu <[email protected]>---
v2:
- fix an issue that can stuck async poll when packets buffer is full
v3:
- revise commit message and title
- rename a local variable to better reflect its usage
Quoted 3 lines
lib/librte_vhost/vhost.h | 3 +++ lib/librte_vhost/virtio_net.c | 27 +++++++++++++++++---------- 2 files changed, 20 insertions(+), 10 deletions(-)
With above typo fixed (can be done when applying, no need to resend):
Thanks,
Maxime
Ferruh Yigit
AppliedRe: [dpdk-dev] [PATCH v3] vhost: fix wrong async completion of multi-seg packets
Quoted 22 lines · Maxime Coquelin
Quoted 8 lines · On 7/21/20 7:47 AM, [email protected] wrote:
From: Patrick Fu <[email protected]>
In async enqueue copy, a packet could be split into multiple copy segments. When polling the copy completion status, current async data path assumes the async device callbacks are aware of the packet boundary and return completed segments only if all segments belonging to the same packet are done. Such assumption are not generic to common async devices and may degrees the copy performance if async callbacks
s/degrees/degrades/
Quoted 8 lines
have to implement it in software manner.
This patch adds tracking of the completed copy segments at vhost side. If async copy device reports partial completion of a packets, only vhost internal record is updated and vring status keeps unchanged until remaining segments of the packet are also finished. The async copy device is no longer necessary to care about the packet boundary.
Quoted 7 lines
Quoted 3 lines
Fixes cd6760da1076 ("vhost: introduce async enqueue for split ring")Signed-off-by Patrick Fu <[email protected]>With above typo fixed (can be done when applying, no need to resend):
Reviewed-by Maxime Coquelin <[email protected]>
Applied to dpdk-next-net/master, thanks.