support to clear in-flight packets for async
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
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
@@ -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
@@ -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
@@ -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
@@ -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
PATCH 2/2 example/vhost: support to clear in-flight packets for async dequeue
In reply to Yuan WangThis 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
@@ -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
v2 cover support to clear in-flight packets for async
In reply to Yuan WangThese 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
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
@@ -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
@@ -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
@@ -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
@@ -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
PATCH v2 2/2 example/vhost: support to clear in-flight packets for async dequeue
In reply to Yuan WangThis 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
@@ -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
v3 cover support to clear in-flight packets for async
In reply to Yuan WangThese 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
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
@@ -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
@@ -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
@@ -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
@@ -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
PATCH v3 2/2 example/vhost: support to clear in-flight packets for async dequeue
In reply to Yuan WangThis 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
@@ -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
v4 cover support to clear in-flight packets for async
In reply to Yuan WangThese 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
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
@@ -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
@@ -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
@@ -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
@@ -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
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.
Signed-off-by Yuan Wang <[email protected]>--- 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@@ -288,7 +288,13 @@ The following is an overview of some key Vhost APIfunctions:
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 --gita/doc/guides/rel_notes/release_22_07.rstb/doc/guides/rel_notes/release_22_07.rst
indexc81383f4a3..2ca06b543c100644doc/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..1db2a10124100644lib/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 index4880b9a422..9329f88e79100644lib/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..a90ae3cb96100644lib/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
-0dev->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_tqueue_id,lib/vhost/virtio_net.c +13
-0return 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 virtqueueidx %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 forqueue 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
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 dequeueHi 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
Signed-off-by Yuan Wang <[email protected]>--- 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@@ -288,7 +288,13 @@ The following is an overview of some key VhostAPI
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 areBetter 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 --gita/doc/guides/rel_notes/release_22_07.rstb/doc/guides/rel_notes/release_22_07.rst
indexc81383f4a3..2ca06b543c100644doc/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
-0index
a1e7f674ed..1db2a10124100644lib/vhost/rte_vhost_async.h +0
-0@@ -183,6 +183,31 @@ uint16_trte_vhost_clear_queue_thread_unsafe(int
Quoted 71 lines
lib/vhost/rte_vhost_async.h +24
-0vid, 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..9329f88e79100644lib/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..a90ae3cb96100644lib/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_tqueue_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 notsupport 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_tqueue_id, returnn_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 forqueue 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_idis 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
PATCH v4 2/2 example/vhost: support to clear in-flight packets for async dequeue
In reply to Yuan WangThis 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
@@ -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
v5 cover support to clear in-flight packets for async
In reply to Yuan WangThese 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
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
@@ -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
@@ -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
@@ -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
@@ -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
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
Signed-off-by Yuan Wang <[email protected]>--- 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
RE: [PATCH v5 1/2] vhost: support clear in-flight packets for async dequeue
In reply to Yuan WangQuoted 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
Signed-off-by Yuan Wang <[email protected]>--- 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
PATCH v5 2/2 example/vhost: support to clear in-flight packets for async dequeue
In reply to Yuan WangThis 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
@@ -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
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 indestroy_device().Signed-off-by Yuan Wang <[email protected]>--- examples/vhost/main.c | 26 +++++++++++++++++++++----- 1 file changed, 21 insertions(+), 5 deletions(-)
Thanks,
Maxime
RE: [PATCH v5 2/2] example/vhost: support to clear in-flight packets for async dequeue
In reply to Yuan WangThanks,
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 dequeueThis patch allows
vring_state_changed()to clear in-flight dequeue packets. It also clears the in-flight packets in a thread-safe way indestroy_device().Signed-off-by Yuan Wang <[email protected]>--- 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..a679ef738c100644examples/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
-5vdev->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
Maxime Coquelin
AppliedQuoted 22 lines · Yuan Wang
These patches support to clear in-flight packets for async dequeue and introduce thread-safe version of this function.
v5:
- Adddma_idcheckv4:
- Rebase to latest DPDKv3:
- Rebase to latest DPDKv2:
- Use the thread-safe version indestroy_devicev1:
- Protect vq access with splitlockYuan 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