Skip to contentSkip to conversation

vhost: support async copy free segmentations

PATCH Superseded [email protected] 4 participants 10 messages Jul 15, 2020 – Jul 21, 2020

lore
Share & tools
lore
#0 lore raw

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.

Fixes cd6760da1076 ("vhost: introduce async enqueue for split ring")
---
 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
index 8c01cee42..0f7212f88 100644
@@ -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
index 1d0be3dd4..c6fa33f37 100644
@@ -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
#1 lore raw

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.

Fixes cd6760da1076 ("vhost: introduce async enqueue for split ring")

---
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
index 8c01cee42..0f7212f88 100644
@@ -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
index 1d0be3dd4..17808ab29 100644
@@ -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
Reviewed-by on v2 1/1
#2 lore raw
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 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.

Fixes cd6760da1076 ("vhost: introduce async enqueue for split ring")

---
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 index renamed from lib/librte_vhost/vhost.h +0 -0

8c01cee42..0f7212f88 100644

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 index renamed from lib/librte_vhost/virtio_net.c +0 -0

1d0be3dd4..17808ab29 100644

lib/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_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id,

lib/librte_vhost/virtio_net.c +1 -2
 	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);

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 -1
 				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);
Quoted 3 lines

vhost_vring_call_split(dev, vq);
--
2.18.4

Applied
#3 lore raw
Quoted 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 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.

Quoted 6 lines
Quoted 3 lines
Fixes cd6760da1076 ("vhost: introduce async enqueue for split ring")

Applied to dpdk-next-net/master, thanks.

#4 lore raw
In reply to [email protected]

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

---
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
index 8c01cee42..0f7212f88 100644
@@ -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
index 1d0be3dd4..17808ab29 100644
@@ -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);
#5 lore raw
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,
Maxime

Quoted 3 lines
Fixes cd6760da1076 ("vhost: introduce async enqueue for split ring")

<...>

#7 lore raw

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.

Fixes cd6760da1076 ("vhost: introduce async enqueue for split ring")

---
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
index 8c01cee42..0f7212f88 100644
@@ -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
index 1d0be3dd4..635113cb0 100644
@@ -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
#6 lore raw
In reply to Maxime Coquelin

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 segmentations

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.

I revise the commit message and title in my v3 patch. Hope that one will be more clear.

Thanks,

Patrick

Reviewed-by on v3 1/1
#8 lore raw

Re: [dpdk-dev] [PATCH v3] vhost: fix wrong async completion of multi-seg packets

In reply to [email protected]
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")

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

Applied
#9 lore raw

Re: [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")

With above typo fixed (can be done when applying, no need to resend):

Applied to dpdk-next-net/master, thanks.