Skip to contentSkip to conversation

support to clear in-flight packets for async

PATCH New Yuan Wang 3 participants 22 messages Apr 13, 2022 – Jun 17, 2022

lore
Share & tools
lore

Yuan Wang

author
#0 lore raw

cover support to clear in-flight packets for async

These patches support to clear in-flight packets for async dequeue and introduce thread-safe version of this function.

note: The patches depend on the following patches
(https://patches.dpdk.org/project/dpdk/patch/[email protected]/)
(https://patches.dpdk.org/project/dpdk/patch/[email protected]/)

Yuan Wang (2):
vhost: support clear in-flight packets for async dequeue example/vhost: support to clear in-flight packets for async dequeue

 doc/guides/prog_guide/vhost_lib.rst    |  8 ++-
 doc/guides/rel_notes/release_22_07.rst |  4 ++
 examples/vhost/main.c                  |  3 -
 lib/vhost/rte_vhost_async.h            | 25 ++++++++
 lib/vhost/version.map                  |  1 +
 lib/vhost/virtio_net.c                 | 80 +++++++++++++++++++++++++-
 6 files changed, 115 insertions(+), 6 deletions(-)
Signature · 1 line
2.25.1
author
#1 lore raw

PATCH 1/2 vhost: support clear in-flight packets for async dequeue

rte_vhost_clear_queue_thread_unsafe() supports to clear in-flight packets for async enqueue only. But after supporting async dequeue, this API should support async dequeue too.

This patch also adds the thread-safe version of this API, the difference between the two API is that thread safety uses lock.

These APIs maybe used to clean up packets in the async channel to prevent packet loss when the device state changes or when the device is destroyed.

---
 doc/guides/prog_guide/vhost_lib.rst    |  8 ++-
 doc/guides/rel_notes/release_22_07.rst |  4 ++
 lib/vhost/rte_vhost_async.h            | 25 ++++++++
 lib/vhost/version.map                  |  1 +
 lib/vhost/virtio_net.c                 | 80 +++++++++++++++++++++++++-
 5 files changed, 115 insertions(+), 3 deletions(-)
doc/guides/prog_guide/vhost_lib.rst +7 -1
index 40cf315170..967c902703 100644
@@ -273,7 +273,13 @@ The following is an overview of some key Vhost API functions:
 
 * ``rte_vhost_clear_queue_thread_unsafe(vid, queue_id, **pkts, count, dma_id, vchan_id)``
 
-  Clear inflight packets which are submitted to DMA engine in vhost async data
+  Clear in-flight packets which are submitted to async channel in vhost
+  async data path without performing any locking. Completed packets are
+  returned to applications through ``pkts``.
+
+* ``rte_vhost_clear_queue(vid, queue_id, **pkts, count, dma_id, vchan_id)``
+
+  Clear in-flight packets which are submitted to async channel in vhost async data
   path. Completed packets are returned to applications through ``pkts``.
 
 * ``rte_vhost_async_try_dequeue_burst(int vid, uint16_t queue_id,
doc/guides/rel_notes/release_22_07.rst +4 -0
index 422a6673cb..6340ab9474 100644
@@ -60,6 +60,10 @@ New Features
   Added vhost async dequeue API which can leverage DMA devices to accelerate
   receiving pkts from guest.
 
+* **Added thread-safe version of inflight packet clear API in vhost library.**
+  Added an API which can clear the inflight packets submitted to
+  the async channel in a thread-safe manner in the vhost async data path.
+
 Removed Items
 -------------
 
lib/vhost/rte_vhost_async.h +25 -0
index 23fe1a7316..8a0e4849b9 100644
@@ -166,6 +166,31 @@ uint16_t rte_vhost_clear_queue_thread_unsafe(int vid, uint16_t queue_id,
 		struct rte_mbuf **pkts, uint16_t count, int16_t dma_id,
 		uint16_t vchan_id);
 
+/**
+ * This function checks async completion status and clear packets for
+ * a specific vhost device queue. Packets which are inflight will be
+ * returned in an array.
+ *
+ * @param vid
+ *  ID of vhost device to clear data
+ * @param queue_id
+ *  Queue id to clear data
+ * @param pkts
+ *  Blank array to get return packet pointer
+ * @param count
+ *  Size of the packet array
+ * @param dma_id
+ *  The identifier of the DMA device
+ * @param vchan_id
+ *  The identifier of virtual DMA channel
+ * @return
+ *  Number of packets returned
+ */
+__rte_experimental
+uint16_t rte_vhost_clear_queue(int vid, uint16_t queue_id,
+		struct rte_mbuf **pkts, uint16_t count, int16_t dma_id,
+		uint16_t vchan_id);
+
 /**
  * The DMA vChannels used in asynchronous data path must be configured
  * first. So this function needs to be called before enabling DMA
lib/vhost/version.map +1 -0
index 514e3ff6a6..531c966c03 100644
@@ -90,6 +90,7 @@ EXPERIMENTAL {
 
 	# added in 22.07
 	rte_vhost_async_try_dequeue_burst;
+	rte_vhost_clear_queue;
 };
 
 INTERNAL {
lib/vhost/virtio_net.c +78 -2

102 lines not on this page · raw message

Signature · 1 line
2.25.1
author
#2 lore raw

PATCH 2/2 example/vhost: support to clear in-flight packets for async dequeue

In reply to Yuan Wang

This patch allows vring_state_changed() to clear
in-flight dequeue packets.

---
 examples/vhost/main.c | 3 ---
 1 file changed, 3 deletions(-)
examples/vhost/main.c +0 -3
index d26e40ab73..04e7821322 100644
@@ -1767,9 +1767,6 @@ vring_state_changed(int vid, uint16_t queue_id, int enable)
 	if (!vdev)
 		return -1;
 
-	if (queue_id != VIRTIO_RXQ)
-		return 0;
-
 	if (dma_bind[vid2socketid[vid]].dmas[queue_id].async_enabled) {
 		if (!enable)
 			vhost_clear_queue_thread_unsafe(vdev, queue_id);
Signature · 1 line
2.25.1
author
#3 lore raw

v2 cover support to clear in-flight packets for async

In reply to Yuan Wang

These patches support to clear in-flight packets for async dequeue and introduce thread-safe version of this function.

note: The patches depend on the following patches
(http://patches.dpdk.org/project/dpdk/patch/[email protected]/)
(http://patches.dpdk.org/project/dpdk/patch/[email protected]/)

v1->v2:
* Rebase to latest DPDK
* Use the thread-safe version in destroy_device()

RFC->v1:
* Protect vq access with splitlock

Yuan Wang (2):
vhost: support clear in-flight packets for async dequeue example/vhost: support to clear in-flight packets for async dequeue

 doc/guides/prog_guide/vhost_lib.rst    |  8 ++-
 doc/guides/rel_notes/release_22_07.rst |  5 ++
 examples/vhost/main.c                  | 26 +++++++--
 lib/vhost/rte_vhost_async.h            | 25 ++++++++
 lib/vhost/version.map                  |  1 +
 lib/vhost/virtio_net.c                 | 80 +++++++++++++++++++++++++-
 6 files changed, 137 insertions(+), 8 deletions(-)
Signature · 1 line
2.25.1
author
#4 lore raw

PATCH v2 1/2 vhost: support clear in-flight packets for async dequeue

rte_vhost_clear_queue_thread_unsafe() supports to clear in-flight packets for async enqueue only. But after supporting async dequeue, this API should support async dequeue too.

This patch also adds the thread-safe version of this API, the difference between the two API is that thread safety uses lock.

These APIs maybe used to clean up packets in the async channel to prevent packet loss when the device state changes or when the device is destroyed.

---
 doc/guides/prog_guide/vhost_lib.rst    |  8 ++-
 doc/guides/rel_notes/release_22_07.rst |  5 ++
 lib/vhost/rte_vhost_async.h            | 25 ++++++++
 lib/vhost/version.map                  |  1 +
 lib/vhost/virtio_net.c                 | 80 +++++++++++++++++++++++++-
 5 files changed, 116 insertions(+), 3 deletions(-)
doc/guides/prog_guide/vhost_lib.rst +7 -1
index 09c1c24b48..543d37e4f4 100644
@@ -279,7 +279,13 @@ The following is an overview of some key Vhost API functions:
 
 * ``rte_vhost_clear_queue_thread_unsafe(vid, queue_id, **pkts, count, dma_id, vchan_id)``
 
-  Clear inflight packets which are submitted to DMA engine in vhost async data
+  Clear in-flight packets which are submitted to async channel in vhost
+  async data path without performing any locking. Completed packets are
+  returned to applications through ``pkts``.
+
+* ``rte_vhost_clear_queue(vid, queue_id, **pkts, count, dma_id, vchan_id)``
+
+  Clear in-flight packets which are submitted to async channel in vhost async data
   path. Completed packets are returned to applications through ``pkts``.
 
 * ``rte_vhost_async_try_dequeue_burst(int vid, uint16_t queue_id,
doc/guides/rel_notes/release_22_07.rst +5 -0
index 564d88623e..2696deb8bb 100644
@@ -75,6 +75,11 @@ New Features
   Added vhost async dequeue API which can leverage DMA devices to
   accelerate receiving pkts from guest.
 
+* **Added thread-safe version of inflight packet clear API in vhost library.**
+
+  Added an API which can clear the inflight packets submitted to
+  the async channel in a thread-safe manner in the vhost async data path.
+
 Removed Items
 -------------
 
lib/vhost/rte_vhost_async.h +25 -0
index 2789492e38..2ecaced7d8 100644
@@ -183,6 +183,31 @@ uint16_t rte_vhost_clear_queue_thread_unsafe(int vid, uint16_t queue_id,
 		struct rte_mbuf **pkts, uint16_t count, int16_t dma_id,
 		uint16_t vchan_id);
 
+/**
+ * This function checks async completion status and clear packets for
+ * a specific vhost device queue. Packets which are inflight will be
+ * returned in an array.
+ *
+ * @param vid
+ *  ID of vhost device to clear data
+ * @param queue_id
+ *  Queue id to clear data
+ * @param pkts
+ *  Blank array to get return packet pointer
+ * @param count
+ *  Size of the packet array
+ * @param dma_id
+ *  The identifier of the DMA device
+ * @param vchan_id
+ *  The identifier of virtual DMA channel
+ * @return
+ *  Number of packets returned
+ */
+__rte_experimental
+uint16_t rte_vhost_clear_queue(int vid, uint16_t queue_id,
+		struct rte_mbuf **pkts, uint16_t count, int16_t dma_id,
+		uint16_t vchan_id);
+
 /**
  * The DMA vChannels used in asynchronous data path must be configured
  * first. So this function needs to be called before enabling DMA
lib/vhost/version.map +1 -0
index 8c7211bf0d..eeaab77695 100644
@@ -91,6 +91,7 @@ EXPERIMENTAL {
 	# added in 22.07
 	rte_vhost_async_get_inflight_thread_unsafe;
 	rte_vhost_async_try_dequeue_burst;
+	rte_vhost_clear_queue;
 };
 
 INTERNAL {
lib/vhost/virtio_net.c +78 -2

102 lines not on this page · raw message

Signature · 1 line
2.25.1
author
#5 lore raw

PATCH v2 2/2 example/vhost: support to clear in-flight packets for async dequeue

In reply to Yuan Wang

This patch allows vring_state_changed() to clear in-flight dequeue packets. It also clears the in-flight packets in a thread-safe way in destroy_device().

---
 examples/vhost/main.c | 26 +++++++++++++++++++++-----
 1 file changed, 21 insertions(+), 5 deletions(-)
examples/vhost/main.c +21 -5
index d070391727..a97ac23061 100644
@@ -1537,6 +1537,25 @@ vhost_clear_queue_thread_unsafe(struct vhost_dev *vdev, uint16_t queue_id)
 	}
 }
 
+static void
+vhost_clear_queue(struct vhost_dev *vdev, uint16_t queue_id)
+{
+	uint16_t n_pkt = 0;
+	int pkts_inflight;
+
+	uint16_t dma_id = dma_bind[vid2socketid[vdev->vid]].dmas[queue_id].dev_id;
+	pkts_inflight = rte_vhost_async_get_inflight(vdev->vid, queue_id);
+
+	struct rte_mbuf *m_cpl[pkts_inflight];
+
+	while (pkts_inflight) {
+		n_pkt = rte_vhost_clear_queue(vdev->vid, queue_id, m_cpl,
+						pkts_inflight, dma_id, 0);
+		free_pkts(m_cpl, n_pkt);
+		pkts_inflight = rte_vhost_async_get_inflight(vdev->vid, queue_id);
+	}
+}
+
 /*
  * Remove a device from the specific data core linked list and from the
  * main linked list. Synchronization  occurs through the use of the
@@ -1594,13 +1613,13 @@ destroy_device(int vid)
 		vdev->vid);
 
 	if (dma_bind[vid].dmas[VIRTIO_RXQ].async_enabled) {
-		vhost_clear_queue_thread_unsafe(vdev, VIRTIO_RXQ);
+		vhost_clear_queue(vdev, VIRTIO_RXQ);
 		rte_vhost_async_channel_unregister(vid, VIRTIO_RXQ);
 		dma_bind[vid].dmas[VIRTIO_RXQ].async_enabled = false;
 	}
 
 	if (dma_bind[vid].dmas[VIRTIO_TXQ].async_enabled) {
-		vhost_clear_queue_thread_unsafe(vdev, VIRTIO_TXQ);
+		vhost_clear_queue(vdev, VIRTIO_TXQ);
 		rte_vhost_async_channel_unregister(vid, VIRTIO_TXQ);
 		dma_bind[vid].dmas[VIRTIO_TXQ].async_enabled = false;
 	}
@@ -1759,9 +1778,6 @@ vring_state_changed(int vid, uint16_t queue_id, int enable)
 	if (!vdev)
 		return -1;
 
-	if (queue_id != VIRTIO_RXQ)
-		return 0;
-
 	if (dma_bind[vid2socketid[vid]].dmas[queue_id].async_enabled) {
 		if (!enable)
 			vhost_clear_queue_thread_unsafe(vdev, queue_id);
Signature · 1 line
2.25.1
author
#6 lore raw

v3 cover support to clear in-flight packets for async

In reply to Yuan Wang

These patches support to clear in-flight packets for async dequeue and introduce thread-safe version of this function.

v3:
- Rebase to latest DPDK

v2:
- Rebase to latest DPDK
- Use the thread-safe version in destroy_device()

v1:
- Protect vq access with splitlock

Yuan Wang (2):
vhost: support clear in-flight packets for async dequeue example/vhost: support to clear in-flight packets for async dequeue

 doc/guides/prog_guide/vhost_lib.rst    |  8 ++-
 doc/guides/rel_notes/release_22_07.rst |  5 ++
 examples/vhost/main.c                  | 26 ++++++--
 lib/vhost/rte_vhost_async.h            | 25 ++++++++
 lib/vhost/version.map                  |  1 +
 lib/vhost/virtio_net.c                 | 82 +++++++++++++++++++++++++-
 6 files changed, 139 insertions(+), 8 deletions(-)
Signature · 1 line
2.25.1
author
#7 lore raw

PATCH v3 1/2 vhost: support clear in-flight packets for async dequeue

rte_vhost_clear_queue_thread_unsafe() supports to clear in-flight packets for async enqueue only. But after supporting async dequeue, this API should support async dequeue too.

This patch also adds the thread-safe version of this API, the difference between the two API is that thread safety uses lock.

These APIs maybe used to clean up packets in the async channel to prevent packet loss when the device state changes or when the device is destroyed.

---
 doc/guides/prog_guide/vhost_lib.rst    |  8 ++-
 doc/guides/rel_notes/release_22_07.rst |  5 ++
 lib/vhost/rte_vhost_async.h            | 25 ++++++++
 lib/vhost/version.map                  |  1 +
 lib/vhost/virtio_net.c                 | 82 +++++++++++++++++++++++++-
 5 files changed, 118 insertions(+), 3 deletions(-)
doc/guides/prog_guide/vhost_lib.rst +7 -1
index 680da504c8..a789f0c26f 100644
@@ -288,7 +288,13 @@ The following is an overview of some key Vhost API functions:
 
 * ``rte_vhost_clear_queue_thread_unsafe(vid, queue_id, **pkts, count, dma_id, vchan_id)``
 
-  Clear inflight packets which are submitted to DMA engine in vhost async data
+  Clear in-flight packets which are submitted to async channel in vhost
+  async data path without performing any locking. Completed packets are
+  returned to applications through ``pkts``.
+
+* ``rte_vhost_clear_queue(vid, queue_id, **pkts, count, dma_id, vchan_id)``
+
+  Clear in-flight packets which are submitted to async channel in vhost async data
   path. Completed packets are returned to applications through ``pkts``.
 
 * ``rte_vhost_vring_stats_get_names(int vid, uint16_t queue_id, struct rte_vhost_stat_name *names, unsigned int size)``
doc/guides/rel_notes/release_22_07.rst +5 -0
index 70b48d0fec..4c8b0c1b21 100644
@@ -92,6 +92,11 @@ New Features
   Added vhost async dequeue API which can leverage DMA devices to
   accelerate receiving pkts from guest.
 
+* **Added thread-safe version of inflight packet clear API in vhost library.**
+
+  Added an API which can clear the inflight packets submitted to
+  the async channel in a thread-safe manner in the vhost async data path.
+
 Removed Items
 -------------
 
lib/vhost/rte_vhost_async.h +25 -0
index a1e7f674ed..1db2a10124 100644
@@ -183,6 +183,31 @@ uint16_t rte_vhost_clear_queue_thread_unsafe(int vid, uint16_t queue_id,
 		struct rte_mbuf **pkts, uint16_t count, int16_t dma_id,
 		uint16_t vchan_id);
 
+/**
+ * This function checks async completion status and clear packets for
+ * a specific vhost device queue. Packets which are inflight will be
+ * returned in an array.
+ *
+ * @param vid
+ *  ID of vhost device to clear data
+ * @param queue_id
+ *  Queue id to clear data
+ * @param pkts
+ *  Blank array to get return packet pointer
+ * @param count
+ *  Size of the packet array
+ * @param dma_id
+ *  The identifier of the DMA device
+ * @param vchan_id
+ *  The identifier of virtual DMA channel
+ * @return
+ *  Number of packets returned
+ */
+__rte_experimental
+uint16_t rte_vhost_clear_queue(int vid, uint16_t queue_id,
+		struct rte_mbuf **pkts, uint16_t count, int16_t dma_id,
+		uint16_t vchan_id);
+
 /**
  * The DMA vChannels used in asynchronous data path must be configured
  * first. So this function needs to be called before enabling DMA
lib/vhost/version.map +1 -0
index bc75d4d724..a1ed3a1205 100644
@@ -94,6 +94,7 @@ EXPERIMENTAL {
 	rte_vhost_vring_stats_get;
 	rte_vhost_vring_stats_reset;
 	rte_vhost_async_try_dequeue_burst;
+	rte_vhost_clear_queue;
 };
 
 INTERNAL {
lib/vhost/virtio_net.c +80 -2

106 lines not on this page · raw message

Signature · 1 line
2.25.1
author
#8 lore raw

PATCH v3 2/2 example/vhost: support to clear in-flight packets for async dequeue

In reply to Yuan Wang

This patch allows vring_state_changed() to clear in-flight dequeue packets. It also clears the in-flight packets in a thread-safe way in destroy_device().

---
 examples/vhost/main.c | 26 +++++++++++++++++++++-----
 1 file changed, 21 insertions(+), 5 deletions(-)
examples/vhost/main.c +21 -5
index 5bc34b0c52..a66d6d4d18 100644
@@ -1539,6 +1539,25 @@ vhost_clear_queue_thread_unsafe(struct vhost_dev *vdev, uint16_t queue_id)
 	}
 }
 
+static void
+vhost_clear_queue(struct vhost_dev *vdev, uint16_t queue_id)
+{
+	uint16_t n_pkt = 0;
+	int pkts_inflight;
+
+	int16_t dma_id = dma_bind[vid2socketid[vdev->vid]].dmas[queue_id].dev_id;
+	pkts_inflight = rte_vhost_async_get_inflight(vdev->vid, queue_id);
+
+	struct rte_mbuf *m_cpl[pkts_inflight];
+
+	while (pkts_inflight) {
+		n_pkt = rte_vhost_clear_queue(vdev->vid, queue_id, m_cpl,
+						pkts_inflight, dma_id, 0);
+		free_pkts(m_cpl, n_pkt);
+		pkts_inflight = rte_vhost_async_get_inflight(vdev->vid, queue_id);
+	}
+}
+
 /*
  * Remove a device from the specific data core linked list and from the
  * main linked list. Synchronization  occurs through the use of the
@@ -1596,13 +1615,13 @@ destroy_device(int vid)
 		vdev->vid);
 
 	if (dma_bind[vid].dmas[VIRTIO_RXQ].async_enabled) {
-		vhost_clear_queue_thread_unsafe(vdev, VIRTIO_RXQ);
+		vhost_clear_queue(vdev, VIRTIO_RXQ);
 		rte_vhost_async_channel_unregister(vid, VIRTIO_RXQ);
 		dma_bind[vid].dmas[VIRTIO_RXQ].async_enabled = false;
 	}
 
 	if (dma_bind[vid].dmas[VIRTIO_TXQ].async_enabled) {
-		vhost_clear_queue_thread_unsafe(vdev, VIRTIO_TXQ);
+		vhost_clear_queue(vdev, VIRTIO_TXQ);
 		rte_vhost_async_channel_unregister(vid, VIRTIO_TXQ);
 		dma_bind[vid].dmas[VIRTIO_TXQ].async_enabled = false;
 	}
@@ -1761,9 +1780,6 @@ vring_state_changed(int vid, uint16_t queue_id, int enable)
 	if (!vdev)
 		return -1;
 
-	if (queue_id != VIRTIO_RXQ)
-		return 0;
-
 	if (dma_bind[vid2socketid[vid]].dmas[queue_id].async_enabled) {
 		if (!enable)
 			vhost_clear_queue_thread_unsafe(vdev, queue_id);
Signature · 1 line
2.25.1
author
#9 lore raw

v4 cover support to clear in-flight packets for async

In reply to Yuan Wang

These patches support to clear in-flight packets for async dequeue and introduce thread-safe version of this function.

v4:
- Rebase to latest DPDK

v3:
- Rebase to latest DPDK

v2:
- Rebase to latest DPDK
- Use the thread-safe version in destroy_device

v1:
- Protect vq access with splitlock

Yuan Wang (2):
vhost: support clear in-flight packets for async dequeue example/vhost: support to clear in-flight packets for async dequeue

 doc/guides/prog_guide/vhost_lib.rst    |  8 ++-
 doc/guides/rel_notes/release_22_07.rst |  5 ++
 examples/vhost/main.c                  | 26 ++++++--
 lib/vhost/rte_vhost_async.h            | 25 ++++++++
 lib/vhost/version.map                  |  1 +
 lib/vhost/virtio_net.c                 | 82 +++++++++++++++++++++++++-
 6 files changed, 139 insertions(+), 8 deletions(-)
Signature · 1 line
2.25.1
author
#10 lore raw

PATCH v4 1/2 vhost: support clear in-flight packets for async dequeue

rte_vhost_clear_queue_thread_unsafe() supports to clear in-flight packets for async enqueue only. But after supporting async dequeue, this API should support async dequeue too.

This patch also adds the thread-safe version of this API, the difference between the two API is that thread safety uses lock.

These APIs maybe used to clean up packets in the async channel to prevent packet loss when the device state changes or when the device is destroyed.

---
 doc/guides/prog_guide/vhost_lib.rst    |  8 ++-
 doc/guides/rel_notes/release_22_07.rst |  5 ++
 lib/vhost/rte_vhost_async.h            | 25 ++++++++
 lib/vhost/version.map                  |  1 +
 lib/vhost/virtio_net.c                 | 82 +++++++++++++++++++++++++-
 5 files changed, 118 insertions(+), 3 deletions(-)
doc/guides/prog_guide/vhost_lib.rst +7 -1
index cd3f6caa9a..b9545770d0 100644
@@ -288,7 +288,13 @@ The following is an overview of some key Vhost API functions:
 
 * ``rte_vhost_clear_queue_thread_unsafe(vid, queue_id, **pkts, count, dma_id, vchan_id)``
 
-  Clear inflight packets which are submitted to DMA engine in vhost async data
+  Clear in-flight packets which are submitted to async channel in vhost
+  async data path without performing any locking. Completed packets are
+  returned to applications through ``pkts``.
+
+* ``rte_vhost_clear_queue(vid, queue_id, **pkts, count, dma_id, vchan_id)``
+
+  Clear in-flight packets which are submitted to async channel in vhost async data
   path. Completed packets are returned to applications through ``pkts``.
 
 * ``rte_vhost_vring_stats_get_names(int vid, uint16_t queue_id, struct rte_vhost_stat_name *names, unsigned int size)``
doc/guides/rel_notes/release_22_07.rst +5 -0
index c81383f4a3..2ca06b543c 100644
@@ -147,6 +147,11 @@ New Features
   Added vhost async dequeue API which can leverage DMA devices to
   accelerate receiving pkts from guest.
 
+* **Added thread-safe version of inflight packet clear API in vhost library.**
+
+  Added an API which can clear the inflight packets submitted to
+  the async channel in a thread-safe manner in the vhost async data path.
+
 Removed Items
 -------------
 
lib/vhost/rte_vhost_async.h +25 -0
index a1e7f674ed..1db2a10124 100644
@@ -183,6 +183,31 @@ uint16_t rte_vhost_clear_queue_thread_unsafe(int vid, uint16_t queue_id,
 		struct rte_mbuf **pkts, uint16_t count, int16_t dma_id,
 		uint16_t vchan_id);
 
+/**
+ * This function checks async completion status and clear packets for
+ * a specific vhost device queue. Packets which are inflight will be
+ * returned in an array.
+ *
+ * @param vid
+ *  ID of vhost device to clear data
+ * @param queue_id
+ *  Queue id to clear data
+ * @param pkts
+ *  Blank array to get return packet pointer
+ * @param count
+ *  Size of the packet array
+ * @param dma_id
+ *  The identifier of the DMA device
+ * @param vchan_id
+ *  The identifier of virtual DMA channel
+ * @return
+ *  Number of packets returned
+ */
+__rte_experimental
+uint16_t rte_vhost_clear_queue(int vid, uint16_t queue_id,
+		struct rte_mbuf **pkts, uint16_t count, int16_t dma_id,
+		uint16_t vchan_id);
+
 /**
  * The DMA vChannels used in asynchronous data path must be configured
  * first. So this function needs to be called before enabling DMA
lib/vhost/version.map +1 -0
index 4880b9a422..9329f88e79 100644
@@ -95,6 +95,7 @@ EXPERIMENTAL {
 	rte_vhost_vring_stats_reset;
 	rte_vhost_async_try_dequeue_burst;
 	rte_vhost_driver_get_vdpa_dev_type;
+	rte_vhost_clear_queue;
 };
 
 INTERNAL {
lib/vhost/virtio_net.c +80 -2

106 lines not on this page · raw message

Signature · 1 line
2.25.1
#11 lore raw

RE: [PATCH v4 1/2] vhost: support clear in-flight packets for async dequeue

Hi Yuan,

Quoted 37 lines

-----Original Message-----
From: Wang, YuanX <[email protected]>
Sent: Tuesday, June 7, 2022 1:45 AM
To: [email protected]; Xia, Chenbo <[email protected]>; [email protected]
Cc: Hu, Jiayu <[email protected]>; Ding, Xuan <[email protected]>; Pai G, Sunil <[email protected]>; Wang, YuanX <[email protected]>
Subject: [PATCH v4 1/2] vhost: support clear in-flight packets for async dequeue

rte_vhost_clear_queue_thread_unsafe() supports to clear in-flight packets for async enqueue only. But after supporting async dequeue, this API should support async dequeue too.

This patch also adds the thread-safe version of this API, the difference between the two API is that thread safety uses lock.

These APIs maybe used to clean up packets in the async channel to prevent packet loss when the device state changes or when the device is destroyed.

---
 doc/guides/prog_guide/vhost_lib.rst    |  8 ++-
 doc/guides/rel_notes/release_22_07.rst |  5 ++
 lib/vhost/rte_vhost_async.h            | 25 ++++++++
 lib/vhost/version.map                  |  1 +
 lib/vhost/virtio_net.c                 | 82 +++++++++++++++++++++++++-
 5 files changed, 118 insertions(+), 3 deletions(-)
doc/guides/prog_guide/vhost_lib.rst +0 -0
index cd3f6caa9a..b9545770d0 100644
@@ -288,7 +288,13 @@ The following is an overview of some key Vhost API

functions:

Quoted 7 lines

* ``rte_vhost_clear_queue_thread_unsafe(vid, queue_id, **pkts, count,
dma_id, vchan_id)``

- Clear inflight packets which are submitted to DMA engine in vhost async data
+ Clear in-flight packets which are submitted to async channel in vhost
+ async data path without performing any locking. Completed packets are

Better specify "without performing locking on virtqueue".

Quoted 107 lines

+ returned to applications through ``pkts``.

doc/guides/prog_guide/vhost_lib.rst +6 -0
+
+* ``rte_vhost_clear_queue(vid, queue_id, **pkts, count, dma_id,
+vchan_id)``
+
+  Clear in-flight packets which are submitted to async channel in vhost
+ async data
   path. Completed packets are returned to applications through ``pkts``.
 
 * ``rte_vhost_vring_stats_get_names(int vid, uint16_t queue_id, struct

rte_vhost_stat_name *names, unsigned int size)`` diff --git a/doc/guides/rel_notes/release_22_07.rst b/doc/guides/rel_notes/release_22_07.rst
index c81383f4a3..2ca06b543c 100644

doc/guides/rel_notes/release_22_07.rst +6 -0
@@ -147,6 +147,11 @@ New Features
   Added vhost async dequeue API which can leverage DMA devices to
   accelerate receiving pkts from guest.
 
+* **Added thread-safe version of inflight packet clear API in vhost
+library.**
+
+  Added an API which can clear the inflight packets submitted to  the
+ async channel in a thread-safe manner in the vhost async data path.
+
 Removed Items
 -------------
lib/vhost/rte_vhost_async.h index renamed from lib/vhost/rte_vhost_async.h +0 -0

a1e7f674ed..1db2a10124 100644

lib/vhost/rte_vhost_async.h +25 -0
@@ -183,6 +183,31 @@ uint16_t rte_vhost_clear_queue_thread_unsafe(int
 vid, uint16_t queue_id,
 		struct rte_mbuf **pkts, uint16_t count, int16_t dma_id,
 		uint16_t vchan_id);
 
+/**
+ * This function checks async completion status and clear packets for
+ * a specific vhost device queue. Packets which are inflight will be
+ * returned in an array.
+ *
+ * @param vid
+ *  ID of vhost device to clear data
+ * @param queue_id
+ *  Queue id to clear data
+ * @param pkts
+ *  Blank array to get return packet pointer
+ * @param count
+ *  Size of the packet array
+ * @param dma_id
+ *  The identifier of the DMA device
+ * @param vchan_id
+ *  The identifier of virtual DMA channel
+ * @return
+ *  Number of packets returned
+ */
+__rte_experimental
+uint16_t rte_vhost_clear_queue(int vid, uint16_t queue_id,
+		struct rte_mbuf **pkts, uint16_t count, int16_t dma_id,
+		uint16_t vchan_id);
+
 /**
  * The DMA vChannels used in asynchronous data path must be configured

* first. So this function needs to be called before enabling DMA diff --git
a/lib/vhost/version.map b/lib/vhost/version.map index 4880b9a422..9329f88e79 100644

lib/vhost/version.map +1 -0
@@ -95,6 +95,7 @@ EXPERIMENTAL {
 	rte_vhost_vring_stats_reset;
 	rte_vhost_async_try_dequeue_burst;
 	rte_vhost_driver_get_vdpa_dev_type;
+	rte_vhost_clear_queue;
 };
 
 INTERNAL {
lib/vhost/virtio_net.c index renamed from lib/vhost/virtio_net.c +0 -0

68a26eb17d..a90ae3cb96 100644

lib/vhost/virtio_net.c +6 -1
@@ -26,6 +26,11 @@
 
 #define MAX_BATCH_LEN 256
 
+static __rte_always_inline uint16_t
+async_poll_dequeue_completed_split(struct virtio_net *dev, struct
 vhost_virtqueue *vq,
+		struct rte_mbuf **pkts, uint16_t count, int16_t dma_id,
+		uint16_t vchan_id, bool legacy_ol_flags);
+
 /* DMA device copy operation tracking array. */  struct async_dma_info
 dma_copy_track[RTE_DMADEV_DEFAULT_MAX];
@@ -2155,7 +2160,7 @@ rte_vhost_clear_queue_thread_unsafe(int vid,
 uint16_t queue_id,
 		return 0;
 
 	VHOST_LOG_DATA(DEBUG, "(%s) %s\n", dev->ifname, __func__);
-	if (unlikely(!is_valid_virt_queue_idx(queue_id, 0, dev->nr_vring))) {
+	if (unlikely(queue_id >= dev->nr_vring)) {
 		VHOST_LOG_DATA(ERR, "(%s) %s: invalid virtqueue
 idx %d.\n",
lib/vhost/virtio_net.c +0 -0
 			dev->ifname, __func__, queue_id);
 		return 0;

lib/vhost/virtio_net.c rte_vhost_clear_queue_thread_unsafe(int vid, · line 2192

Quoted 7 lines
lib/vhost/virtio_net.c +1 -1
@@ -2182,7 +2187,18 @@ rte_vhost_clear_queue_thread_unsafe(int vid,
 uint16_t queue_id,
 		return 0;
 	}
 
-	n_pkts_cpl = vhost_poll_enqueue_completed(dev, queue_id, pkts,
 count, dma_id, vchan_id);
+	if (queue_id % 2 == 0)

Replace "%" with "&" should help the performance a bit.

Quoted 45 lines
lib/vhost/virtio_net.c +9 -0
+		n_pkts_cpl = vhost_poll_enqueue_completed(dev, queue_id,
+					pkts, count, dma_id, vchan_id);
+	else {
+		if (unlikely(vq_is_packed(dev)))
+			VHOST_LOG_DATA(ERR,
+					"(%d) %s: async dequeue does not
 support packed ring.\n",
+					dev->vid, __func__);
+		else
+			n_pkts_cpl =

async_poll_dequeue_completed_split(dev, vq, pkts, count,

lib/vhost/virtio_net.c +1 -0
+					dma_id, vchan_id, dev->flags &

VIRTIO_DEV_LEGACY_OL_FLAGS);

lib/vhost/virtio_net.c +1 -0
+	}
 
 	vhost_queue_stats_update(dev, vq, pkts, n_pkts_cpl);
 	vq->stats.inflight_completed += n_pkts_cpl; @@ -2190,6 +2206,68

@@ rte_vhost_clear_queue_thread_unsafe(int vid, uint16_t queue_id,

lib/vhost/virtio_net.c +13 -0
 	return n_pkts_cpl;
 }
 
+uint16_t
+rte_vhost_clear_queue(int vid, uint16_t queue_id, struct rte_mbuf **pkts,
+		uint16_t count, int16_t dma_id, uint16_t vchan_id) {
+	struct virtio_net *dev = get_device(vid);
+	struct vhost_virtqueue *vq;
+	uint16_t n_pkts_cpl = 0;
+
+	if (!dev)
+		return 0;
+
+	VHOST_LOG_DATA(DEBUG, "(%s) %s\n", dev->ifname, __func__);
+	if (unlikely(queue_id >= dev->nr_vring)) {
+		VHOST_LOG_DATA(ERR, "(%s) %s: invalid virtqueue

idx %d.\n",

lib/vhost/virtio_net.c +9 -0
+			dev->ifname, __func__, queue_id);
+		return 0;
+	}
+
+	vq = dev->virtqueue[queue_id];
+
+	if (!rte_spinlock_trylock(&vq->access_lock)) {
+		VHOST_LOG_DATA(ERR,
+				"(%d) %s: failed to clear async queue id %d,

virtqueue busy.\n",

lib/vhost/virtio_net.c rte_vhost_clear_queue_thread_unsafe(int vid, uint16_t queue_id, · line 2234

Quoted 3 lines
lib/vhost/virtio_net.c +3 -0
+				dev->vid, __func__, queue_id);
+		return 0;
+	}

Failing to acquire the lock shouldn't be treated as an error.

Quoted 13 lines
lib/vhost/virtio_net.c +3 -0
+
+	if (unlikely(!vq->async)) {
+		VHOST_LOG_DATA(ERR, "(%s) %s: async not registered for

queue id %d.\n",

lib/vhost/virtio_net.c +6 -0
+				dev->ifname, __func__, queue_id);
+		goto out_access_unlock;
+	}
+
+	if (unlikely(!dma_copy_track[dma_id].vchans ||
+
	!dma_copy_track[dma_id].vchans[vchan_id].pkts_cmpl_flag_addr)) {
lib/vhost/virtio_net.c +1 -0
+		VHOST_LOG_DATA(ERR, "(%s) %s: invalid channel %d:%u.\n",

dev->ifname, __func__,

lib/vhost/virtio_net.c rte_vhost_clear_queue_thread_unsafe(int vid, uint16_t queue_id, · line 2247

Quoted 3 lines
lib/vhost/virtio_net.c +3 -0
+				dma_id, vchan_id);
+		goto out_access_unlock;
+	}

Also need to check if dma_id is valid.

lib/vhost/virtio_net.c

Quoted 2 lines
lib/vhost/virtio_net.c +2 -0
+
+	if (queue_id % 2 == 0)

Ditto.

Thanks,
Jiayu

#12 lore raw

RE: [PATCH v4 1/2] vhost: support clear in-flight packets for async dequeue

Hi Jiayu,

Quoted 242 lines

-----Original Message-----
From: Hu, Jiayu <[email protected]>
Sent: Thursday, June 9, 2022 3:06 PM
To: Wang, YuanX <[email protected]>; [email protected]; Xia, Chenbo <[email protected]>; [email protected]
Cc: Ding, Xuan <[email protected]>; Pai G, Sunil <[email protected]>
Subject: RE: [PATCH v4 1/2] vhost: support clear in-flight packets for async dequeue

Hi Yuan,

Quoted 15 lines

-----Original Message-----
From: Wang, YuanX <[email protected]>
Sent: Tuesday, June 7, 2022 1:45 AM
To: [email protected]; Xia, Chenbo <[email protected]>; [email protected]
Cc: Hu, Jiayu <[email protected]>; Ding, Xuan <[email protected]>; Pai G, Sunil <[email protected]>; Wang, YuanX <[email protected]>
Subject: [PATCH v4 1/2] vhost: support clear in-flight packets for async dequeue

rte_vhost_clear_queue_thread_unsafe() supports to clear in-flight packets for async enqueue only. But after supporting async dequeue, this API should support async dequeue too.

Quoted 5 lines

This patch also adds the thread-safe version of this API, the difference between the two API is that thread safety uses lock.

These APIs maybe used to clean up packets in the async channel to prevent packet loss when the device state changes or when the device is

destroyed.

Quoted 19 lines
---
 doc/guides/prog_guide/vhost_lib.rst    |  8 ++-
 doc/guides/rel_notes/release_22_07.rst |  5 ++
 lib/vhost/rte_vhost_async.h            | 25 ++++++++
 lib/vhost/version.map                  |  1 +
 lib/vhost/virtio_net.c                 | 82 +++++++++++++++++++++++++-
 5 files changed, 118 insertions(+), 3 deletions(-)
doc/guides/prog_guide/vhost_lib.rst +0 -0
index cd3f6caa9a..b9545770d0 100644
@@ -288,7 +288,13 @@ The following is an overview of some key Vhost

API
functions:

Quoted 8 lines

* ``rte_vhost_clear_queue_thread_unsafe(vid, queue_id, **pkts, count,
dma_id, vchan_id)``

- Clear inflight packets which are submitted to DMA engine in vhost async data
+ Clear in-flight packets which are submitted to async channel in
+ vhost async data path without performing any locking. Completed
+ packets are

Better specify "without performing locking on virtqueue".

lib/vhost/rte_vhost_async.h uint16_t

Quoted 35 lines

+ returned to applications through ``pkts``.

doc/guides/prog_guide/vhost_lib.rst +6 -0
+
+* ``rte_vhost_clear_queue(vid, queue_id, **pkts, count, dma_id,
+vchan_id)``
+
+  Clear in-flight packets which are submitted to async channel in
+ vhost async data
   path. Completed packets are returned to applications through ``pkts``.
 
 * ``rte_vhost_vring_stats_get_names(int vid, uint16_t queue_id,

struct rte_vhost_stat_name *names, unsigned int size)`` diff --git a/doc/guides/rel_notes/release_22_07.rst b/doc/guides/rel_notes/release_22_07.rst
index c81383f4a3..2ca06b543c 100644

doc/guides/rel_notes/release_22_07.rst +6 -0
@@ -147,6 +147,11 @@ New Features
   Added vhost async dequeue API which can leverage DMA devices to
   accelerate receiving pkts from guest.
 
+* **Added thread-safe version of inflight packet clear API in vhost
+library.**
+
+  Added an API which can clear the inflight packets submitted to  the
+ async channel in a thread-safe manner in the vhost async data path.
+
 Removed Items
 -------------
lib/vhost/rte_vhost_async.h +0 -0

index
a1e7f674ed..1db2a10124 100644

lib/vhost/rte_vhost_async.h +0 -0
@@ -183,6 +183,31 @@ uint16_t

rte_vhost_clear_queue_thread_unsafe(int

Quoted 71 lines
lib/vhost/rte_vhost_async.h +24 -0
 vid, uint16_t queue_id,
 struct rte_mbuf **pkts, uint16_t count, int16_t dma_id,  uint16_t
 vchan_id);
 
+/**
+ * This function checks async completion status and clear packets for
+ * a specific vhost device queue. Packets which are inflight will be
+ * returned in an array.
+ *
+ * @param vid
+ *  ID of vhost device to clear data
+ * @param queue_id
+ *  Queue id to clear data
+ * @param pkts
+ *  Blank array to get return packet pointer
+ * @param count
+ *  Size of the packet array
+ * @param dma_id
+ *  The identifier of the DMA device
+ * @param vchan_id
+ *  The identifier of virtual DMA channel
+ * @return
+ *  Number of packets returned
+ */
+__rte_experimental
+uint16_t rte_vhost_clear_queue(int vid, uint16_t queue_id, struct
+rte_mbuf **pkts, uint16_t count, int16_t dma_id, uint16_t vchan_id);
+
 /**
  * The DMA vChannels used in asynchronous data path must be configured
  * first. So this function needs to be called before enabling DMA
lib/vhost/version.map index renamed from lib/vhost/version.map +0 -0

4880b9a422..9329f88e79 100644

lib/vhost/version.map +1 -0
@@ -95,6 +95,7 @@ EXPERIMENTAL {
 rte_vhost_vring_stats_reset;
 rte_vhost_async_try_dequeue_burst;
 rte_vhost_driver_get_vdpa_dev_type;
+rte_vhost_clear_queue;
 };
 
 INTERNAL {
lib/vhost/virtio_net.c index renamed from lib/vhost/virtio_net.c +0 -0

68a26eb17d..a90ae3cb96 100644

lib/vhost/virtio_net.c +6 -0
@@ -26,6 +26,11 @@
 
 #define MAX_BATCH_LEN 256
 
+static __rte_always_inline uint16_t
+async_poll_dequeue_completed_split(struct virtio_net *dev, struct
 vhost_virtqueue *vq,
+struct rte_mbuf **pkts, uint16_t count, int16_t dma_id, uint16_t
+vchan_id, bool legacy_ol_flags);
+
 /* DMA device copy operation tracking array. */  struct
 async_dma_info dma_copy_track[RTE_DMADEV_DEFAULT_MAX];
@@ -2155,7 +2160,7 @@ rte_vhost_clear_queue_thread_unsafe(int vid,
 uint16_t queue_id,  return 0;
 
 VHOST_LOG_DATA(DEBUG, "(%s) %s\n", dev->ifname, __func__); -if
 (unlikely(!is_valid_virt_queue_idx(queue_id, 0, dev->nr_vring))) {
+if (unlikely(queue_id >= dev->nr_vring)) {
 VHOST_LOG_DATA(ERR, "(%s) %s: invalid virtqueue idx %d.\n",

dev->ifname, __func__, queue_id); return 0; @@ -2182,7 +2187,18 @@ rte_vhost_clear_queue_thread_unsafe(int vid, uint16_t queue_id, return 0; }

Quoted 3 lines

-n_pkts_cpl = vhost_poll_enqueue_completed(dev, queue_id, pkts, count, dma_id, vchan_id);
+if (queue_id % 2 == 0)

Replace "%" with "&" should help the performance a bit.

Quoted 1 line

+n_pkts_cpl = vhost_poll_enqueue_completed(dev, queue_id, pkts,

count,

Quoted 18 lines
lib/vhost/virtio_net.c +3 -0
+dma_id, vchan_id); else { if (unlikely(vq_is_packed(dev)))
+VHOST_LOG_DATA(ERR,
+"(%d) %s: async dequeue does not

support packed ring.\n",

lib/vhost/virtio_net.c +3 -0
+dev->vid, __func__);
+else
+n_pkts_cpl =

async_poll_dequeue_completed_split(dev, vq, pkts, count, +dma_id, vchan_id, dev->flags & VIRTIO_DEV_LEGACY_OL_FLAGS);
+}

vhost_queue_stats_update(dev, vq, pkts, n_pkts_cpl);
vq->stats.inflight_completed += n_pkts_cpl; @@ -2190,6 +2206,68 @@ rte_vhost_clear_queue_thread_unsafe(int vid, uint16_t queue_id, return n_pkts_cpl; }

lib/vhost/virtio_net.c +1 -0
+uint16_t

lib/vhost/virtio_net.c rte_vhost_clear_queue_thread_unsafe(int vid, uint16_t queue_id,

Quoted 10 lines
lib/vhost/virtio_net.c +10 -0
+rte_vhost_clear_queue(int vid, uint16_t queue_id, struct rte_mbuf
+**pkts, uint16_t count, int16_t dma_id, uint16_t vchan_id) { struct
+virtio_net *dev = get_device(vid); struct vhost_virtqueue *vq;
+uint16_t n_pkts_cpl = 0;
+
+if (!dev)
+return 0;
+
+VHOST_LOG_DATA(DEBUG, "(%s) %s\n", dev->ifname, __func__); if
+(unlikely(queue_id >= dev->nr_vring)) { VHOST_LOG_DATA(ERR,

"(%s) %s:

Quoted 11 lines

+invalid virtqueue
idx %d.\n",

lib/vhost/virtio_net.c +8 -0
+dev->ifname, __func__, queue_id);
+return 0;
+}
+
+vq = dev->virtqueue[queue_id];
+
+if (!rte_spinlock_trylock(&vq->access_lock)) { VHOST_LOG_DATA(ERR,
+"(%d) %s: failed to clear async queue id %d,

virtqueue busy.\n",

lib/vhost/virtio_net.c rte_vhost_clear_queue_thread_unsafe(int vid, uint16_t queue_id, · line 2234

Quoted 3 lines
lib/vhost/virtio_net.c +3 -0
+dev->vid, __func__, queue_id);
+return 0;
+}

Failing to acquire the lock shouldn't be treated as an error.

Quoted 13 lines
lib/vhost/virtio_net.c +3 -0
+
+if (unlikely(!vq->async)) {
+VHOST_LOG_DATA(ERR, "(%s) %s: async not registered for

queue id %d.\n",

lib/vhost/virtio_net.c +6 -0
+dev->ifname, __func__, queue_id);
+goto out_access_unlock;
+}
+
+if (unlikely(!dma_copy_track[dma_id].vchans ||
+

!dma_copy_track[dma_id].vchans[vchan_id].pkts_cmpl_flag_addr)) { +VHOST_LOG_DATA(ERR, "(%s) %s: invalid channel %d:%u.\n", dev->ifname, __func__,

lib/vhost/virtio_net.c rte_vhost_clear_queue_thread_unsafe(int vid, uint16_t queue_id, · line 2247

Quoted 3 lines
lib/vhost/virtio_net.c +3 -0
+dma_id, vchan_id);
+goto out_access_unlock;
+}

Also need to check if dma_id is valid.

Quoted 4 lines

lib/vhost/virtio_net.c

Quoted 2 lines
lib/vhost/virtio_net.c +2 -0
+
+if (queue_id % 2 == 0)

Ditto.

Thanks, will fix them soon.

Regards,
Yuan

Quoted 4 lines

Thanks,
Jiayu

author
#13 lore raw

PATCH v4 2/2 example/vhost: support to clear in-flight packets for async dequeue

In reply to Yuan Wang

This patch allows vring_state_changed() to clear in-flight dequeue packets. It also clears the in-flight packets in a thread-safe way in destroy_device().

---
 examples/vhost/main.c | 26 +++++++++++++++++++++-----
 1 file changed, 21 insertions(+), 5 deletions(-)
examples/vhost/main.c +21 -5
index 9aae340c46..1e36c35565 100644
@@ -1543,6 +1543,25 @@ vhost_clear_queue_thread_unsafe(struct vhost_dev *vdev, uint16_t queue_id)
 	}
 }
 
+static void
+vhost_clear_queue(struct vhost_dev *vdev, uint16_t queue_id)
+{
+	uint16_t n_pkt = 0;
+	int pkts_inflight;
+
+	int16_t dma_id = dma_bind[vid2socketid[vdev->vid]].dmas[queue_id].dev_id;
+	pkts_inflight = rte_vhost_async_get_inflight(vdev->vid, queue_id);
+
+	struct rte_mbuf *m_cpl[pkts_inflight];
+
+	while (pkts_inflight) {
+		n_pkt = rte_vhost_clear_queue(vdev->vid, queue_id, m_cpl,
+						pkts_inflight, dma_id, 0);
+		free_pkts(m_cpl, n_pkt);
+		pkts_inflight = rte_vhost_async_get_inflight(vdev->vid, queue_id);
+	}
+}
+
 /*
  * Remove a device from the specific data core linked list and from the
  * main linked list. Synchronization  occurs through the use of the
@@ -1600,13 +1619,13 @@ destroy_device(int vid)
 		vdev->vid);
 
 	if (dma_bind[vid].dmas[VIRTIO_RXQ].async_enabled) {
-		vhost_clear_queue_thread_unsafe(vdev, VIRTIO_RXQ);
+		vhost_clear_queue(vdev, VIRTIO_RXQ);
 		rte_vhost_async_channel_unregister(vid, VIRTIO_RXQ);
 		dma_bind[vid].dmas[VIRTIO_RXQ].async_enabled = false;
 	}
 
 	if (dma_bind[vid].dmas[VIRTIO_TXQ].async_enabled) {
-		vhost_clear_queue_thread_unsafe(vdev, VIRTIO_TXQ);
+		vhost_clear_queue(vdev, VIRTIO_TXQ);
 		rte_vhost_async_channel_unregister(vid, VIRTIO_TXQ);
 		dma_bind[vid].dmas[VIRTIO_TXQ].async_enabled = false;
 	}
@@ -1765,9 +1784,6 @@ vring_state_changed(int vid, uint16_t queue_id, int enable)
 	if (!vdev)
 		return -1;
 
-	if (queue_id != VIRTIO_RXQ)
-		return 0;
-
 	if (dma_bind[vid2socketid[vid]].dmas[queue_id].async_enabled) {
 		if (!enable)
 			vhost_clear_queue_thread_unsafe(vdev, queue_id);
Signature · 1 line
2.25.1
author
#14 lore raw

v5 cover support to clear in-flight packets for async

In reply to Yuan Wang

These patches support to clear in-flight packets for async dequeue and introduce thread-safe version of this function.

v5:
- Add dma_id check

v4:
- Rebase to latest DPDK

v3:
- Rebase to latest DPDK

v2:
- Use the thread-safe version in destroy_device

v1:
- Protect vq access with splitlock

Yuan Wang (2):
vhost: support clear in-flight packets for async dequeue example/vhost: support to clear in-flight packets for async dequeue

 doc/guides/prog_guide/vhost_lib.rst    |  8 ++-
 doc/guides/rel_notes/release_22_07.rst |  4 ++
 examples/vhost/main.c                  | 26 +++++--
 lib/vhost/rte_vhost_async.h            | 25 +++++++
 lib/vhost/version.map                  |  1 +
 lib/vhost/virtio_net.c                 | 93 +++++++++++++++++++++++++-
 6 files changed, 149 insertions(+), 8 deletions(-)
Signature · 1 line
2.25.1
author
#15 lore raw

PATCH v5 1/2 vhost: support clear in-flight packets for async dequeue

rte_vhost_clear_queue_thread_unsafe() supports to clear in-flight packets for async enqueue only. But after supporting async dequeue, this API should support async dequeue too.

This patch also adds the thread-safe version of this API, the difference between the two API is that thread safety uses lock.

These APIs maybe used to clean up packets in the async channel to prevent packet loss when the device state changes or when the device is destroyed.

---
 doc/guides/prog_guide/vhost_lib.rst    |  8 ++-
 doc/guides/rel_notes/release_22_07.rst |  4 ++
 lib/vhost/rte_vhost_async.h            | 25 +++++++
 lib/vhost/version.map                  |  1 +
 lib/vhost/virtio_net.c                 | 93 +++++++++++++++++++++++++-
 5 files changed, 128 insertions(+), 3 deletions(-)
doc/guides/prog_guide/vhost_lib.rst +7 -1
index cd3f6caa9a..606edee940 100644
@@ -288,7 +288,13 @@ The following is an overview of some key Vhost API functions:
 
 * ``rte_vhost_clear_queue_thread_unsafe(vid, queue_id, **pkts, count, dma_id, vchan_id)``
 
-  Clear inflight packets which are submitted to DMA engine in vhost async data
+  Clear in-flight packets which are submitted to async channel in vhost
+  async data path without performing locking on virtqueue. Completed
+  packets are returned to applications through ``pkts``.
+
+* ``rte_vhost_clear_queue(vid, queue_id, **pkts, count, dma_id, vchan_id)``
+
+  Clear in-flight packets which are submitted to async channel in vhost async data
   path. Completed packets are returned to applications through ``pkts``.
 
 * ``rte_vhost_vring_stats_get_names(int vid, uint16_t queue_id, struct rte_vhost_stat_name *names, unsigned int size)``
doc/guides/rel_notes/release_22_07.rst +4 -0
index d46f773df0..28ad615a66 100644
@@ -170,6 +170,10 @@ New Features
   This is a fall-back implementation for platforms that
   don't support vector operations.
 
+* **Added thread-safe version of inflight packet clear API in vhost library.**
+
+  Added an API which can clear the inflight packets submitted to
+  the async channel in a thread-safe manner in the vhost async data path.
 
 Removed Items
 -------------
lib/vhost/rte_vhost_async.h +25 -0
index a1e7f674ed..1db2a10124 100644
@@ -183,6 +183,31 @@ uint16_t rte_vhost_clear_queue_thread_unsafe(int vid, uint16_t queue_id,
 		struct rte_mbuf **pkts, uint16_t count, int16_t dma_id,
 		uint16_t vchan_id);
 
+/**
+ * This function checks async completion status and clear packets for
+ * a specific vhost device queue. Packets which are inflight will be
+ * returned in an array.
+ *
+ * @param vid
+ *  ID of vhost device to clear data
+ * @param queue_id
+ *  Queue id to clear data
+ * @param pkts
+ *  Blank array to get return packet pointer
+ * @param count
+ *  Size of the packet array
+ * @param dma_id
+ *  The identifier of the DMA device
+ * @param vchan_id
+ *  The identifier of virtual DMA channel
+ * @return
+ *  Number of packets returned
+ */
+__rte_experimental
+uint16_t rte_vhost_clear_queue(int vid, uint16_t queue_id,
+		struct rte_mbuf **pkts, uint16_t count, int16_t dma_id,
+		uint16_t vchan_id);
+
 /**
  * The DMA vChannels used in asynchronous data path must be configured
  * first. So this function needs to be called before enabling DMA
lib/vhost/version.map +1 -0
index 4880b9a422..9329f88e79 100644
@@ -95,6 +95,7 @@ EXPERIMENTAL {
 	rte_vhost_vring_stats_reset;
 	rte_vhost_async_try_dequeue_burst;
 	rte_vhost_driver_get_vdpa_dev_type;
+	rte_vhost_clear_queue;
 };
 
 INTERNAL {
lib/vhost/virtio_net.c +91 -2

120 lines not on this page · raw message

Signature · 1 line
2.25.1
Reviewed-by on v5 1/2
#16 lore raw

Re: [PATCH v5 1/2] vhost: support clear in-flight packets for async dequeue

Quoted 11 lines · Yuan Wang

rte_vhost_clear_queue_thread_unsafe() supports to clear in-flight packets for async enqueue only. But after supporting async dequeue, this API should support async dequeue too.

This patch also adds the thread-safe version of this API, the difference between the two API is that thread safety uses lock.

These APIs maybe used to clean up packets in the async channel to prevent packet loss when the device state changes or when the device is destroyed.

Quoted 9 lines
---
  doc/guides/prog_guide/vhost_lib.rst    |  8 ++-
  doc/guides/rel_notes/release_22_07.rst |  4 ++
  lib/vhost/rte_vhost_async.h            | 25 +++++++
  lib/vhost/version.map                  |  1 +
  lib/vhost/virtio_net.c                 | 93 +++++++++++++++++++++++++-
  5 files changed, 128 insertions(+), 3 deletions(-)

Thanks,
Maxime

Reviewed-by on v5 1/2
#17 lore raw

RE: [PATCH v5 1/2] vhost: support clear in-flight packets for async dequeue

In reply to Yuan Wang
Quoted 21 lines

-----Original Message-----
From: Wang, YuanX <[email protected]>
Sent: Friday, June 10, 2022 1:34 AM
To: [email protected]; Xia, Chenbo <[email protected]>; [email protected]
Cc: Hu, Jiayu <[email protected]>; Ding, Xuan <[email protected]>; Pai G, Sunil <[email protected]>; Wang, YuanX <[email protected]>
Subject: [PATCH v5 1/2] vhost: support clear in-flight packets for async dequeue

rte_vhost_clear_queue_thread_unsafe() supports to clear in-flight packets for async enqueue only. But after supporting async dequeue, this API should support async dequeue too.

This patch also adds the thread-safe version of this API, the difference between the two API is that thread safety uses lock.

These APIs maybe used to clean up packets in the async channel to prevent packet loss when the device state changes or when the device is destroyed.

Quoted 9 lines
---
 doc/guides/prog_guide/vhost_lib.rst    |  8 ++-
 doc/guides/rel_notes/release_22_07.rst |  4 ++
 lib/vhost/rte_vhost_async.h            | 25 +++++++
 lib/vhost/version.map                  |  1 +
 lib/vhost/virtio_net.c                 | 93 +++++++++++++++++++++++++-
 5 files changed, 128 insertions(+), 3 deletions(-)

Thanks,
Jiayu

author
#18 lore raw

PATCH v5 2/2 example/vhost: support to clear in-flight packets for async dequeue

In reply to Yuan Wang

This patch allows vring_state_changed() to clear in-flight dequeue packets. It also clears the in-flight packets in a thread-safe way in destroy_device().

---
 examples/vhost/main.c | 26 +++++++++++++++++++++-----
 1 file changed, 21 insertions(+), 5 deletions(-)
examples/vhost/main.c +21 -5
index e7fee5aa1b..a679ef738c 100644
@@ -1543,6 +1543,25 @@ vhost_clear_queue_thread_unsafe(struct vhost_dev *vdev, uint16_t queue_id)
 	}
 }
 
+static void
+vhost_clear_queue(struct vhost_dev *vdev, uint16_t queue_id)
+{
+	uint16_t n_pkt = 0;
+	int pkts_inflight;
+
+	int16_t dma_id = dma_bind[vid2socketid[vdev->vid]].dmas[queue_id].dev_id;
+	pkts_inflight = rte_vhost_async_get_inflight(vdev->vid, queue_id);
+
+	struct rte_mbuf *m_cpl[pkts_inflight];
+
+	while (pkts_inflight) {
+		n_pkt = rte_vhost_clear_queue(vdev->vid, queue_id, m_cpl,
+						pkts_inflight, dma_id, 0);
+		free_pkts(m_cpl, n_pkt);
+		pkts_inflight = rte_vhost_async_get_inflight(vdev->vid, queue_id);
+	}
+}
+
 /*
  * Remove a device from the specific data core linked list and from the
  * main linked list. Synchronization  occurs through the use of the
@@ -1600,13 +1619,13 @@ destroy_device(int vid)
 		vdev->vid);
 
 	if (dma_bind[vid].dmas[VIRTIO_RXQ].async_enabled) {
-		vhost_clear_queue_thread_unsafe(vdev, VIRTIO_RXQ);
+		vhost_clear_queue(vdev, VIRTIO_RXQ);
 		rte_vhost_async_channel_unregister(vid, VIRTIO_RXQ);
 		dma_bind[vid].dmas[VIRTIO_RXQ].async_enabled = false;
 	}
 
 	if (dma_bind[vid].dmas[VIRTIO_TXQ].async_enabled) {
-		vhost_clear_queue_thread_unsafe(vdev, VIRTIO_TXQ);
+		vhost_clear_queue(vdev, VIRTIO_TXQ);
 		rte_vhost_async_channel_unregister(vid, VIRTIO_TXQ);
 		dma_bind[vid].dmas[VIRTIO_TXQ].async_enabled = false;
 	}
@@ -1765,9 +1784,6 @@ vring_state_changed(int vid, uint16_t queue_id, int enable)
 	if (!vdev)
 		return -1;
 
-	if (queue_id != VIRTIO_RXQ)
-		return 0;
-
 	if (dma_bind[vid2socketid[vid]].dmas[queue_id].async_enabled) {
 		if (!enable)
 			vhost_clear_queue_thread_unsafe(vdev, queue_id);
Signature · 1 line
2.25.1
Reviewed-by on v5 2/2
#19 lore raw

Re: [PATCH v5 2/2] example/vhost: support to clear in-flight packets for async dequeue

Quoted 9 lines · Yuan Wang

This patch allows vring_state_changed() to clear in-flight dequeue packets. It also clears the in-flight packets in a thread-safe way in destroy_device().

---
  examples/vhost/main.c | 26 +++++++++++++++++++++-----
  1 file changed, 21 insertions(+), 5 deletions(-)

Thanks,
Maxime

Reviewed-by on v5 2/2
#20 lore raw

RE: [PATCH v5 2/2] example/vhost: support to clear in-flight packets for async dequeue

In reply to Yuan Wang

Thanks,
Jiayu

Quoted 79 lines

-----Original Message-----
From: Wang, YuanX <[email protected]>
Sent: Friday, June 10, 2022 1:34 AM
To: [email protected]; Xia, Chenbo <[email protected]>; [email protected]
Cc: Hu, Jiayu <[email protected]>; Ding, Xuan <[email protected]>; Pai G, Sunil <[email protected]>; Wang, YuanX <[email protected]>
Subject: [PATCH v5 2/2] example/vhost: support to clear in-flight packets for async dequeue

This patch allows vring_state_changed() to clear in-flight dequeue packets. It also clears the in-flight packets in a thread-safe way in destroy_device().

---
 examples/vhost/main.c | 26 +++++++++++++++++++++-----
 1 file changed, 21 insertions(+), 5 deletions(-)
examples/vhost/main.c index renamed from examples/vhost/main.c +0 -0

e7fee5aa1b..a679ef738c 100644

examples/vhost/main.c +18 -0
@@ -1543,6 +1543,25 @@ vhost_clear_queue_thread_unsafe(struct
 vhost_dev *vdev, uint16_t queue_id)
 	}
 }
 
+static void
+vhost_clear_queue(struct vhost_dev *vdev, uint16_t queue_id) {
+	uint16_t n_pkt = 0;
+	int pkts_inflight;
+
+	int16_t dma_id = dma_bind[vid2socketid[vdev-
 >vid]].dmas[queue_id].dev_id;
+	pkts_inflight = rte_vhost_async_get_inflight(vdev->vid, queue_id);
+
+	struct rte_mbuf *m_cpl[pkts_inflight];
+
+	while (pkts_inflight) {
+		n_pkt = rte_vhost_clear_queue(vdev->vid, queue_id, m_cpl,
+						pkts_inflight, dma_id, 0);
+		free_pkts(m_cpl, n_pkt);
+		pkts_inflight = rte_vhost_async_get_inflight(vdev->vid,
 queue_id);
+	}
+}
+
 /*
  * Remove a device from the specific data core linked list and from the
  * main linked list. Synchronization  occurs through the use of the @@ -

1600,13 +1619,13 @@ destroy_device(int vid)

examples/vhost/main.c +2 -5
 		vdev->vid);
 
 	if (dma_bind[vid].dmas[VIRTIO_RXQ].async_enabled) {
-		vhost_clear_queue_thread_unsafe(vdev, VIRTIO_RXQ);
+		vhost_clear_queue(vdev, VIRTIO_RXQ);
 		rte_vhost_async_channel_unregister(vid, VIRTIO_RXQ);
 		dma_bind[vid].dmas[VIRTIO_RXQ].async_enabled = false;
 	}
 
 	if (dma_bind[vid].dmas[VIRTIO_TXQ].async_enabled) {
-		vhost_clear_queue_thread_unsafe(vdev, VIRTIO_TXQ);
+		vhost_clear_queue(vdev, VIRTIO_TXQ);
 		rte_vhost_async_channel_unregister(vid, VIRTIO_TXQ);
 		dma_bind[vid].dmas[VIRTIO_TXQ].async_enabled = false;
 	}
@@ -1765,9 +1784,6 @@ vring_state_changed(int vid, uint16_t queue_id, int
 enable)
 	if (!vdev)
 		return -1;
 
-	if (queue_id != VIRTIO_RXQ)
-		return 0;
-
 	if (dma_bind[vid2socketid[vid]].dmas[queue_id].async_enabled) {
 		if (!enable)

vhost_clear_queue_thread_unsafe(vdev, queue_id);
--
2.25.1

#21 lore raw
In reply to Yuan Wang
Quoted 22 lines · Yuan Wang

These patches support to clear in-flight packets for async dequeue and introduce thread-safe version of this function.

v5:
- Add dma_id check

v4:
- Rebase to latest DPDK

v3:
- Rebase to latest DPDK

v2:
- Use the thread-safe version in destroy_device

v1:
- Protect vq access with splitlock

Yuan Wang (2):
vhost: support clear in-flight packets for async dequeue example/vhost: support to clear in-flight packets for async dequeue

Quoted 8 lines
  doc/guides/prog_guide/vhost_lib.rst    |  8 ++-
  doc/guides/rel_notes/release_22_07.rst |  4 ++
  examples/vhost/main.c                  | 26 +++++--
  lib/vhost/rte_vhost_async.h            | 25 +++++++
  lib/vhost/version.map                  |  1 +
  lib/vhost/virtio_net.c                 | 93 +++++++++++++++++++++++++-
  6 files changed, 149 insertions(+), 8 deletions(-)

Applied to dpdk-next-virtio/main.

Thanks,
Maxime