introduce asynchronous data path for vhost
cover introduce asynchronous data path for vhost
From: Patrick Fu <[email protected]>
Performing large memory copies usually takes up a major part of CPU cycles and becomes the hot spot in vhost-user enqueue operation. To offload expensive memory operations from the CPU, this patch set proposes to leverage DMA engines, e.g., I/OAT, a DMA engine in the Intel's processor, to accelerate large copies.
Large copies are offloaded from the CPU to the DMA in an asynchronous manner. The CPU just submits copy jobs to the DMA but without waiting for its copy completion. Thus, there is no CPU intervention during data transfer; we can save precious CPU cycles and improve the overall throughput for vhost-user based applications, like OVS. During packet transmission, it offloads large copies to the DMA and performs small copies by the CPU, due to startup overheads associated with the DMA.
This patch set construct a general framework that applications can leverage to attach DMA channels with vhost-user transmit queues. Four new RTE APIs are introduced to vhost library for applications to register and use the asynchronous data path. In addition, two new DMA operation callbacks are defined, by which vhost-user asynchronous data path can interact with DMA hardware. Currently only enqueue operation for split queue is implemented, but the frame is flexible to extend support for dequeue & packed queue.
Patrick Fu (2):
vhost: introduce async data path registration API
vhost: introduce async enqueue for split ring
lib/librte_vhost/Makefile | 3 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 172 ++++++++++++ lib/librte_vhost/socket.c | 20 ++ lib/librte_vhost/vhost.c | 74 ++++- lib/librte_vhost/vhost.h | 30 ++- lib/librte_vhost/vhost_user.c | 28 +- lib/librte_vhost/virtio_net.c | 538 ++++++++++++++++++++++++++++++++++++- 8 files changed, 857 insertions(+), 9 deletions(-) create mode 100644 lib/librte_vhost/rte_vhost_async.h
Signature · 1 line
1.8.3.1
PATCH 1/2 vhost: introduce async data path registration API
From: Patrick <[email protected]>
This patch introduces registration/un-registration APIs for async data path together with all required data structures and DMA callback function proto-types.
--- lib/librte_vhost/Makefile | 3 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 134 +++++++++++++++++++++++++++++++++++++ lib/librte_vhost/socket.c | 20 ++++++ lib/librte_vhost/vhost.c | 74 +++++++++++++++++++- lib/librte_vhost/vhost.h | 30 ++++++++- lib/librte_vhost/vhost_user.c | 28 ++++++-- 7 files changed, 283 insertions(+), 7 deletions(-) create mode 100644 lib/librte_vhost/rte_vhost_async.h
lib/librte_vhost/Makefile +2 -1
@@ -41,7 +41,8 @@ SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c iotlb.c socket.c vhost.c \ vhost_user.c virtio_net.c vdpa.c # install includes -SYMLINK-$(CONFIG_RTE_LIBRTE_VHOST)-include += rte_vhost.h rte_vdpa.h +SYMLINK-$(CONFIG_RTE_LIBRTE_VHOST)-include += rte_vhost.h rte_vdpa.h \ + rte_vhost_async.h # only compile vhost crypto when cryptodev is enabled ifeq ($(CONFIG_RTE_LIBRTE_CRYPTODEV),y)
lib/librte_vhost/rte_vhost.h +1 -0
@@ -35,6 +35,7 @@#define RTE_VHOST_USER_EXTBUF_SUPPORT (1ULL << 5)/* support only linear buffers (no chained mbufs) */ #define RTE_VHOST_USER_LINEARBUF_SUPPORT (1ULL << 6) +#define RTE_VHOST_USER_ASYNC_COPY (1ULL << 7)/** Protocol features. */ #ifndef VHOST_USER_PROTOCOL_F_MQ
lib/librte_vhost/rte_vhost_async.h new file +134 -0
134 lines not on this page · raw message
lib/librte_vhost/socket.c +20 -0
@@ -42,6 +42,7 @@ struct vhost_user_socket {bool use_builtin_virtio_net;bool extbuf;bool linearbuf; +bool async_copy;/* * The "supported_features" indicates the feature bits the
@@ -210,6 +211,7 @@ struct vhost_user {size_t size;struct vhost_user_connection *conn;int ret; +struct virtio_net *dev;if (vsocket ==NULL )return ;
@@ -241,6 +243,13 @@ struct vhost_user {if (vsocket->linearbuf)vhost_enable_linearbuf (vid); +if (vsocket->async_copy) { + dev =get_device (vid); + +if (dev) + dev->async_copy =1 ; + } +VHOST_LOG_CONFIG (INFO ,"new device, handle is %d\n" , vid);if (vsocket->notify_ops->new_connection) {
@@ -891,6 +900,17 @@ struct vhost_user_reconnect_list { goto out_mutex; } + vsocket->async_copy = flags &RTE_VHOST_USER_ASYNC_COPY ; + +if (vsocket->async_copy && + (flags & (RTE_VHOST_USER_IOMMU_SUPPORT | +RTE_VHOST_USER_POSTCOPY_SUPPORT ))) { +VHOST_LOG_CONFIG (ERR ,"error: enabling async copy and IOMMU " +"or post-copy feature simultaneously is not " +"supported\n" ); + goto out_mutex; + } +/* * Set the supported features correctly for the builtin vhost-user * net driver.
lib/librte_vhost/vhost.c +73 -1
84 lines not on this page · raw message
lib/librte_vhost/vhost.h +29 -1
@@ -23,6 +23,8 @@#include "rte_vhost.h" #include "rte_vdpa.h" +#include "rte_vhost_async.h" +/* Used to indicate that the device is running on a data core */ #define VIRTIO_DEV_RUNNING 1/* Used to indicate that the device is ready to operate */
@@ -39,6 +41,11 @@#define VHOST_LOG_CACHE_NR 32 +#define MAX_PKT_BURST 32 + +#define VHOST_MAX_ASYNC_IT (MAX_PKT_BURST * 2) +#define VHOST_MAX_ASYNC_VEC (BUF_VECTOR_MAX * 2) +#define PACKED_DESC_ENQUEUE_USED_FLAG (w) \ ((w) ? (VRING_DESC_F_AVAIL | VRING_DESC_F_USED | VRING_DESC_F_WRITE) : \ VRING_DESC_F_WRITE)
@@ -200,6 +207,25 @@ struct vhost_virtqueue { TAILQ_HEAD(, vhost_iotlb_entry) iotlb_list;int iotlb_cache_nr; TAILQ_HEAD(, vhost_iotlb_entry) iotlb_pending_list; + +/* operation callbacks for async dma */ +struct rte_vhost_async_channel_ops async_ops; + +struct iov_it it_pool[VHOST_MAX_ASYNC_IT ]; +struct iovec vec_pool[VHOST_MAX_ASYNC_VEC ]; + +/* async data transfer status */ +uintptr_t **async_pkts_pending; +#define ASYNC_PENDING_INFO_N_MSK 0xFFFF +#define ASYNC_PENDING_INFO_N_SFT 16 +uint64_t *async_pending_info; +uint16_t async_pkts_idx; +uint16_t async_pkts_inflight_n; + +/* vq async features */ +bool async_inorder; +bool async_registered; +uint16_t async_threshold; } __rte_cache_aligned;/* Old kernels have no such macros defined */
@@ -353,6 +379,7 @@ struct virtio_net {int16_t broadcast_rarp;uint32_t nr_vring;int dequeue_zero_copy; +int async_copy;int extbuf;int linearbuf;struct vhost_virtqueue *virtqueue[VHOST_MAX_QUEUE_PAIRS *2 ];
@@ -702,7 +729,8 @@ uint64_t translate_log_addr(struct virtio_net *dev, struct vhost_virtqueue *vq,/* Don't kick guest if we don't reach index specified by guest. */ if (dev->features & (1ULL <<VIRTIO_RING_F_EVENT_IDX )) {uint16_t old = vq->signalled_used; -uint16_t new = vq->last_used_idx; +uint16_t new = vq->async_pkts_inflight_n ? + vq->used->idx:vq->last_used_idx;bool signalled_used_valid = vq->signalled_used_valid; vq->signalled_used = new;
lib/librte_vhost/vhost_user.c +24 -4
@@ -464,12 +464,25 @@ }else {if (vq->shadow_used_split)rte_free (vq->shadow_used_split); +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + vq->shadow_used_split =rte_malloc (NULL , vq->size *sizeof (struct vring_used_elem ),RTE_CACHE_LINE_SIZE ); -if (!vq->shadow_used_split) { + vq->async_pkts_pending =rte_malloc (NULL , + vq->size *sizeof (uintptr_t ), +RTE_CACHE_LINE_SIZE ); + vq->async_pending_info =rte_malloc (NULL , + vq->size *sizeof (uint64_t ), +RTE_CACHE_LINE_SIZE ); +if (!vq->shadow_used_split || + !vq->async_pkts_pending || + !vq->async_pending_info) {VHOST_LOG_CONFIG (ERR , -"failed to allocate memory for shadow used ring.\n" ); +"failed to allocate memory for vq internal data.\n" );return RTE_VHOST_MSG_RESULT_ERR ; } }
@@ -1147,7 +1160,8 @@ goto err_mmap; } - populate = (dev->dequeue_zero_copy) ?MAP_POPULATE :0 ; + populate = (dev->dequeue_zero_copy || dev->async_copy) ? +MAP_POPULATE :0 ; mmap_addr =mmap (NULL , mmap_size,PROT_READ |PROT_WRITE ,MAP_SHARED | populate, fd,0 );
@@ -1162,7 +1176,7 @@ reg->host_user_addr = (uint64_t )(uintptr_t )mmap_addr + mmap_offset; -if (dev->dequeue_zero_copy) +if (dev->dequeue_zero_copy || dev->async_copy)if (add_guest_pages (dev, reg, alignment) <0 ) { VHOST_LOG_CONFIG(ERR, "adding guest pages to region %u failed.\n",
@@ -1945,6 +1959,12 @@ static int vhost_user_set_vring_err(struct virtio_net **pdev __rte_unused, }else {rte_free (vq->shadow_used_split); vq->shadow_used_split =NULL ; +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + vq->async_pkts_pending =NULL ; + vq->async_pending_info =NULL ; }rte_free (vq->batch_copy_elems);
Signature · 1 line
1.8.3.1
Re: [dpdk-dev] [PATCH v1 1/2] vhost: introduce async data path registration API
Thanks, Patrick. So comments are inline.
Quoted 35 lines
-----Original Message-----
From: dev <[email protected]> On Behalf Of [email protected]
Sent: Thursday, June 11, 2020 6:02 PM
To: [email protected]; [email protected]; Xia, Chenbo <[email protected]>; Wang, Zhihong <[email protected]>; Ye, Xiaolong <[email protected]>
Cc: Fu, Patrick <[email protected]>; Jiang, Cheng1 <[email protected]>; Liang, Cunming <[email protected]>
Subject: [dpdk-dev] [PATCH v1 1/2] vhost: introduce async data path registration APIFrom: Patrick <[email protected]>
This patch introduces registration/un-registration APIs for async data path together with all required data structures and DMA callback function proto-types.
Signed-off-by Patrick <[email protected]>--- lib/librte_vhost/Makefile | 3 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 134 +++++++++++++++++++++++++++++++++++++ lib/librte_vhost/socket.c | 20 ++++++ lib/librte_vhost/vhost.c | 74 +++++++++++++++++++- lib/librte_vhost/vhost.h | 30 ++++++++- lib/librte_vhost/vhost_user.c | 28 ++++++-- 7 files changed, 283 insertions(+), 7 deletions(-) create mode 100644 lib/librte_vhost/rte_vhost_async.hlib/librte_vhost/Makefile +0
-0
lib/librte_vhost/Makefile SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c · line 48
Quoted 9 lines
lib/librte_vhost/Makefile +2
-1@@ -41,7 +41,8 @@ SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c iotlb.c socket.c vhost.c \ vhost_user.c virtio_net.c vdpa.c # install includes -SYMLINK-$(CONFIG_RTE_LIBRTE_VHOST)-include += rte_vhost.h rte_vdpa.h +SYMLINK-$(CONFIG_RTE_LIBRTE_VHOST)-include += rte_vhost.h rte_vdpa.h \ + rte_vhost_async.h
Hi Patrick,
Please also update meson build for newly added file.
Thanks,
Marvin
Quoted 21 lines
# only compile vhost crypto when cryptodev is enabled ifeq ($(CONFIG_RTE_LIBRTE_CRYPTODEV),y)lib/librte_vhost/rte_vhost.h +1
-0@@ -35,6 +35,7 @@#define RTE_VHOST_USER_EXTBUF_SUPPORT (1ULL << 5)/* support only linear buffers (no chained mbufs) */ #define RTE_VHOST_USER_LINEARBUF_SUPPORT (1ULL << 6) +#define RTE_VHOST_USER_ASYNC_COPY (1ULL << 7)/** Protocol features. */ #ifndef VHOST_USER_PROTOCOL_F_MQ lib/librte_vhost/rte_vhost_async.h new file +0
-0
lib/librte_vhost/rte_vhost_async.h line 3
Quoted 3 lines
lib/librte_vhost/rte_vhost_async.h new file +3
-0@@ -0,0 +1,134 @@ +/* SPDX-License-Identifier: BSD-3-Clause +* Copyright(c) 2018 Intel Corporation +*/
s/2018/2020/
Quoted 9 lines
lib/librte_vhost/rte_vhost_async.h new file +9
-0+ +#ifndef _RTE_VHOST_ASYNC_H_ +#define _RTE_VHOST_ASYNC_H_ + +#include "rte_vhost.h" + +/** +* iovec iterator +*/
lib/librte_vhost/rte_vhost_async.h line 22
Quoted 10 lines
lib/librte_vhost/rte_vhost_async.h new file +10
-0+struct iov_it { +/** offset to the first byte of interesting data */ +size_t offset; +/** total bytes of data in this iterator */ +size_t count; +/** pointer to the iovec array */ +struct iovec *iov; +/** number of iovec in this iterator */ +unsigned long nr_segs; +};
Patrick,
I think structure named as "it" is too generic for understanding, please use more meaningful name like "iov_iter".
lib/librte_vhost/rte_vhost_async.h line 33
Quoted 11 lines
lib/librte_vhost/rte_vhost_async.h new file +11
-0+ +/** +* dma transfer descriptor pair +*/ +struct dma_trans_desc { +/** source memory iov_it */ +struct iov_it *src; +/** destination memory iov_it */ +struct iov_it *dst; +}; +
This series patch named as sync copy, and dma is just one async copy method which underneath hardware supplied. IMHO, structure is better to named as "async_copy_desc" which matched the overall concept.
lib/librte_vhost/rte_vhost_async.h line 43
Quoted 10 lines
lib/librte_vhost/rte_vhost_async.h new file +10
-0+/** +* dma transfer status +*/ +struct dma_trans_status { +/** An array of application specific data for source memory */ +uintptr_t *src_opaque_data; +/** An array of application specific data for destination memory */ +uintptr_t *dst_opaque_data; +}; +
Same as pervious comment.
Quoted 47 lines
lib/librte_vhost/rte_vhost_async.h new file +47
-0+/** +* dma operation callbacks to be implemented by applications +*/ +struct rte_vhost_async_channel_ops { +/** +* instruct a DMA channel to perform copies for a batch of packets +* +* @param vid +* id of vhost device to perform data copies +* @param queue_id +* queue id to perform data copies +* @param descs +* an array of DMA transfer memory descriptors +* @param opaque_data +* opaque data pair sending to DMA engine +* @param count +* number of elements in the "descs" array +* @return +* -1 on failure, number of descs processed on success +*/ +int (*transfer_data)(int vid,uint16_t queue_id, +struct dma_trans_desc *descs, +struct dma_trans_status *opaque_data, +uint16_t count); +/** +* check copy-completed packets from a DMA channel +* @param vid +* id of vhost device to check copy completion +* @param queue_id +* queue id to check copyp completion +* @param opaque_data +* buffer to receive the opaque data pair from DMA engine +* @param max_packets +* max number of packets could be completed +* @return +* -1 on failure, number of iov segments completed on success +*/ +int (*check_completed_copies)(int vid,uint16_t queue_id, +struct dma_trans_status *opaque_data, +uint16_t max_packets); +}; + +/** +* dma channel feature bit definition +*/ +struct dma_channel_features { + union {
lib/librte_vhost/rte_vhost_async.h line 100
Quoted 10 lines
lib/librte_vhost/rte_vhost_async.h new file +10
-0+uint32_t intval; +struct { +uint32_t inorder:1 ; +uint32_t resvd0115:15 ; +uint32_t threshold:12 ; +uint32_t resvd2831:4 ; + }; + }; +}; +
Naming feature bits as "intval" may cause confusion, why not just use its meaning like "engine_features"?
I'm not sure whether format "resvd0115" match dpdk copy style. In my mind, dpdk will use resvd_0 and resvd_1 for two reserved elements.
Quoted 55 lines
lib/librte_vhost/rte_vhost_async.h new file +34
-0+/** +* register a dma channel for vhost +* +* @param vid +* vhost device id DMA channel to be attached to +* @param queue_id +* vhost queue id DMA channel to be attached to +* @param features +* DMA channel feature bit +* b0 : DMA supports inorder data transfer +* b1 - b15: reserved +* b16 - b27: Packet length threshold for DMA transfer +* b28 - b31: reserved +* @param ops +* DMA operation callbacks +* @return +* 0 on success, -1 on failures +*/ +int rte_vhost_async_channel_register (int vid,uint16_t queue_id, +uint32_t features,struct rte_vhost_async_channel_ops *ops); + +/** +* unregister a dma channel for vhost +* +* @param vid +* vhost device id DMA channel to be detached +* @param queue_id +* vhost queue id DMA channel to be detached +* @return +* 0 on success, -1 on failures +*/ +int rte_vhost_async_channel_unregister (int vid,uint16_t queue_id); + +#endif /* _RTE_VDPA_H_ */ lib/librte_vhost/socket.c +2
-0@@ -42,6 +42,7 @@ struct vhost_user_socket {bool use_builtin_virtio_net;bool extbuf;bool linearbuf; +bool async_copy;/* * The "supported_features" indicates the feature bits the @@ -210,6 +211,7 @@ struct vhost_user {size_t size;struct vhost_user_connection *conn;int ret; +struct virtio_net *dev;if (vsocket ==NULL )return ;
lib/librte_vhost/socket.c struct vhost_user { · line 252
Quoted 10 lines
lib/librte_vhost/socket.c +7
-0@@ -241,6 +243,13 @@ struct vhost_user {if (vsocket->linearbuf)vhost_enable_linearbuf (vid); +if (vsocket->async_copy) { + dev =get_device (vid); + +if (dev) + dev->async_copy =1 ; + } +
IMHO, user can chose which queue utilize async copy as backend hardware resource is limited. So should async_copy enable flag be saved in virtqueue structure?
Quoted 60 lines
lib/librte_vhost/socket.c +6
-0VHOST_LOG_CONFIG (INFO ,"new device, handle is %d\n" , vid);if (vsocket->notify_ops->new_connection) {@@ -891,6 +900,17 @@ struct vhost_user_reconnect_list { goto out_mutex; } + vsocket->async_copy = flags &RTE_VHOST_USER_ASYNC_COPY ; + +if (vsocket->async_copy && + (flags & (RTE_VHOST_USER_IOMMU_SUPPORT | +RTE_VHOST_USER_POSTCOPY_SUPPORT ))) { + VHOST_LOG_CONFIG(ERR, "error: enabling async copy andIOMMU "
lib/librte_vhost/socket.c +5
-0+"or post-copy feature simultaneously is not " + "supported\n"); + goto out_mutex; + } +/* * Set the supported features correctly for the builtin vhost-user * net driver. lib/librte_vhost/vhost.c +10
-1@@ -332,8 +332,13 @@ {if (vq_is_packed (dev))rte_free (vq->shadow_used_packed); -else +else {rte_free (vq->shadow_used_split); +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + }rte_free (vq->batch_copy_elems);rte_mempool_free (vq->iotlb_pool);rte_free (vq);@@ -1527,3 +1532,70 @@ int rte_vhost_extern_callback_register(int vid,if (vhost_data_log_level >=0 )rte_log_set_level (vhost_data_log_level,RTE_LOG_WARNING ); } + +int rte_vhost_async_channel_register (int vid,uint16_t queue_id, +uint32_t features, + struct rte_vhost_async_channel_ops*ops)
lib/librte_vhost/vhost.c +9
-0+{ +struct vhost_virtqueue *vq; +struct virtio_net *dev =get_device (vid); +struct dma_channel_features f; + +if (dev ==NULL || ops ==NULL ) +return -1 ; + + f.intval = features;
lib/librte_vhost/vhost.c int rte_vhost_extern_callback_register(int vid, · line 1557
Quoted 10 lines
lib/librte_vhost/vhost.c +10
-0+ + vq = dev->virtqueue[queue_id]; + +if (vq ==NULL ) +return -1 ; + +/** packed queue is not supported */ +if (vq_is_packed (dev) || !f.inorder) +return -1 ; +
Virtio already has in_order concept, these two names are so like and can be easily messed up. Please consider how to distinguish them.
lib/librte_vhost/vhost.c int rte_vhost_extern_callback_register(int vid, · line 1561
Quoted 4 lines
lib/librte_vhost/vhost.c +4
-0+if (ops->check_completed_copies ==NULL || + ops->transfer_data ==NULL ) +return -1 ; +
Previous error is unlikely to be true, unlikely macro may be helpful for understanding.
Quoted 133 lines
lib/librte_vhost/vhost.c +3
-0+rte_spinlock_lock (&vq->access_lock); + + vq->async_ops.check_completed_copies = ops-Quoted 1 line
check_completed_copies;lib/librte_vhost/vhost.c +37
-0+ vq->async_ops.transfer_data = ops->transfer_data; + + vq->async_inorder = f.inorder; + vq->async_threshold = f.threshold; + + vq->async_registered = true; + +rte_spinlock_unlock (&vq->access_lock); + +return 0 ; +} + +int rte_vhost_async_channel_unregister (int vid,uint16_t queue_id) +{ +struct vhost_virtqueue *vq; +struct virtio_net *dev =get_device (vid); + +if (dev ==NULL ) +return -1 ; + + vq = dev->virtqueue[queue_id]; + +if (vq ==NULL ) +return -1 ; + +rte_spinlock_lock (&vq->access_lock); + + vq->async_ops.transfer_data =NULL ; + vq->async_ops.check_completed_copies =NULL ; + + vq->async_registered = false; + +rte_spinlock_unlock (&vq->access_lock); + +return 0 ; +} +lib/librte_vhost/vhost.h +7
-0@@ -23,6 +23,8 @@#include "rte_vhost.h" #include "rte_vdpa.h" +#include "rte_vhost_async.h" +/* Used to indicate that the device is running on a data core */ #define VIRTIO_DEV_RUNNING 1/* Used to indicate that the device is ready to operate */ @@ -39,6 +41,11 @@#define VHOST_LOG_CACHE_NR 32 +#define MAX_PKT_BURST 32 + +#define VHOST_MAX_ASYNC_IT (MAX_PKT_BURST * 2) +#define VHOST_MAX_ASYNC_VEC (BUF_VECTOR_MAX * 2) +#define PACKED_DESC_ENQUEUE_USED_FLAG (w) \ ((w) ? (VRING_DESC_F_AVAIL | VRING_DESC_F_USED | VRING_DESC_F_WRITE) : \lib/librte_vhost/vhost.h +22
-1VRING_DESC_F_WRITE)@@ -200,6 +207,25 @@ struct vhost_virtqueue { TAILQ_HEAD(, vhost_iotlb_entry) iotlb_list;int iotlb_cache_nr; TAILQ_HEAD(, vhost_iotlb_entry) iotlb_pending_list; + +/* operation callbacks for async dma */ +struct rte_vhost_async_channel_ops async_ops; + +struct iov_it it_pool[VHOST_MAX_ASYNC_IT ]; +struct iovec vec_pool[VHOST_MAX_ASYNC_VEC ]; + +/* async data transfer status */ +uintptr_t **async_pkts_pending; +#define ASYNC_PENDING_INFO_N_MSK 0xFFFF +#define ASYNC_PENDING_INFO_N_SFT 16 +uint64_t *async_pending_info; +uint16_t async_pkts_idx; +uint16_t async_pkts_inflight_n; + +/* vq async features */ +bool async_inorder; +bool async_registered; +uint16_t async_threshold; } __rte_cache_aligned;/* Old kernels have no such macros defined */ @@ -353,6 +379,7 @@ struct virtio_net {int16_t broadcast_rarp;uint32_t nr_vring;int dequeue_zero_copy; +int async_copy;int extbuf;int linearbuf;struct vhost_virtqueue *virtqueue[VHOST_MAX_QUEUE_PAIRS *2 ];@@ -702,7 +729,8 @@ uint64_t translate_log_addr(struct virtio_net *dev,struct vhost_virtqueue *vq,/* Don't kick guest if we don't reach index specified by guest. */ if (dev->features & (1ULL << VIRTIO_RING_F_EVENT_IDX)) { uint16_t old = vq->signalled_used; -uint16_t new = vq->last_used_idx; +uint16_t new = vq->async_pkts_inflight_n ? + vq->used->idx:vq->last_used_idx;bool signalled_used_valid = vq->signalled_used_valid;lib/librte_vhost/vhost.h +0
-0vq->signalled_used = new;lib/librte_vhost/vhost_user.c +9
-1@@ -464,12 +464,25 @@ }else {if (vq->shadow_used_split)rte_free (vq->shadow_used_split); +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + vq->shadow_used_split =rte_malloc (NULL , vq->size *sizeof (struct vring_used_elem ),RTE_CACHE_LINE_SIZE ); -if (!vq->shadow_used_split) { + vq->async_pkts_pending =rte_malloc (NULL , + vq->size *sizeof (uintptr_t ), +RTE_CACHE_LINE_SIZE ); + vq->async_pending_info = rte_malloc(NULL,
lib/librte_vhost/vhost_user.c line 487
Quoted 10 lines
lib/librte_vhost/vhost_user.c +6
-1+ vq->size *sizeof (uint64_t ), + RTE_CACHE_LINE_SIZE); +if (!vq->shadow_used_split || + !vq->async_pkts_pending || + !vq->async_pending_info) {VHOST_LOG_CONFIG (ERR , - "failed to allocate memory for shadow used ring.\n"); +" failed to allocate memory for vq internal data.\n");
If async copy not enabled, there will be no need to allocate related structures.
Quoted 40 lines
lib/librte_vhost/vhost_user.c +0
-0return RTE_VHOST_MSG_RESULT_ERR ;lib/librte_vhost/vhost_user.c +3
-2} }@@ -1147,7 +1160,8 @@ goto err_mmap; } - populate = (dev->dequeue_zero_copy) ?MAP_POPULATE :0 ; + populate = (dev->dequeue_zero_copy || dev->async_copy) ? +MAP_POPULATE :0 ; mmap_addr =mmap (NULL , mmap_size,PROT_READ |PROT_WRITE ,MAP_SHARED | populate, fd,0 );@@ -1162,7 +1176,7 @@ reg->host_user_addr = (uint64_t )(uintptr_t )mmap_addr + mmap_offset; -if (dev->dequeue_zero_copy) +if (dev->dequeue_zero_copy || dev->async_copy)if (add_guest_pages (dev, reg, alignment) <0 ) { VHOST_LOG_CONFIG(ERR, "adding guest pages to region %ufailed.\n",
lib/librte_vhost/vhost_user.c +6
-0@@ -1945,6 +1959,12 @@ static int vhost_user_set_vring_err(struct virtio_net **pdev __rte_unused, }else {rte_free (vq->shadow_used_split); vq->shadow_used_split =NULL ; +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + vq->async_pkts_pending =NULL ; + vq->async_pending_info =NULL ; }
rte_free(vq->batch_copy_elems);
--
1.8.3.1
Re: [dpdk-dev] [PATCH v1 1/2] vhost: introduce async data path registration API
Quoted 200 lines
-----Original Message-----
From: Liu, Yong <[email protected]>
Sent: Thursday, June 18, 2020 1:51 PM
To: Fu, Patrick <[email protected]>
Cc: Fu, Patrick <[email protected]>; Jiang, Cheng1 <[email protected]>; Liang, Cunming <[email protected]>; [email protected]; [email protected]; Xia, Chenbo <[email protected]>; Wang, Zhihong <[email protected]>; Ye, Xiaolong <[email protected]>
Subject: RE: [dpdk-dev] [PATCH v1 1/2] vhost: introduce async data path registration APIThanks, Patrick. So comments are inline.
lib/librte_vhost/Makefile SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c
Quoted 35 lines
-----Original Message-----
From: dev <[email protected]> On Behalf Of [email protected]
Sent: Thursday, June 11, 2020 6:02 PM
To: [email protected]; [email protected]; Xia, Chenbo <[email protected]>; Wang, Zhihong <[email protected]>; Ye, Xiaolong <[email protected]>
Cc: Fu, Patrick <[email protected]>; Jiang, Cheng1 <[email protected]>; Liang, Cunming <[email protected]>
Subject: [dpdk-dev] [PATCH v1 1/2] vhost: introduce async data path registration APIFrom: Patrick <[email protected]>
This patch introduces registration/un-registration APIs for async data path together with all required data structures and DMA callback function proto-types.
Signed-off-by Patrick <[email protected]>--- lib/librte_vhost/Makefile | 3 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 134 +++++++++++++++++++++++++++++++++++++ lib/librte_vhost/socket.c | 20 ++++++ lib/librte_vhost/vhost.c | 74 +++++++++++++++++++- lib/librte_vhost/vhost.h | 30 ++++++++- lib/librte_vhost/vhost_user.c | 28 ++++++-- 7 files changed, 283 insertions(+), 7 deletions(-) create mode100644
lib/librte_vhost/rte_vhost_async.hlib/librte_vhost/Makefile +0
-0@@ -41,7 +41,8 @@ SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c
iotlb.clib/librte_vhost/Makefile SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c iotlb.c socket.c vhost.c \
Quoted 5 lines
lib/librte_vhost/Makefile +0
-1socket.c vhost.c \ vhost_user.c virtio_net.c vdpa.c # install includes -SYMLINK-$(CONFIG_RTE_LIBRTE_VHOST)-include += rte_vhost.h
rte_vdpa.hlib/librte_vhost/Makefile SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c · line 45
Quoted 1 line
lib/librte_vhost/Makefile +1
-0+SYMLINK-$(CONFIG_RTE_LIBRTE_VHOST)-include += rte_vhost.h
rte_vdpa.hlib/librte_vhost/Makefile SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c iotlb.c socket.c vhost.c \ · line 46
Quoted 3 lines
lib/librte_vhost/Makefile +1
-0\ + rte_vhost_async.hHi Patrick,
Please also update meson build for newly added file.Thanks,
MarvinQuoted 21 lines
# only compile vhost crypto when cryptodev is enabled ifeq ($(CONFIG_RTE_LIBRTE_CRYPTODEV),y)(quoted diff) +0
-0
b/lib/librte_vhost/rte_vhost.hindex d43669f..cec4d07 100644lib/librte_vhost/rte_vhost.h +1
-0@@ -35,6 +35,7 @@#define RTE_VHOST_USER_EXTBUF_SUPPORT (1ULL << 5)/* support only linear buffers (no chained mbufs) */ #define RTE_VHOST_USER_LINEARBUF_SUPPORT (1ULL << 6) +#define RTE_VHOST_USER_ASYNC_COPY (1ULL << 7)/** Protocol features. */ #ifndef VHOST_USER_PROTOCOL_F_MQ lib/librte_vhost/rte_vhost_async.h new file +0
-0lib/librte_vhost/rte_vhost_async.h line 2
Quoted 2 lines
lib/librte_vhost/rte_vhost_async.h new file +2
-0@@ -0,0 +1,134 @@ +/* SPDX-License-Identifier: BSD-3-Clause +* Copyright(c) 2018 Intel Corporation */ s/2018/2020/
Quoted 9 lines
lib/librte_vhost/rte_vhost_async.h new file +9
-0+ +#ifndef _RTE_VHOST_ASYNC_H_ +#define _RTE_VHOST_ASYNC_H_ + +#include "rte_vhost.h" + +/** +* iovec iterator +*/ lib/librte_vhost/rte_vhost_async.h line 22
Quoted 10 lines
lib/librte_vhost/rte_vhost_async.h new file +10
-0+struct iov_it { +/** offset to the first byte of interesting data */ +size_t offset; +/** total bytes of data in this iterator */ +size_t count; +/** pointer to the iovec array */ +struct iovec *iov; +/** number of iovec in this iterator */ +unsigned long nr_segs; +};Patrick,
I think structure named as "it" is too generic for understanding, please use more meaningful name like "iov_iter".lib/librte_vhost/rte_vhost_async.h line 33
Quoted 11 lines
lib/librte_vhost/rte_vhost_async.h new file +11
-0+ +/** +* dma transfer descriptor pair +*/ +struct dma_trans_desc { +/** source memory iov_it */ +struct iov_it *src; +/** destination memory iov_it */ +struct iov_it *dst; +}; +This series patch named as sync copy, and dma is just one async copy method which underneath hardware supplied.
IMHO, structure is better to named as "async_copy_desc" which matched the overall concept.lib/librte_vhost/rte_vhost_async.h line 43
Quoted 10 lines
lib/librte_vhost/rte_vhost_async.h new file +10
-0+/** +* dma transfer status +*/ +struct dma_trans_status { +/** An array of application specific data for source memory */ +uintptr_t *src_opaque_data; +/** An array of application specific data for destination memory */ +uintptr_t *dst_opaque_data; +}; +Same as pervious comment.
Quoted 52 lines
lib/librte_vhost/rte_vhost_async.h new file +52
-0+/** +* dma operation callbacks to be implemented by applications */ +struct rte_vhost_async_channel_ops { +/** +* instruct a DMA channel to perform copies for a batch of packets +* +* @param vid +* id of vhost device to perform data copies +* @param queue_id +* queue id to perform data copies +* @param descs +* an array of DMA transfer memory descriptors +* @param opaque_data +* opaque data pair sending to DMA engine +* @param count +* number of elements in the "descs" array +* @return +* -1 on failure, number of descs processed on success +*/ +int (*transfer_data)(int vid,uint16_t queue_id, +struct dma_trans_desc *descs, +struct dma_trans_status *opaque_data, +uint16_t count); +/** +* check copy-completed packets from a DMA channel +* @param vid +* id of vhost device to check copy completion +* @param queue_id +* queue id to check copyp completion +* @param opaque_data +* buffer to receive the opaque data pair from DMA engine +* @param max_packets +* max number of packets could be completed +* @return +* -1 on failure, number of iov segments completed on success +*/ +int (*check_completed_copies)(int vid,uint16_t queue_id, +struct dma_trans_status *opaque_data, +uint16_t max_packets); +}; + +/** +* dma channel feature bit definition */ struct +dma_channel_features { +union { +uint32_t intval; +struct { +uint32_t inorder:1 ; +uint32_t resvd0115:15 ; +uint32_t threshold:12 ; +uint32_t resvd2831:4 ; + };
Quoted 9 lines
lib/librte_vhost/rte_vhost_async.h line 33
Quoted 3 lines
lib/librte_vhost/rte_vhost_async.h new file +3
-0+ }; +}; +Naming feature bits as "intval" may cause confusion, why not just use its meaning like "
engine_features"?
I'm not sure whether format "resvd0115" match dpdk copy style. In my mind, dpdk will useresvd_0andresvd_1for two reserved elements.
For comments here above, I will take changes in v2 patch
Quoted 9 lines
lib/librte_vhost/rte_vhost_async.h line 101
Quoted 4 lines
lib/librte_vhost/rte_vhost_async.h new file +4
-0+if (dev) + dev->async_copy =1 ; + } +IMHO, user can chose which queue utilize async copy as backend hardware resource is limited.
So shouldasync_copyenable flag be saved in virtqueue structure?
We have per queue flag to identify the enabling status of a specific queue.
"async_copy" flag is a dev level flag which identifies the async capability of a vhost device.
This is necessary because we rely on this flag to do initialization work if the vhost backend need to support async mode at any of its queues.
Quoted 64 lines
Quoted 64 lines
lib/librte_vhost/rte_vhost_async.h new file +0
-0VHOST_LOG_CONFIG (INFO ,"new device, handle is %d\n" , vid); if (vsocket->notify_ops->new_connection) { @@ -891,6 +900,17 @@struct
vhost_user_reconnect_list{lib/librte_vhost/rte_vhost_async.h new file +6
-0goto out_mutex; } + vsocket->async_copy = flags &RTE_VHOST_USER_ASYNC_COPY ; + +if (vsocket->async_copy && + (flags & (RTE_VHOST_USER_IOMMU_SUPPORT | +RTE_VHOST_USER_POSTCOPY_SUPPORT ))) { + VHOST_LOG_CONFIG(ERR, "error: enabling async copy andIOMMU "
lib/librte_vhost/rte_vhost_async.h new file +5
-0+"or post-copy feature simultaneously is not " + "supported\n"); + goto out_mutex; + } +/* * Set the supported features correctly for the builtin vhost-user * net driver. lib/librte_vhost/vhost.c index renamed from lib/librte_vhost/vhost.c +0
-00266318..e6b688a 100644
lib/librte_vhost/vhost.c +10
-1@@ -332,8 +332,13 @@ {if (vq_is_packed (dev))rte_free (vq->shadow_used_packed); -else +else {rte_free (vq->shadow_used_split); +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + }rte_free (vq->batch_copy_elems);rte_mempool_free (vq->iotlb_pool);rte_free (vq);@@ -1527,3 +1532,70 @@ int rte_vhost_extern_callback_register(int vid,if (vhost_data_log_level >=0 )rte_log_set_level (vhost_data_log_level,RTE_LOG_WARNING ); } + +int rte_vhost_async_channel_register (int vid,uint16_t queue_id, +uint32_t features, + struct rte_vhost_async_channel_ops*ops)
lib/librte_vhost/vhost.c +13
-0+{ +struct vhost_virtqueue *vq; +struct virtio_net *dev =get_device (vid); +struct dma_channel_features f; + +if (dev ==NULL || ops ==NULL ) +return -1 ; + + f.intval = features; + + vq = dev->virtqueue[queue_id]; + +if (vq ==NULL )
Quoted 9 lines
lib/librte_vhost/vhost.c int rte_vhost_extern_callback_register(int vid, · line 1557
Quoted 6 lines
lib/librte_vhost/vhost.c +6
-0+return -1 ; + +/** packed queue is not supported */ +if (vq_is_packed (dev) || !f.inorder) +return -1 ; +Virtio already has
in_orderconcept, these two names are so like and can be easily messed up. Please consider how to distinguish them.
What about "async_inorder"
Quoted 8 lines
lib/librte_vhost/vhost.c int rte_vhost_extern_callback_register(int vid, · line 1561
Quoted 4 lines
lib/librte_vhost/vhost.c +4
-0+if (ops->check_completed_copies ==NULL || + ops->transfer_data ==NULL ) +return -1 ; +Previous error is unlikely to be true, unlikely macro may be helpful for understanding.
Will update in v2 patch
Quoted 136 lines
Quoted 136 lines
lib/librte_vhost/vhost.c +3
-0+rte_spinlock_lock (&vq->access_lock); + + vq->async_ops.check_completed_copies = ops-Quoted 1 line
check_completed_copies;lib/librte_vhost/vhost.c +36
-0+ vq->async_ops.transfer_data = ops->transfer_data; + + vq->async_inorder = f.inorder; + vq->async_threshold = f.threshold; + + vq->async_registered = true; + +rte_spinlock_unlock (&vq->access_lock); + +return 0 ; +} + +int rte_vhost_async_channel_unregister (int vid,uint16_t queue_id) { +struct vhost_virtqueue *vq; +struct virtio_net *dev =get_device (vid); + +if (dev ==NULL ) +return -1 ; + + vq = dev->virtqueue[queue_id]; + +if (vq ==NULL ) +return -1 ; + +rte_spinlock_lock (&vq->access_lock); + + vq->async_ops.transfer_data =NULL ; + vq->async_ops.check_completed_copies =NULL ; + + vq->async_registered = false; + +rte_spinlock_unlock (&vq->access_lock); + +return 0 ; +} +lib/librte_vhost/vhost.h index renamed from lib/librte_vhost/vhost.h +0
-0df98d15..a7fbe23 100644
lib/librte_vhost/vhost.h +8
-0@@ -23,6 +23,8 @@#include "rte_vhost.h" #include "rte_vdpa.h" +#include "rte_vhost_async.h" +/* Used to indicate that the device is running on a data core */ #define VIRTIO_DEV_RUNNING 1 /* Used to indicate that the device is ready to operate */ @@ -39,6 +41,11 @@#define VHOST_LOG_CACHE_NR 32 +#define MAX_PKT_BURST 32 + +#define VHOST_MAX_ASYNC_IT (MAX_PKT_BURST * 2) #define +VHOST_MAX_ASYNC_VEC (BUF_VECTOR_MAX * 2) +#define PACKED_DESC_ENQUEUE_USED_FLAG (w) \ ((w) ? (VRING_DESC_F_AVAIL | VRING_DESC_F_USED |
VRING_DESC_F_WRITE) : \lib/librte_vhost/vhost.h +19
-0VRING_DESC_F_WRITE)@@ -200,6 +207,25 @@ struct vhost_virtqueue { TAILQ_HEAD(, vhost_iotlb_entry) iotlb_list;int iotlb_cache_nr; TAILQ_HEAD(, vhost_iotlb_entry) iotlb_pending_list; + +/* operation callbacks for async dma */ +struct rte_vhost_async_channel_ops async_ops; + +struct iov_it it_pool[VHOST_MAX_ASYNC_IT ]; +struct iovec vec_pool[VHOST_MAX_ASYNC_VEC ]; + +/* async data transfer status */ +uintptr_t **async_pkts_pending; +#define ASYNC_PENDING_INFO_N_MSK 0xFFFF +#define ASYNC_PENDING_INFO_N_SFT 16 +uint64_t *async_pending_info; +uint16_t async_pkts_idx; +uint16_t async_pkts_inflight_n; + +/* vq async features */ +bool async_inorder; +bool async_registered; +uint16_t async_threshold; } __rte_cache_aligned; /* Old kernels have no such macros defined */ @@ -353,6 +379,7 @@struct
virtio_net{lib/librte_vhost/vhost.h +3
-1int16_t broadcast_rarp;uint32_t nr_vring;int dequeue_zero_copy; +int async_copy;int extbuf;int linearbuf;struct vhost_virtqueue *virtqueue[VHOST_MAX_QUEUE_PAIRS *2 ];@@ -702,7 +729,8 @@ uint64_t translate_log_addr(struct virtio_net *dev, struct vhost_virtqueue *vq,/* Don't kick guest if we don't reach index specified by guest. */ if (dev->features & (1ULL << VIRTIO_RING_F_EVENT_IDX)) {uint16_t old = vq->signalled_used; -uint16_t new = vq->last_used_idx; +uint16_t new = vq->async_pkts_inflight_n ? + vq->used->idx:vq->last_used_idx;bool signalled_used_valid = vq->signalled_used_valid;lib/librte_vhost/vhost.h +0
-0vq->signalled_used = new;(quoted diff) +0
-0
b/lib/librte_vhost/vhost_user.cindex 84bebad..d7600bf 100644lib/librte_vhost/vhost_user.c +13
-1@@ -464,12 +464,25 @@ }else {if (vq->shadow_used_split)rte_free (vq->shadow_used_split); +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + vq->shadow_used_split =rte_malloc (NULL , vq->size *sizeof (struct vring_used_elem ),RTE_CACHE_LINE_SIZE ); -if (!vq->shadow_used_split) { + vq->async_pkts_pending =rte_malloc (NULL , + vq->size *sizeof (uintptr_t ), +RTE_CACHE_LINE_SIZE ); + vq->async_pending_info =rte_malloc (NULL , + vq->size *sizeof (uint64_t ), +RTE_CACHE_LINE_SIZE ); + if (!vq->shadow_used_split || + !vq->async_pkts_pending ||
Quoted 9 lines
lib/librte_vhost/vhost_user.c line 487
Quoted 6 lines
lib/librte_vhost/vhost_user.c +2
-1+ !vq->async_pending_info) {VHOST_LOG_CONFIG (ERR , - "failed to allocate memory for shadow used ring.\n"); +" failed to allocate memory for vq internal data.\n");If async copy not enabled, there will be no need to allocate related structures.
Will update in v2 patch
Thanks,
Patrick
Re: [dpdk-dev] [PATCH v1 1/2] vhost: introduce async data path registration API
Quoted 235 lines
-----Original Message-----
From: Fu, Patrick <[email protected]>
Sent: Thursday, June 18, 2020 5:09 PM
To: Liu, Yong <[email protected]>
Cc: Jiang, Cheng1 <[email protected]>; Liang, Cunming <[email protected]>; [email protected]; [email protected]; Xia, Chenbo <[email protected]>; Wang, Zhihong <[email protected]>; Ye, Xiaolong <[email protected]>
Subject: RE: [dpdk-dev] [PATCH v1 1/2] vhost: introduce async data path registration APIQuoted 12 lines
-----Original Message-----
From: Liu, Yong <[email protected]>
Sent: Thursday, June 18, 2020 1:51 PM
To: Fu, Patrick <[email protected]>
Cc: Fu, Patrick <[email protected]>; Jiang, Cheng1 <[email protected]>; Liang, Cunming <[email protected]>; [email protected]; [email protected]; Xia, Chenbo <[email protected]>; Wang, Zhihong <[email protected]>; Ye, Xiaolong <[email protected]>
Subject: RE: [dpdk-dev] [PATCH v1 1/2] vhost: introduce async data path registration APIQuoted 7 lines
Thanks, Patrick. So comments are inline.
Quoted 5 lines
-----Original Message-----
From: dev <[email protected]> On Behalf Of [email protected]
Sent: Thursday, June 11, 2020 6:02 PM
To: [email protected]; [email protected]; Xia, Chenbo <[email protected]>; Wang, Zhihong <[email protected]>;Ye,
Quoted 88 lines
lib/librte_vhost/Makefile SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c
Quoted 30 lines
Xiaolong <[email protected]>
Cc: Fu, Patrick <[email protected]>; Jiang, Cheng1 <[email protected]>; Liang, Cunming <[email protected]>
Subject: [dpdk-dev] [PATCH v1 1/2] vhost: introduce async data path registration APIFrom: Patrick <[email protected]>
This patch introduces registration/un-registration APIs for async data path together with all required data structures and DMA callback function proto-types.
Signed-off-by Patrick <[email protected]>--- lib/librte_vhost/Makefile | 3 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 134 +++++++++++++++++++++++++++++++++++++ lib/librte_vhost/socket.c | 20 ++++++ lib/librte_vhost/vhost.c | 74 +++++++++++++++++++- lib/librte_vhost/vhost.h | 30 ++++++++- lib/librte_vhost/vhost_user.c | 28 ++++++-- 7 files changed, 283 insertions(+), 7 deletions(-) create mode100644
lib/librte_vhost/rte_vhost_async.hlib/librte_vhost/Makefile +0
-0@@ -41,7 +41,8 @@ SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c
iotlb.clib/librte_vhost/Makefile SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c iotlb.c socket.c vhost.c \
Quoted 5 lines
lib/librte_vhost/Makefile +0
-1socket.c vhost.c \ vhost_user.c virtio_net.c vdpa.c # install includes -SYMLINK-$(CONFIG_RTE_LIBRTE_VHOST)-include += rte_vhost.h
rte_vdpa.hlib/librte_vhost/Makefile SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c · line 45
Quoted 1 line
lib/librte_vhost/Makefile +1
-0+SYMLINK-$(CONFIG_RTE_LIBRTE_VHOST)-include += rte_vhost.h
rte_vdpa.hlib/librte_vhost/Makefile SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c iotlb.c socket.c vhost.c \ · line 46
Quoted 3 lines
lib/librte_vhost/Makefile +1
-0\ +rte_vhost_async.hHi Patrick,
Please also update meson build for newly added file.Thanks,
MarvinQuoted 21 lines
# only compile vhost crypto when cryptodev is enabled ifeq ($(CONFIG_RTE_LIBRTE_CRYPTODEV),y)(quoted diff) +0
-0
b/lib/librte_vhost/rte_vhost.hindex d43669f..cec4d07 100644lib/librte_vhost/rte_vhost.h +1
-0@@ -35,6 +35,7 @@ #define RTE_VHOST_USER_EXTBUF_SUPPORT(1ULL << 5)/* support only linear buffers (no chained mbufs) */ #define RTE_VHOST_USER_LINEARBUF_SUPPORT(1ULL << 6) +#define RTE_VHOST_USER_ASYNC_COPY(1ULL << 7)/** Protocol features. */ #ifndef VHOST_USER_PROTOCOL_F_MQ lib/librte_vhost/rte_vhost_async.h new file +0
-0lib/librte_vhost/rte_vhost_async.h line 2
Quoted 2 lines
lib/librte_vhost/rte_vhost_async.h new file +2
-0@@ -0,0 +1,134 @@ +/* SPDX-License-Identifier: BSD-3-Clause +* Copyright(c) 2018 Intel Corporation */ s/2018/2020/
Quoted 14 lines
lib/librte_vhost/rte_vhost_async.h new file +14
-0+ +#ifndef _RTE_VHOST_ASYNC_H_ +#define _RTE_VHOST_ASYNC_H_ + +#include "rte_vhost.h" + +/** + * iovec iterator + */ +struct iov_it { +/** offset to the first byte of interesting data */ +size_t offset; +/** total bytes of data in this iterator */ +size_t count;Quoted 8 lines
lib/librte_vhost/rte_vhost_async.h line 22
Quoted 5 lines
lib/librte_vhost/rte_vhost_async.h new file +5
-0+/** pointer to the iovec array */ +struct iovec *iov; +/** number of iovec in this iterator */ +unsigned long nr_segs; +};Patrick,
I think structure named as "it" is too generic for understanding, pleaseuse
Quoted 17 lines
more meaningful name like "
iov_iter".lib/librte_vhost/rte_vhost_async.h line 33
Quoted 11 lines
lib/librte_vhost/rte_vhost_async.h new file +11
-0+ +/** +* dma transfer descriptor pair +*/ +struct dma_trans_desc { +/** source memory iov_it */ +struct iov_it *src; +/** destination memory iov_it */ +struct iov_it *dst; +}; +This series patch named as sync copy, and dma is just one async copy method which underneath hardware supplied.
IMHO, structure is better to named as "async_copy_desc" which matchedthe
Quoted 65 lines
overall concept.
lib/librte_vhost/rte_vhost_async.h line 43
Quoted 10 lines
lib/librte_vhost/rte_vhost_async.h new file +10
-0+/** +* dma transfer status +*/ +struct dma_trans_status { +/** An array of application specific data for source memory */ +uintptr_t *src_opaque_data; +/** An array of application specific data for destination memory */ +uintptr_t *dst_opaque_data; +}; +Same as pervious comment.
Quoted 51 lines
lib/librte_vhost/rte_vhost_async.h new file +51
-0+/** +* dma operation callbacks to be implemented by applications */ +struct rte_vhost_async_channel_ops { +/** +* instruct a DMA channel to perform copies for a batch of packets +* +* @param vid +* id of vhost device to perform data copies +* @param queue_id +* queue id to perform data copies +* @param descs +* an array of DMA transfer memory descriptors +* @param opaque_data +* opaque data pair sending to DMA engine +* @param count +* number of elements in the "descs" array +* @return +* -1 on failure, number of descs processed on success +*/ +int (*transfer_data)(int vid,uint16_t queue_id, +struct dma_trans_desc *descs, +struct dma_trans_status *opaque_data, +uint16_t count); +/** +* check copy-completed packets from a DMA channel +* @param vid +* id of vhost device to check copy completion +* @param queue_id +* queue id to check copyp completion +* @param opaque_data +* buffer to receive the opaque data pair from DMA engine +* @param max_packets +* max number of packets could be completed +* @return +* -1 on failure, number of iov segments completed on success +*/ +int (*check_completed_copies)(int vid,uint16_t queue_id, +struct dma_trans_status *opaque_data, +uint16_t max_packets); +}; + +/** + * dma channel feature bit definition */ struct +dma_channel_features { +union { +uint32_t intval; +struct { +uint32_t inorder:1; +uint32_t resvd0115:15; +uint32_t threshold:12; +uint32_t resvd2831:4;Quoted 8 lines
lib/librte_vhost/rte_vhost_async.h line 43
Quoted 4 lines
lib/librte_vhost/rte_vhost_async.h new file +4
-0+}; +}; +}; +Naming feature bits as "intval" may cause confusion, why not just use its meaning like "
engine_features"?
I'm not sure whether format "resvd0115" match dpdk copy style. In mymind,
Quoted 2 lines
dpdk will use
resvd_0andresvd_1for two reserved elements.For comments here above, I will take changes in v2 patch
Quoted 6 lines
lib/librte_vhost/rte_vhost_async.h line 101
Quoted 4 lines
lib/librte_vhost/rte_vhost_async.h new file +4
-0+if (dev) +dev->async_copy =1 ; +} +IMHO, user can chose which queue utilize async copy as backend
hardware
Quoted 9 lines
Quoted 3 lines
resource is limited.
So shouldasync_copyenable flag be saved in virtqueue structure?We have per queue flag to identify the enabling status of a specific queue. "
async_copy" flag is a dev level flag which identifies the async capability of a vhost device.
This is necessary because we rely on this flag to do initialization work if the vhost backend need to support async mode at any of its queues.
I got u, how about rename this variable to "async_copy_enabled" which more aligned to its real implication.
Thanks,
Marvin
Quoted 72 lines
Quoted 34 lines
Quoted 34 lines
VHOST_LOG_CONFIG(INFO, "new device, handle is %d\n", vid);if (
vsocket->notify_ops->new_connection) { @@ -891,6 +900,17 @@
structvhost_user_reconnect_list{
gotoout_mutex;
}lib/librte_vhost/rte_vhost_async.h new file +6
-0+vsocket->async_copy = flags &RTE_VHOST_USER_ASYNC_COPY ; + +if (vsocket->async_copy && +(flags & (RTE_VHOST_USER_IOMMU_SUPPORT | +RTE_VHOST_USER_POSTCOPY_SUPPORT ))) { +VHOST_LOG_CONFIG(ERR, "error: enabling async copy andIOMMU "
+"or post-copy feature simultaneously is not "
+"supported\n");lib/librte_vhost/rte_vhost_async.h new file +3
-0+goto out_mutex; +} +/* * Set the supported features correctly for the builtin vhost-user * net driver. lib/librte_vhost/vhost.c index renamed from lib/librte_vhost/vhost.c +0
-00266318..e6b688a 100644
lib/librte_vhost/vhost.c +2
-1@@ -332,8 +332,13 @@ {if (vq_is_packed (dev))rte_free (vq->shadow_used_packed); -else +else {rte_free (vq->shadow_used_split); +if (vq->async_pkts_pending)Quoted 8 lines
lib/librte_vhost/vhost.c int rte_vhost_extern_callback_register(int
Quoted 8 lines
lib/librte_vhost/vhost.c +4
-0+rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); +}rte_free (vq->batch_copy_elems);rte_mempool_free (vq->iotlb_pool);rte_free (vq);@@ -1527,3 +1532,70 @@ int rte_vhost_extern_callback_register(intvid,
Quoted 21 lines
Quoted 21 lines
lib/librte_vhost/vhost.c +4
-0if (vhost_data_log_level >=0 )rte_log_set_level (vhost_data_log_level,RTE_LOG_WARNING ); } + +int rte_vhost_async_channel_register (int vid,uint16_t queue_id, +uint32_t features, +struct rte_vhost_async_channel_ops*ops)
lib/librte_vhost/vhost.c +12
-0+{ +struct vhost_virtqueue *vq; +struct virtio_net *dev =get_device (vid); +struct dma_channel_features f; + +if (dev ==NULL || ops ==NULL ) +return -1 ; + +f.intval = features; + +vq = dev->virtqueue[queue_id]; +Quoted 8 lines
lib/librte_vhost/vhost.c int rte_vhost_extern_callback_register(int vid, · line 1557
Quoted 7 lines
lib/librte_vhost/vhost.c +7
-0+if (vq ==NULL ) +return -1 ; + +/** packed queue is not supported */ +if (vq_is_packed (dev) || !f.inorder) +return -1 ; +Virtio already has
in_orderconcept, these two names are so like and can
Quoted 4 lines
be
Quoted 2 lines
easily messed up. Please consider how to distinguish them.
What about "
async_inorder"
Look great for me.
Quoted 162 lines
Quoted 9 lines
lib/librte_vhost/vhost.c int rte_vhost_extern_callback_register(int vid, · line 1561
Quoted 5 lines
lib/librte_vhost/vhost.c +4
-0+if (ops->check_completed_copies ==NULL || +ops->transfer_data ==NULL ) +return -1 ; +Previous error is unlikely to be true, unlikely macro may be helpful for understanding.
Will update in v2 patch
Quoted 136 lines
Quoted 136 lines
lib/librte_vhost/vhost.c +3
-0+rte_spinlock_lock (&vq->access_lock); + +vq->async_ops.check_completed_copies = ops-Quoted 1 line
check_completed_copies;lib/librte_vhost/vhost.c +36
-0+vq->async_ops.transfer_data = ops->transfer_data; + +vq->async_inorder = f.inorder; +vq->async_threshold = f.threshold; + +vq->async_registered = true; + +rte_spinlock_unlock (&vq->access_lock); + +return 0 ; +} + +int rte_vhost_async_channel_unregister (int vid,uint16_t queue_id) { +struct vhost_virtqueue *vq; +struct virtio_net *dev =get_device (vid); + +if (dev ==NULL ) +return -1 ; + +vq = dev->virtqueue[queue_id]; + +if (vq ==NULL ) +return -1 ; + +rte_spinlock_lock (&vq->access_lock); + +vq->async_ops.transfer_data =NULL ; +vq->async_ops.check_completed_copies =NULL ; + +vq->async_registered = false; + +rte_spinlock_unlock (&vq->access_lock); + +return 0 ; +} +lib/librte_vhost/vhost.h index renamed from lib/librte_vhost/vhost.h +0
-0df98d15..a7fbe23 100644
lib/librte_vhost/vhost.h +8
-0@@ -23,6 +23,8 @@#include "rte_vhost.h" #include "rte_vdpa.h" +#include "rte_vhost_async.h" +/* Used to indicate that the device is running on a data core */ #define VIRTIO_DEV_RUNNING 1 /* Used to indicate that the device is ready to operate */ @@ -39,6 +41,11 @@#define VHOST_LOG_CACHE_NR 32 +#define MAX_PKT_BURST 32 + +#define VHOST_MAX_ASYNC_IT (MAX_PKT_BURST * 2) #define +VHOST_MAX_ASYNC_VEC (BUF_VECTOR_MAX * 2) +#define PACKED_DESC_ENQUEUE_USED_FLAG (w)\ ((w) ? (VRING_DESC_F_AVAIL | VRING_DESC_F_USED |
VRING_DESC_F_WRITE) : \
VRING_DESC_F_WRITE)lib/librte_vhost/vhost.h +19
-0@@ -200,6 +207,25 @@ struct vhost_virtqueue { TAILQ_HEAD(, vhost_iotlb_entry) iotlb_list; intiotlb_cache_nr; TAILQ_HEAD(, vhost_iotlb_entry) iotlb_pending_list; + +/* operation callbacks for async dma */ +struct rte_vhost_async_channel_opsasync_ops ; + +struct iov_it it_pool[VHOST_MAX_ASYNC_IT ]; +struct iovec vec_pool[VHOST_MAX_ASYNC_VEC ]; + +/* async data transfer status */ +uintptr_t **async_pkts_pending; +#defineASYNC_PENDING_INFO_N_MSK 0xFFFF +#defineASYNC_PENDING_INFO_N_SFT 16 +uint64_t *async_pending_info; +uint16_tasync_pkts_idx; +uint16_tasync_pkts_inflight_n; + +/* vq async features */ +boolasync_inorder; +boolasync_registered; +uint16_tasync_threshold; } __rte_cache_aligned; /* Old kernels have no such macros defined */ @@ -353,6 +379,7 @@struct
virtio_net{
int16_tbroadcast_rarp;
uint32_tnr_vring;
intdequeue_zero_copy;lib/librte_vhost/vhost.h +3
-1+intasync_copy; intextbuf; intlinearbuf;struct vhost_virtqueue *virtqueue[VHOST_MAX_QUEUE_PAIRS *2 ];@@ -702,7 +729,8 @@ uint64_t translate_log_addr(struct virtio_net *dev, struct vhost_virtqueue *vq,/* Don't kick guest if we don't reach index specified by guest. */ if (dev->features & (1ULL << VIRTIO_RING_F_EVENT_IDX)) {uint16_t old = vq->signalled_used; -uint16_t new = vq->last_used_idx; +uint16_t new = vq->async_pkts_inflight_n ? +vq->used->idx:vq->last_used_idx;bool signalled_used_valid = vq->signalled_used_valid;
vq->signalled_used= new;(quoted diff) +0
-0
b/lib/librte_vhost/vhost_user.cindex 84bebad..d7600bf 100644lib/librte_vhost/vhost_user.c +13
-1@@ -464,12 +464,25 @@ }else {if (vq->shadow_used_split)rte_free (vq->shadow_used_split); +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + vq->shadow_used_split =rte_malloc (NULL , vq->size *sizeof (struct vring_used_elem ),RTE_CACHE_LINE_SIZE ); -if (!vq->shadow_used_split) { +vq->async_pkts_pending =rte_malloc (NULL , +vq->size *sizeof (uintptr_t ), +RTE_CACHE_LINE_SIZE ); +vq->async_pending_info =rte_malloc (NULL , +vq->size *sizeof (uint64_t ), +RTE_CACHE_LINE_SIZE ); +if (!vq->shadow_used_split || +!vq->async_pkts_pending ||Quoted 8 lines
lib/librte_vhost/vhost_user.c line 487
Quoted 6 lines
lib/librte_vhost/vhost_user.c +2
-1+!vq->async_pending_info) {VHOST_LOG_CONFIG (ERR , -"failed to allocate memory for shadow used ring.\n"); +" failed to allocate memory for vq internal data.\n");If async copy not enabled, there will be no need to allocate related
structures.
Quoted 1 line
Will update in v2 patch
Thanks,
Patrick
Re: [dpdk-dev] [PATCH v1 1/2] vhost: introduce async data path registration API
In reply to Liu, YongQuoted 93 lines · Yong
Thanks, Patrick. So comments are inline.
Quoted 35 lines
-----Original Message-----
From: dev <[email protected]> On Behalf Of [email protected]
Sent: Thursday, June 11, 2020 6:02 PM
To: [email protected]; [email protected]; Xia, Chenbo <[email protected]>; Wang, Zhihong <[email protected]>; Ye, Xiaolong <[email protected]>
Cc: Fu, Patrick <[email protected]>; Jiang, Cheng1 <[email protected]>; Liang, Cunming <[email protected]>
Subject: [dpdk-dev] [PATCH v1 1/2] vhost: introduce async data path registration APIFrom: Patrick <[email protected]>
This patch introduces registration/un-registration APIs for async data path together with all required data structures and DMA callback function proto-types.
Signed-off-by Patrick <[email protected]>--- lib/librte_vhost/Makefile | 3 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 134 +++++++++++++++++++++++++++++++++++++ lib/librte_vhost/socket.c | 20 ++++++ lib/librte_vhost/vhost.c | 74 +++++++++++++++++++- lib/librte_vhost/vhost.h | 30 ++++++++- lib/librte_vhost/vhost_user.c | 28 ++++++-- 7 files changed, 283 insertions(+), 7 deletions(-) create mode 100644 lib/librte_vhost/rte_vhost_async.hlib/librte_vhost/Makefile +0
-0lib/librte_vhost/Makefile SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c · line 48
Quoted 9 lines
lib/librte_vhost/Makefile +2
-1@@ -41,7 +41,8 @@ SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c iotlb.c socket.c vhost.c \ vhost_user.c virtio_net.c vdpa.c # install includes -SYMLINK-$(CONFIG_RTE_LIBRTE_VHOST)-include += rte_vhost.h rte_vdpa.h +SYMLINK-$(CONFIG_RTE_LIBRTE_VHOST)-include += rte_vhost.h rte_vdpa.h \ + rte_vhost_async.hHi Patrick,
Please also update meson build for newly added file.Thanks,
MarvinQuoted 21 lines
# only compile vhost crypto when cryptodev is enabled ifeq ($(CONFIG_RTE_LIBRTE_CRYPTODEV),y)lib/librte_vhost/rte_vhost.h +1
-0@@ -35,6 +35,7 @@#define RTE_VHOST_USER_EXTBUF_SUPPORT (1ULL << 5)/* support only linear buffers (no chained mbufs) */ #define RTE_VHOST_USER_LINEARBUF_SUPPORT (1ULL << 6) +#define RTE_VHOST_USER_ASYNC_COPY (1ULL << 7)/** Protocol features. */ #ifndef VHOST_USER_PROTOCOL_F_MQ lib/librte_vhost/rte_vhost_async.h new file +0
-0lib/librte_vhost/rte_vhost_async.h line 3
Quoted 3 lines
lib/librte_vhost/rte_vhost_async.h new file +3
-0@@ -0,0 +1,134 @@ +/* SPDX-License-Identifier: BSD-3-Clause +* Copyright(c) 2018 Intel Corporation +*/ s/2018/2020/
Quoted 14 lines
lib/librte_vhost/rte_vhost_async.h new file +14
-0+ +#ifndef _RTE_VHOST_ASYNC_H_ +#define _RTE_VHOST_ASYNC_H_ + +#include "rte_vhost.h" + +/** + * iovec iterator + */ +struct iov_it { + /** offset to the first byte of interesting data */ + size_t offset; + /** total bytes of data in this iterator */ + size_t count;
Quoted 8 lines
lib/librte_vhost/rte_vhost_async.h line 22
Quoted 5 lines
lib/librte_vhost/rte_vhost_async.h new file +5
-0+/** pointer to the iovec array */ +struct iovec *iov; +/** number of iovec in this iterator */ +unsigned long nr_segs; +};Patrick,
I think structure named as "it" is too generic for understanding, please use more meaningful name like "iov_iter".
I would also add that being pat if the Vhost API, it needs to be prefixed with rte_vhost_.
This comment applies to all structures in this header.
Quoted 423 lines
lib/librte_vhost/rte_vhost_async.h line 33
Quoted 11 lines
lib/librte_vhost/rte_vhost_async.h new file +11
-0+ +/** +* dma transfer descriptor pair +*/ +struct dma_trans_desc { +/** source memory iov_it */ +struct iov_it *src; +/** destination memory iov_it */ +struct iov_it *dst; +}; +This series patch named as sync copy, and dma is just one async copy method which underneath hardware supplied. IMHO, structure is better to named as "
async_copy_desc" which matched the overall concept.lib/librte_vhost/rte_vhost_async.h line 43
Quoted 10 lines
lib/librte_vhost/rte_vhost_async.h new file +10
-0+/** +* dma transfer status +*/ +struct dma_trans_status { +/** An array of application specific data for source memory */ +uintptr_t *src_opaque_data; +/** An array of application specific data for destination memory */ +uintptr_t *dst_opaque_data; +}; +Same as pervious comment.
Quoted 47 lines
lib/librte_vhost/rte_vhost_async.h new file +47
-0+/** +* dma operation callbacks to be implemented by applications +*/ +struct rte_vhost_async_channel_ops { +/** +* instruct a DMA channel to perform copies for a batch of packets +* +* @param vid +* id of vhost device to perform data copies +* @param queue_id +* queue id to perform data copies +* @param descs +* an array of DMA transfer memory descriptors +* @param opaque_data +* opaque data pair sending to DMA engine +* @param count +* number of elements in the "descs" array +* @return +* -1 on failure, number of descs processed on success +*/ +int (*transfer_data)(int vid,uint16_t queue_id, +struct dma_trans_desc *descs, +struct dma_trans_status *opaque_data, +uint16_t count); +/** +* check copy-completed packets from a DMA channel +* @param vid +* id of vhost device to check copy completion +* @param queue_id +* queue id to check copyp completion +* @param opaque_data +* buffer to receive the opaque data pair from DMA engine +* @param max_packets +* max number of packets could be completed +* @return +* -1 on failure, number of iov segments completed on success +*/ +int (*check_completed_copies)(int vid,uint16_t queue_id, +struct dma_trans_status *opaque_data, +uint16_t max_packets); +}; + +/** +* dma channel feature bit definition +*/ +struct dma_channel_features { + union {lib/librte_vhost/rte_vhost_async.h line 100
Quoted 10 lines
lib/librte_vhost/rte_vhost_async.h new file +10
-0+uint32_t intval; +struct { +uint32_t inorder:1 ; +uint32_t resvd0115:15 ; +uint32_t threshold:12 ; +uint32_t resvd2831:4 ; + }; + }; +}; +Naming feature bits as "intval" may cause confusion, why not just use its meaning like "
engine_features"?
I'm not sure whether format "resvd0115" match dpdk copy style. In my mind, dpdk will useresvd_0andresvd_1for two reserved elements.Quoted 55 lines
lib/librte_vhost/rte_vhost_async.h new file +34
-0+/** +* register a dma channel for vhost +* +* @param vid +* vhost device id DMA channel to be attached to +* @param queue_id +* vhost queue id DMA channel to be attached to +* @param features +* DMA channel feature bit +* b0 : DMA supports inorder data transfer +* b1 - b15: reserved +* b16 - b27: Packet length threshold for DMA transfer +* b28 - b31: reserved +* @param ops +* DMA operation callbacks +* @return +* 0 on success, -1 on failures +*/ +int rte_vhost_async_channel_register (int vid,uint16_t queue_id, +uint32_t features,struct rte_vhost_async_channel_ops *ops); + +/** +* unregister a dma channel for vhost +* +* @param vid +* vhost device id DMA channel to be detached +* @param queue_id +* vhost queue id DMA channel to be detached +* @return +* 0 on success, -1 on failures +*/ +int rte_vhost_async_channel_unregister (int vid,uint16_t queue_id); + +#endif /* _RTE_VDPA_H_ */ lib/librte_vhost/socket.c +2
-0@@ -42,6 +42,7 @@ struct vhost_user_socket {bool use_builtin_virtio_net;bool extbuf;bool linearbuf; +bool async_copy;/* * The "supported_features" indicates the feature bits the @@ -210,6 +211,7 @@ struct vhost_user {size_t size;struct vhost_user_connection *conn;int ret; +struct virtio_net *dev;if (vsocket ==NULL )return ;lib/librte_vhost/socket.c struct vhost_user { · line 252
Quoted 10 lines
lib/librte_vhost/socket.c +7
-0@@ -241,6 +243,13 @@ struct vhost_user {if (vsocket->linearbuf)vhost_enable_linearbuf (vid); +if (vsocket->async_copy) { + dev =get_device (vid); + +if (dev) + dev->async_copy =1 ; + } +IMHO, user can chose which queue utilize async copy as backend hardware resource is limited. So should
async_copyenable flag be saved in virtqueue structure?Quoted 60 lines
lib/librte_vhost/socket.c +6
-0VHOST_LOG_CONFIG (INFO ,"new device, handle is %d\n" , vid);if (vsocket->notify_ops->new_connection) {@@ -891,6 +900,17 @@ struct vhost_user_reconnect_list { goto out_mutex; } + vsocket->async_copy = flags &RTE_VHOST_USER_ASYNC_COPY ; + +if (vsocket->async_copy && + (flags & (RTE_VHOST_USER_IOMMU_SUPPORT | +RTE_VHOST_USER_POSTCOPY_SUPPORT ))) { + VHOST_LOG_CONFIG(ERR, "error: enabling async copy andIOMMU "
lib/librte_vhost/socket.c +5
-0+"or post-copy feature simultaneously is not " + "supported\n"); + goto out_mutex; + } +/* * Set the supported features correctly for the builtin vhost-user * net driver. lib/librte_vhost/vhost.c +10
-1@@ -332,8 +332,13 @@ {if (vq_is_packed (dev))rte_free (vq->shadow_used_packed); -else +else {rte_free (vq->shadow_used_split); +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + }rte_free (vq->batch_copy_elems);rte_mempool_free (vq->iotlb_pool);rte_free (vq);@@ -1527,3 +1532,70 @@ int rte_vhost_extern_callback_register(int vid,if (vhost_data_log_level >=0 )rte_log_set_level (vhost_data_log_level,RTE_LOG_WARNING ); } + +int rte_vhost_async_channel_register (int vid,uint16_t queue_id, +uint32_t features, + struct rte_vhost_async_channel_ops*ops)
lib/librte_vhost/vhost.c +9
-0+{ +struct vhost_virtqueue *vq; +struct virtio_net *dev =get_device (vid); +struct dma_channel_features f; + +if (dev ==NULL || ops ==NULL ) +return -1 ; + + f.intval = features;lib/librte_vhost/vhost.c int rte_vhost_extern_callback_register(int vid, · line 1557
Quoted 10 lines
lib/librte_vhost/vhost.c +10
-0+ + vq = dev->virtqueue[queue_id]; + +if (vq ==NULL ) +return -1 ; + +/** packed queue is not supported */ +if (vq_is_packed (dev) || !f.inorder) +return -1 ; +Virtio already has
in_orderconcept, these two names are so like and can be easily messed up. Please consider how to distinguish them.lib/librte_vhost/vhost.c int rte_vhost_extern_callback_register(int vid, · line 1561
Quoted 4 lines
lib/librte_vhost/vhost.c +4
-0+if (ops->check_completed_copies ==NULL || + ops->transfer_data ==NULL ) +return -1 ; +Previous error is unlikely to be true, unlikely macro may be helpful for understanding.
Quoted 133 lines
lib/librte_vhost/vhost.c +3
-0+rte_spinlock_lock (&vq->access_lock); + + vq->async_ops.check_completed_copies = ops-Quoted 1 line
check_completed_copies;lib/librte_vhost/vhost.c +37
-0+ vq->async_ops.transfer_data = ops->transfer_data; + + vq->async_inorder = f.inorder; + vq->async_threshold = f.threshold; + + vq->async_registered = true; + +rte_spinlock_unlock (&vq->access_lock); + +return 0 ; +} + +int rte_vhost_async_channel_unregister (int vid,uint16_t queue_id) +{ +struct vhost_virtqueue *vq; +struct virtio_net *dev =get_device (vid); + +if (dev ==NULL ) +return -1 ; + + vq = dev->virtqueue[queue_id]; + +if (vq ==NULL ) +return -1 ; + +rte_spinlock_lock (&vq->access_lock); + + vq->async_ops.transfer_data =NULL ; + vq->async_ops.check_completed_copies =NULL ; + + vq->async_registered = false; + +rte_spinlock_unlock (&vq->access_lock); + +return 0 ; +} +lib/librte_vhost/vhost.h +7
-0@@ -23,6 +23,8 @@#include "rte_vhost.h" #include "rte_vdpa.h" +#include "rte_vhost_async.h" +/* Used to indicate that the device is running on a data core */ #define VIRTIO_DEV_RUNNING 1/* Used to indicate that the device is ready to operate */ @@ -39,6 +41,11 @@#define VHOST_LOG_CACHE_NR 32 +#define MAX_PKT_BURST 32 + +#define VHOST_MAX_ASYNC_IT (MAX_PKT_BURST * 2) +#define VHOST_MAX_ASYNC_VEC (BUF_VECTOR_MAX * 2) +#define PACKED_DESC_ENQUEUE_USED_FLAG (w) \ ((w) ? (VRING_DESC_F_AVAIL | VRING_DESC_F_USED | VRING_DESC_F_WRITE) : \lib/librte_vhost/vhost.h +22
-1VRING_DESC_F_WRITE)@@ -200,6 +207,25 @@ struct vhost_virtqueue { TAILQ_HEAD(, vhost_iotlb_entry) iotlb_list;int iotlb_cache_nr; TAILQ_HEAD(, vhost_iotlb_entry) iotlb_pending_list; + +/* operation callbacks for async dma */ +struct rte_vhost_async_channel_ops async_ops; + +struct iov_it it_pool[VHOST_MAX_ASYNC_IT ]; +struct iovec vec_pool[VHOST_MAX_ASYNC_VEC ]; + +/* async data transfer status */ +uintptr_t **async_pkts_pending; +#define ASYNC_PENDING_INFO_N_MSK 0xFFFF +#define ASYNC_PENDING_INFO_N_SFT 16 +uint64_t *async_pending_info; +uint16_t async_pkts_idx; +uint16_t async_pkts_inflight_n; + +/* vq async features */ +bool async_inorder; +bool async_registered; +uint16_t async_threshold; } __rte_cache_aligned;/* Old kernels have no such macros defined */ @@ -353,6 +379,7 @@ struct virtio_net {int16_t broadcast_rarp;uint32_t nr_vring;int dequeue_zero_copy; +int async_copy;int extbuf;int linearbuf;struct vhost_virtqueue *virtqueue[VHOST_MAX_QUEUE_PAIRS *2 ];@@ -702,7 +729,8 @@ uint64_t translate_log_addr(struct virtio_net *dev,struct vhost_virtqueue *vq,/* Don't kick guest if we don't reach index specified by guest. */ if (dev->features & (1ULL << VIRTIO_RING_F_EVENT_IDX)) { uint16_t old = vq->signalled_used; -uint16_t new = vq->last_used_idx; +uint16_t new = vq->async_pkts_inflight_n ? + vq->used->idx:vq->last_used_idx;bool signalled_used_valid = vq->signalled_used_valid;lib/librte_vhost/vhost.h +0
-0vq->signalled_used = new;lib/librte_vhost/vhost_user.c +9
-1@@ -464,12 +464,25 @@ }else {if (vq->shadow_used_split)rte_free (vq->shadow_used_split); +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + vq->shadow_used_split =rte_malloc (NULL , vq->size *sizeof (struct vring_used_elem ),RTE_CACHE_LINE_SIZE ); -if (!vq->shadow_used_split) { + vq->async_pkts_pending =rte_malloc (NULL , + vq->size *sizeof (uintptr_t ), +RTE_CACHE_LINE_SIZE ); + vq->async_pending_info = rte_malloc(NULL,lib/librte_vhost/vhost_user.c line 487
Quoted 10 lines
lib/librte_vhost/vhost_user.c +6
-1+ vq->size *sizeof (uint64_t ), + RTE_CACHE_LINE_SIZE); +if (!vq->shadow_used_split || + !vq->async_pkts_pending || + !vq->async_pending_info) {VHOST_LOG_CONFIG (ERR , - "failed to allocate memory for shadow used ring.\n"); +" failed to allocate memory for vq internal data.\n");If async copy not enabled, there will be no need to allocate related structures.
Quoted 40 lines
lib/librte_vhost/vhost_user.c +0
-0return RTE_VHOST_MSG_RESULT_ERR ;lib/librte_vhost/vhost_user.c +3
-2} }@@ -1147,7 +1160,8 @@ goto err_mmap; } - populate = (dev->dequeue_zero_copy) ?MAP_POPULATE :0 ; + populate = (dev->dequeue_zero_copy || dev->async_copy) ? +MAP_POPULATE :0 ; mmap_addr =mmap (NULL , mmap_size,PROT_READ |PROT_WRITE ,MAP_SHARED | populate, fd,0 );@@ -1162,7 +1176,7 @@ reg->host_user_addr = (uint64_t )(uintptr_t )mmap_addr + mmap_offset; -if (dev->dequeue_zero_copy) +if (dev->dequeue_zero_copy || dev->async_copy)if (add_guest_pages (dev, reg, alignment) <0 ) { VHOST_LOG_CONFIG(ERR, "adding guest pages to region %ufailed.\n",
lib/librte_vhost/vhost_user.c +6
-0@@ -1945,6 +1959,12 @@ static int vhost_user_set_vring_err(struct virtio_net **pdev __rte_unused, }else {rte_free (vq->shadow_used_split); vq->shadow_used_split =NULL ; +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + vq->async_pkts_pending =NULL ; + vq->async_pending_info =NULL ; }
rte_free(vq->batch_copy_elems);
--
1.8.3.1
Re: [dpdk-dev] [PATCH v1 1/2] vhost: introduce async data path registration API
In reply to [email protected]Quoted 223 lines · On 6/11/20 12:02 PM, [email protected] wrote:
From: Patrick <[email protected]>
This patch introduces registration/un-registration APIs for async data path together with all required data structures and DMA callback function proto-types.
Signed-off-by Patrick <[email protected]>--- lib/librte_vhost/Makefile | 3 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 134 +++++++++++++++++++++++++++++++++++++ lib/librte_vhost/socket.c | 20 ++++++ lib/librte_vhost/vhost.c | 74 +++++++++++++++++++- lib/librte_vhost/vhost.h | 30 ++++++++- lib/librte_vhost/vhost_user.c | 28 ++++++-- 7 files changed, 283 insertions(+), 7 deletions(-) create mode 100644 lib/librte_vhost/rte_vhost_async.hlib/librte_vhost/Makefile +2
-1@@ -41,7 +41,8 @@ SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c iotlb.c socket.c vhost.c \ vhost_user.c virtio_net.c vdpa.c # install includes -SYMLINK-$(CONFIG_RTE_LIBRTE_VHOST)-include += rte_vhost.h rte_vdpa.h +SYMLINK-$(CONFIG_RTE_LIBRTE_VHOST)-include += rte_vhost.h rte_vdpa.h \ + rte_vhost_async.h # only compile vhost crypto when cryptodev is enabled ifeq ($(CONFIG_RTE_LIBRTE_CRYPTODEV),y)lib/librte_vhost/rte_vhost.h +1
-0@@ -35,6 +35,7 @@#define RTE_VHOST_USER_EXTBUF_SUPPORT (1ULL << 5)/* support only linear buffers (no chained mbufs) */ #define RTE_VHOST_USER_LINEARBUF_SUPPORT (1ULL << 6) +#define RTE_VHOST_USER_ASYNC_COPY (1ULL << 7)/** Protocol features. */ #ifndef VHOST_USER_PROTOCOL_F_MQ lib/librte_vhost/rte_vhost_async.h new file +134
-0@@ -0,0 +1,134 @@ +/* SPDX-License-Identifier: BSD-3-Clause +* Copyright(c) 2018 Intel Corporation +*/ + +#ifndef _RTE_VHOST_ASYNC_H_ +#define _RTE_VHOST_ASYNC_H_ + +#include "rte_vhost.h" + +/** +* iovec iterator +*/ +struct iov_it { +/** offset to the first byte of interesting data */ +size_t offset; +/** total bytes of data in this iterator */ +size_t count; +/** pointer to the iovec array */ +struct iovec *iov; +/** number of iovec in this iterator */ +unsigned long nr_segs; +}; + +/** +* dma transfer descriptor pair +*/ +struct dma_trans_desc { +/** source memory iov_it */ +struct iov_it *src; +/** destination memory iov_it */ +struct iov_it *dst; +}; + +/** +* dma transfer status +*/ +struct dma_trans_status { +/** An array of application specific data for source memory */ +uintptr_t *src_opaque_data; +/** An array of application specific data for destination memory */ +uintptr_t *dst_opaque_data; +}; + +/** +* dma operation callbacks to be implemented by applications +*/ +struct rte_vhost_async_channel_ops { +/** +* instruct a DMA channel to perform copies for a batch of packets +* +* @param vid +* id of vhost device to perform data copies +* @param queue_id +* queue id to perform data copies +* @param descs +* an array of DMA transfer memory descriptors +* @param opaque_data +* opaque data pair sending to DMA engine +* @param count +* number of elements in the "descs" array +* @return +* -1 on failure, number of descs processed on success +*/ +int (*transfer_data)(int vid,uint16_t queue_id, +struct dma_trans_desc *descs, +struct dma_trans_status *opaque_data, +uint16_t count); +/** +* check copy-completed packets from a DMA channel +* @param vid +* id of vhost device to check copy completion +* @param queue_id +* queue id to check copyp completion +* @param opaque_data +* buffer to receive the opaque data pair from DMA engine +* @param max_packets +* max number of packets could be completed +* @return +* -1 on failure, number of iov segments completed on success +*/ +int (*check_completed_copies)(int vid,uint16_t queue_id, +struct dma_trans_status *opaque_data, +uint16_t max_packets); +}; + +/** +* dma channel feature bit definition +*/ +struct dma_channel_features { +union { +uint32_t intval; +struct { +uint32_t inorder:1 ; +uint32_t resvd0115:15 ; +uint32_t threshold:12 ; +uint32_t resvd2831:4 ; + }; + }; +}; + +/** +* register a dma channel for vhost +* +* @param vid +* vhost device id DMA channel to be attached to +* @param queue_id +* vhost queue id DMA channel to be attached to +* @param features +* DMA channel feature bit +* b0 : DMA supports inorder data transfer +* b1 - b15: reserved +* b16 - b27: Packet length threshold for DMA transfer +* b28 - b31: reserved +* @param ops +* DMA operation callbacks +* @return +* 0 on success, -1 on failures +*/ +int rte_vhost_async_channel_register (int vid,uint16_t queue_id, +uint32_t features,struct rte_vhost_async_channel_ops *ops); + +/** +* unregister a dma channel for vhost +* +* @param vid +* vhost device id DMA channel to be detached +* @param queue_id +* vhost queue id DMA channel to be detached +* @return +* 0 on success, -1 on failures +*/ +int rte_vhost_async_channel_unregister (int vid,uint16_t queue_id); + +#endif /* _RTE_VDPA_H_ */ lib/librte_vhost/socket.c +10
-0@@ -42,6 +42,7 @@ struct vhost_user_socket {bool use_builtin_virtio_net;bool extbuf;bool linearbuf; +bool async_copy;/* * The "supported_features" indicates the feature bits the @@ -210,6 +211,7 @@ struct vhost_user {size_t size;struct vhost_user_connection *conn;int ret; +struct virtio_net *dev;if (vsocket ==NULL )return ;@@ -241,6 +243,13 @@ struct vhost_user {if (vsocket->linearbuf)vhost_enable_linearbuf (vid); +if (vsocket->async_copy) { + dev =get_device (vid); + +if (dev) + dev->async_copy =1 ; + } +VHOST_LOG_CONFIG (INFO ,"new device, handle is %d\n" , vid);if (vsocket->notify_ops->new_connection) {@@ -891,6 +900,17 @@ struct vhost_user_reconnect_list { goto out_mutex; } + vsocket->async_copy = flags &RTE_VHOST_USER_ASYNC_COPY ;
lib/librte_vhost/socket.c struct vhost_user_reconnect_list { · line 913
Quoted 10 lines
lib/librte_vhost/socket.c +10
-0+ +if (vsocket->async_copy && + (flags & (RTE_VHOST_USER_IOMMU_SUPPORT | +RTE_VHOST_USER_POSTCOPY_SUPPORT ))) { +VHOST_LOG_CONFIG (ERR ,"error: enabling async copy and IOMMU " +"or post-copy feature simultaneously is not " +"supported\n" ); + goto out_mutex; + } +
Have you ensure compatibility with the linearbuf feature (TSO)? You will want to do same kind of check if not compatible.
Quoted 38 lines
lib/librte_vhost/socket.c +0
-0/* * Set the supported features correctly for the builtin vhost-user * net driver. lib/librte_vhost/vhost.c +18
-1@@ -332,8 +332,13 @@ {if (vq_is_packed (dev))rte_free (vq->shadow_used_packed); -else +else {rte_free (vq->shadow_used_split); +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + }rte_free (vq->batch_copy_elems);rte_mempool_free (vq->iotlb_pool);rte_free (vq);@@ -1527,3 +1532,70 @@ int rte_vhost_extern_callback_register(int vid,if (vhost_data_log_level >=0 )rte_log_set_level (vhost_data_log_level,RTE_LOG_WARNING ); } + +int rte_vhost_async_channel_register (int vid,uint16_t queue_id, +uint32_t features, +struct rte_vhost_async_channel_ops *ops) +{ +struct vhost_virtqueue *vq; +struct virtio_net *dev =get_device (vid); +struct dma_channel_features f; + +if (dev ==NULL || ops ==NULL ) +return -1 ; +
lib/librte_vhost/vhost.c int rte_vhost_extern_callback_register(int vid, · line 1556
Quoted 10 lines
lib/librte_vhost/vhost.c +10
-0+ f.intval = features; + + vq = dev->virtqueue[queue_id]; + +if (vq ==NULL ) +return -1 ; + +/** packed queue is not supported */ +if (vq_is_packed (dev) || !f.inorder) +return -1 ;
You might want to print an error message to help the user understanding why it fails.
Quoted 24 lines
lib/librte_vhost/vhost.c +24
-0+ +if (ops->check_completed_copies ==NULL || + ops->transfer_data ==NULL ) +return -1 ; + +rte_spinlock_lock (&vq->access_lock); + + vq->async_ops.check_completed_copies = ops->check_completed_copies; + vq->async_ops.transfer_data = ops->transfer_data; + + vq->async_inorder = f.inorder; + vq->async_threshold = f.threshold; + + vq->async_registered = true; + +rte_spinlock_unlock (&vq->access_lock); + +return 0 ; +} + +int rte_vhost_async_channel_unregister (int vid,uint16_t queue_id) +{ +struct vhost_virtqueue *vq; +struct virtio_net *dev =get_device (vid);
lib/librte_vhost/vhost.c int rte_vhost_extern_callback_register(int vid, · line 1590
Quoted 10 lines
lib/librte_vhost/vhost.c +10
-0+ +if (dev ==NULL ) +return -1 ; + + vq = dev->virtqueue[queue_id]; + +if (vq ==NULL ) +return -1 ; + +rte_spinlock_lock (&vq->access_lock);
We might want to wait all async transfers are done berfore unregistering?
Quoted 145 lines
lib/librte_vhost/vhost.c +11
-0+ + vq->async_ops.transfer_data =NULL ; + vq->async_ops.check_completed_copies =NULL ; + + vq->async_registered = false; + +rte_spinlock_unlock (&vq->access_lock); + +return 0 ; +} +lib/librte_vhost/vhost.h +29
-1@@ -23,6 +23,8 @@#include "rte_vhost.h" #include "rte_vdpa.h" +#include "rte_vhost_async.h" +/* Used to indicate that the device is running on a data core */ #define VIRTIO_DEV_RUNNING 1/* Used to indicate that the device is ready to operate */ @@ -39,6 +41,11 @@#define VHOST_LOG_CACHE_NR 32 +#define MAX_PKT_BURST 32 + +#define VHOST_MAX_ASYNC_IT (MAX_PKT_BURST * 2) +#define VHOST_MAX_ASYNC_VEC (BUF_VECTOR_MAX * 2) +#define PACKED_DESC_ENQUEUE_USED_FLAG (w) \ ((w) ? (VRING_DESC_F_AVAIL | VRING_DESC_F_USED | VRING_DESC_F_WRITE) : \ VRING_DESC_F_WRITE)@@ -200,6 +207,25 @@ struct vhost_virtqueue { TAILQ_HEAD(, vhost_iotlb_entry) iotlb_list;int iotlb_cache_nr; TAILQ_HEAD(, vhost_iotlb_entry) iotlb_pending_list; + +/* operation callbacks for async dma */ +struct rte_vhost_async_channel_ops async_ops; + +struct iov_it it_pool[VHOST_MAX_ASYNC_IT ]; +struct iovec vec_pool[VHOST_MAX_ASYNC_VEC ]; + +/* async data transfer status */ +uintptr_t **async_pkts_pending; +#define ASYNC_PENDING_INFO_N_MSK 0xFFFF +#define ASYNC_PENDING_INFO_N_SFT 16 +uint64_t *async_pending_info; +uint16_t async_pkts_idx; +uint16_t async_pkts_inflight_n; + +/* vq async features */ +bool async_inorder; +bool async_registered; +uint16_t async_threshold; } __rte_cache_aligned;/* Old kernels have no such macros defined */ @@ -353,6 +379,7 @@ struct virtio_net {int16_t broadcast_rarp;uint32_t nr_vring;int dequeue_zero_copy; +int async_copy;int extbuf;int linearbuf;struct vhost_virtqueue *virtqueue[VHOST_MAX_QUEUE_PAIRS *2 ];@@ -702,7 +729,8 @@ uint64_t translate_log_addr(struct virtio_net *dev, struct vhost_virtqueue *vq,/* Don't kick guest if we don't reach index specified by guest. */ if (dev->features & (1ULL <<VIRTIO_RING_F_EVENT_IDX )) {uint16_t old = vq->signalled_used; -uint16_t new = vq->last_used_idx; +uint16_t new = vq->async_pkts_inflight_n ? + vq->used->idx:vq->last_used_idx;bool signalled_used_valid = vq->signalled_used_valid; vq->signalled_used = new;lib/librte_vhost/vhost_user.c +24
-4@@ -464,12 +464,25 @@ }else {if (vq->shadow_used_split)rte_free (vq->shadow_used_split); +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + vq->shadow_used_split =rte_malloc (NULL , vq->size *sizeof (struct vring_used_elem ),RTE_CACHE_LINE_SIZE ); -if (!vq->shadow_used_split) { + vq->async_pkts_pending =rte_malloc (NULL , + vq->size *sizeof (uintptr_t ), +RTE_CACHE_LINE_SIZE ); + vq->async_pending_info =rte_malloc (NULL , + vq->size *sizeof (uint64_t ), +RTE_CACHE_LINE_SIZE ); +if (!vq->shadow_used_split || + !vq->async_pkts_pending || + !vq->async_pending_info) {VHOST_LOG_CONFIG (ERR , -"failed to allocate memory for shadow used ring.\n" ); +"failed to allocate memory for vq internal data.\n" );return RTE_VHOST_MSG_RESULT_ERR ; } }@@ -1147,7 +1160,8 @@ goto err_mmap; } - populate = (dev->dequeue_zero_copy) ?MAP_POPULATE :0 ; + populate = (dev->dequeue_zero_copy || dev->async_copy) ? +MAP_POPULATE :0 ; mmap_addr =mmap (NULL , mmap_size,PROT_READ |PROT_WRITE ,MAP_SHARED | populate, fd,0 );@@ -1162,7 +1176,7 @@ reg->host_user_addr = (uint64_t )(uintptr_t )mmap_addr + mmap_offset; -if (dev->dequeue_zero_copy) +if (dev->dequeue_zero_copy || dev->async_copy)if (add_guest_pages (dev, reg, alignment) <0 ) { VHOST_LOG_CONFIG(ERR, "adding guest pages to region %u failed.\n",@@ -1945,6 +1959,12 @@ static int vhost_user_set_vring_err(struct virtio_net **pdev __rte_unused, }else {rte_free (vq->shadow_used_split); vq->shadow_used_split =NULL ; +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + vq->async_pkts_pending =NULL ; + vq->async_pending_info =NULL ; }rte_free (vq->batch_copy_elems);
Re: [dpdk-dev] [PATCH v1 1/2] vhost: introduce async data path registration API
Hi Maxime,
Quoted 60 lines
-----Original Message-----
From: Maxime Coquelin <[email protected]>
Sent: Friday, June 26, 2020 10:29 PM
To: Fu, Patrick <[email protected]>; [email protected]; Xia, Chenbo <[email protected]>; Wang, Zhihong <[email protected]>; Ye, Xiaolong <[email protected]>
Cc: Jiang, Cheng1 <[email protected]>; Liang, Cunming <[email protected]>
Subject: Re: [PATCH v1 1/2] vhost: introduce async data path registration APIQuoted 37 lines · On 6/11/20 12:02 PM, [email protected] wrote:
From: Patrick <[email protected]>
lib/librte_vhost/socket.c +10
-0@@ -42,6 +42,7 @@ struct vhost_user_socket {bool use_builtin_virtio_net;bool extbuf;bool linearbuf; +bool async_copy;/* * The "supported_features" indicates the feature bits the @@ -210,6 +211,7 @@ struct vhost_user { size_t size; struct vhost_user_connection *conn; int ret; +struct virtio_net *dev; if (vsocket == NULL) return; @@ -241,6 +243,13 @@ struct vhost_user {if (vsocket->linearbuf)vhost_enable_linearbuf (vid); +if (vsocket->async_copy) { + dev =get_device (vid); + +if (dev) + dev->async_copy =1 ; + } +VHOST_LOG_CONFIG (INFO ,"new device, handle is %d\n" , vid); if (vsocket->notify_ops->new_connection) { @@ -891,6 +900,17 @@struct
vhost_user_reconnect_list{lib/librte_vhost/socket.c struct vhost_user_reconnect_list {
Quoted 9 lines
lib/librte_vhost/socket.c +6
-0goto out_mutex; } + vsocket->async_copy = flags &RTE_VHOST_USER_ASYNC_COPY ; + +if (vsocket->async_copy && + (flags & (RTE_VHOST_USER_IOMMU_SUPPORT | +RTE_VHOST_USER_POSTCOPY_SUPPORT ))) { + VHOST_LOG_CONFIG(ERR, "error: enabling async copy andIOMMU "
Quoted 9 lines
lib/librte_vhost/socket.c struct vhost_user_reconnect_list { · line 913
Quoted 5 lines
lib/librte_vhost/socket.c +5
-0+"or post-copy feature simultaneously is not " + "supported\n"); + goto out_mutex; + } +Have you ensure compatibility with the linearbuf feature (TSO)? You will want to do same kind of check if not compatible.
I think this concern comes primarily from dequeue side. As current patch is for enqueue only, linearbuf check doesn't seem to be necessary. For future dequeue implementation, we may need to add an additional feature bit to let application to decide if the async callback is compatible with linearbuf or not. For a real hardware DMA engine, it should usually support linearbuf. For a pure software backend (something like dequeue-zero-copy), it may not support.
Quoted 43 lines
Quoted 23 lines
lib/librte_vhost/socket.c +0
-0/* * Set the supported features correctly for the builtin vhost-user * net driver. lib/librte_vhost/vhost.c index renamed from lib/librte_vhost/vhost.c +0
-00266318..e6b688a 100644
lib/librte_vhost/vhost.c +6
-1@@ -332,8 +332,13 @@ {if (vq_is_packed (dev))rte_free (vq->shadow_used_packed); -else +else {rte_free (vq->shadow_used_split); +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + }rte_free (vq->batch_copy_elems);rte_mempool_free (vq->iotlb_pool);rte_free (vq);lib/librte_vhost/vhost.c int rte_vhost_extern_callback_register(int vid, · line 1533
Quoted 2 lines
lib/librte_vhost/vhost.c +0
-0@@ -1527,3 +1532,70 @@ int rte_vhost_extern_callback_register(int vid,if (vhost_data_log_level >=0 ) rte_log_set_level(vhost_data_log_level,
RTE_LOG_WARNING); }lib/librte_vhost/vhost.c int rte_vhost_extern_callback_register(int vid,
Quoted 4 lines
lib/librte_vhost/vhost.c +4
-0+ +int rte_vhost_async_channel_register (int vid,uint16_t queue_id, +uint32_t features, + struct rte_vhost_async_channel_ops*ops) {
Quoted 12 lines
lib/librte_vhost/vhost.c +12
-0+struct vhost_virtqueue *vq; +struct virtio_net *dev =get_device (vid); +struct dma_channel_features f; + +if (dev ==NULL || ops ==NULL ) +return -1 ; + + f.intval = features; + + vq = dev->virtqueue[queue_id]; + +if (vq ==NULL )
Quoted 9 lines
lib/librte_vhost/vhost.c int rte_vhost_extern_callback_register(int vid, · line 1556
Quoted 5 lines
lib/librte_vhost/vhost.c +5
-0+return -1 ; + +/** packed queue is not supported */ +if (vq_is_packed (dev) || !f.inorder) +return -1 ;You might want to print an error message to help the user understanding why it fails.
Will update in v2 patch
Quoted 28 lines
Quoted 28 lines
lib/librte_vhost/vhost.c +27
-0+ +if (ops->check_completed_copies ==NULL || + ops->transfer_data ==NULL ) +return -1 ; + +rte_spinlock_lock (&vq->access_lock); + + vq->async_ops.check_completed_copies = ops- check_completed_copies; + vq->async_ops.transfer_data = ops->transfer_data; + + vq->async_inorder = f.inorder; + vq->async_threshold = f.threshold; + + vq->async_registered = true; + +rte_spinlock_unlock (&vq->access_lock); + +return 0 ; +} + +int rte_vhost_async_channel_unregister (int vid,uint16_t queue_id) { +struct vhost_virtqueue *vq; +struct virtio_net *dev =get_device (vid); + +if (dev ==NULL ) +return -1 ; +
Quoted 9 lines
lib/librte_vhost/vhost.c int rte_vhost_extern_callback_register(int vid, · line 1562
Quoted 6 lines
lib/librte_vhost/vhost.c +6
-0+ vq = dev->virtqueue[queue_id]; + +if (vq ==NULL ) +return -1 ; + +rte_spinlock_lock (&vq->access_lock);We might want to wait all async transfers are done berfore unregistering?
This could be a little bit tricky. In our async enqueue API design, applications send mbuf to DMA engine from one API call and get finished mbuf back from another API call. If we want to drain DMA buffer at this unregistration API, we need to either return mbuf from unregistration, or save the mbuf and return it somewhere else. I'm thinking if it's better to just report error in unregistration in case in-flight packets existing and rely on application to poll out all in-flight packets.
Re: [dpdk-dev] [PATCH v1 1/2] vhost: introduce async data path registration API
In reply to [email protected]Quoted 41 lines · On 6/11/20 12:02 PM, [email protected] wrote:
From: Patrick <[email protected]>
This patch introduces registration/un-registration APIs for async data path together with all required data structures and DMA callback function proto-types.
Signed-off-by Patrick <[email protected]>--- lib/librte_vhost/Makefile | 3 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 134 +++++++++++++++++++++++++++++++++++++ lib/librte_vhost/socket.c | 20 ++++++ lib/librte_vhost/vhost.c | 74 +++++++++++++++++++- lib/librte_vhost/vhost.h | 30 ++++++++- lib/librte_vhost/vhost_user.c | 28 ++++++-- 7 files changed, 283 insertions(+), 7 deletions(-) create mode 100644 lib/librte_vhost/rte_vhost_async.hlib/librte_vhost/rte_vhost_async.h new file +22
-0+/** +* register a dma channel for vhost +* +* @param vid +* vhost device id DMA channel to be attached to +* @param queue_id +* vhost queue id DMA channel to be attached to +* @param features +* DMA channel feature bit +* b0 : DMA supports inorder data transfer +* b1 - b15: reserved +* b16 - b27: Packet length threshold for DMA transfer +* b28 - b31: reserved +* @param ops +* DMA operation callbacks +* @return +* 0 on success, -1 on failures +*/ +int rte_vhost_async_channel_register (int vid,uint16_t queue_id, +uint32_t features,struct rte_vhost_async_channel_ops *ops); + +/**
lib/librte_vhost/rte_vhost_async.h line 132
Quoted 10 lines
lib/librte_vhost/rte_vhost_async.h new file +10
-0+* unregister a dma channel for vhost +* +* @param vid +* vhost device id DMA channel to be detached +* @param queue_id +* vhost queue id DMA channel to be detached +* @return +* 0 on success, -1 on failures +*/ +int rte_vhost_async_channel_unregister (int vid,uint16_t queue_id);
These new APIs need to be tagged as experimental. We'll need a few releases before considering them stable.
You need to add them to rte_vhost_version.map too.
PATCH 2/2 vhost: introduce async enqueue for split ring
In reply to [email protected]From: Patrick <[email protected]>
This patch implement async enqueue data path for split ring.
--- lib/librte_vhost/rte_vhost_async.h | 38 +++ lib/librte_vhost/virtio_net.c | 538 ++++++++++++++++++++++++++++++++++++- 2 files changed, 574 insertions(+), 2 deletions(-)
lib/librte_vhost/rte_vhost_async.h +38 -0
@@ -131,4 +131,42 @@ int rte_vhost_async_channel_register(int vid, uint16_t queue_id,*/ int rte_vhost_async_channel_unregister (int vid,uint16_t queue_id); +/** +* This function submit enqueue data to DMA. This function has no +* guranttee to the transfer completion upon return. Applications should +* poll transfer status by rte_vhost_poll_enqueue_completed() +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data +* @param pkts +* array of packets to be enqueued +* @param count +* packets num to be enqueued +* @return +* num of packets enqueued +*/ +uint16_t rte_vhost_submit_enqueue_burst (int vid,uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); + +/** +* This function check DMA completion status for a specific vhost +* device queue. Packets which finish copying (enqueue) operation +* will be returned in an array. +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data +* @param pkts +* blank array to get return packet pointer +* @param count +* size of the packet array +* @return +* num of packets returned +*/ +uint16_t rte_vhost_poll_enqueue_completed (int vid,uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); +#endif /* _RTE_VDPA_H_ */
lib/librte_vhost/virtio_net.c +536 -2
568 lines not on this page · raw message
Signature · 1 line
1.8.3.1
Re: [dpdk-dev] [PATCH v1 2/2] vhost: introduce async enqueue for split ring
Thanks, Patrick. Some comments are inline.
Quoted 161 lines
-----Original Message-----
From: dev <[email protected]> On Behalf Of [email protected]
Sent: Thursday, June 11, 2020 6:02 PM
To: [email protected]; [email protected]; Xia, Chenbo <[email protected]>; Wang, Zhihong <[email protected]>; Ye, Xiaolong <[email protected]>
Cc: Fu, Patrick <[email protected]>; Jiang, Cheng1 <[email protected]>; Liang, Cunming <[email protected]>
Subject: [dpdk-dev] [PATCH v1 2/2] vhost: introduce async enqueue for split ringFrom: Patrick <[email protected]>
This patch implement async enqueue data path for split ring.
Signed-off-by Patrick <[email protected]>--- lib/librte_vhost/rte_vhost_async.h | 38 +++ lib/librte_vhost/virtio_net.c | 538 ++++++++++++++++++++++++++++++++++++- 2 files changed, 574 insertions(+), 2 deletions(-)lib/librte_vhost/rte_vhost_async.h +38
-0@@ -131,4 +131,42 @@ int rte_vhost_async_channel_register(int vid,uint16_t queue_id, */ int rte_vhost_async_channel_unregister (int vid,uint16_t queue_id); +/** +* This function submit enqueue data to DMA. This function has no +* guranttee to the transfer completion upon return. Applications should +* poll transfer status by rte_vhost_poll_enqueue_completed() +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data +* @param pkts +* array of packets to be enqueued +* @param count +* packets num to be enqueued +* @return +* num of packets enqueued +*/ +uint16_t rte_vhost_submit_enqueue_burst (int vid,uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); + +/** +* This function check DMA completion status for a specific vhost +* device queue. Packets which finish copying (enqueue) operation +* will be returned in an array. +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data +* @param pkts +* blank array to get return packet pointer +* @param count +* size of the packet array +* @return +* num of packets returned +*/ +uint16_t rte_vhost_poll_enqueue_completed (int vid,uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); +#endif /* _RTE_VDPA_H_ */
lib/librte_vhost/virtio_net.c +60
-2@@ -17,14 +17,15 @@#include <rte_arp.h> #include <rte_spinlock.h> #include <rte_malloc.h> +#include <rte_vhost_async.h> #include "iotlb.h" #include "vhost.h" -#define MAX_PKT_BURST 32 -#define MAX_BATCH_LEN 256 +#define VHOST_ASYNC_BATCH_THRESHOLD 8 + static __rte_always_inline boolrxvq_is_mergeable (struct virtio_net *dev) {@@ -117,6 +118,35 @@ } static __rte_always_inline void +async_flush_shadow_used_ring_split (struct virtio_net *dev, +struct vhost_virtqueue *vq) +{ +uint16_t used_idx = vq->last_used_idx & (vq->size -1 ); + +if (used_idx + vq->shadow_used_idx <= vq->size) { +do_flush_shadow_used_ring_split (dev, vq, used_idx,0 , + vq->shadow_used_idx); + }else { +uint16_t size; + +/* update used ring interval [used_idx, vq->size] */ + size = vq->size - used_idx; +do_flush_shadow_used_ring_split (dev, vq, used_idx,0 , size); + +/* update the left half used ring interval [0, left_size] */ +do_flush_shadow_used_ring_split (dev, vq,0 , size, + vq->shadow_used_idx - size); + } + vq->last_used_idx += vq->shadow_used_idx; + +rte_smp_wmb (); + +vhost_log_cache_sync (dev, vq); + + vq->shadow_used_idx =0 ; +} + +static __rte_always_inline voidupdate_shadow_used_ring_split (struct vhost_virtqueue *vq,uint16_t desc_idx,uint32_t len) {@@ -905,6 +935,199 @@return error; } +static __rte_always_inline void +async_fill_vec (struct iovec *v,void *base,size_t len) +{ + v->iov_base = base; + v->iov_len = len; +} + +static __rte_always_inline void +async_fill_it (struct iov_it *it,size_t count, +struct iovec *vec,unsigned long nr_seg) +{ + it->offset =0 ; + it->count = count; + +if (count) { + it->iov = vec; + it->nr_segs = nr_seg; + }else { + it->iov =0 ; + it->nr_segs =0 ; + } +} + +static __rte_always_inline void +async_fill_des (struct dma_trans_desc *desc, +struct iov_it *src,struct iov_it *dst) +{ + desc->src = src;
lib/librte_vhost/virtio_net.c line 975
Quoted 10 lines
lib/librte_vhost/virtio_net.c +10
-0+ desc->dst = dst; +} + +static __rte_always_inline int +async_mbuf_to_desc (struct virtio_net *dev,struct vhost_virtqueue *vq, +struct rte_mbuf *m,struct buf_vector *buf_vec, +uint16_t nr_vec,uint16_t num_buffers, +struct iovec *src_iovec,struct iovec *dst_iovec, +struct iov_it *src_it,struct iov_it *dst_it) +{
There're too much arguments in this function, please check whether it will impact performance.
Quoted 97 lines
lib/librte_vhost/virtio_net.c +95
-0+uint32_t vec_idx =0 ; +uint32_t mbuf_offset, mbuf_avail; +uint32_t buf_offset, buf_avail; +uint64_t buf_addr, buf_iova, buf_len; +uint32_t cpy_len, cpy_threshold; +uint64_t hdr_addr; +struct rte_mbuf *hdr_mbuf; +struct batch_copy_elem *batch_copy = vq->batch_copy_elems; +struct virtio_net_hdr_mrg_rxbuf tmp_hdr, *hdr =NULL ; +int error =0 ; + +uint32_t tlen =0 ; +int tvec_idx =0 ; +void *hpa; + +if (unlikely (m ==NULL )) { + error =-1 ; + goto out; + } + + cpy_threshold = vq->async_threshold; + + buf_addr = buf_vec[vec_idx].buf_addr; + buf_iova = buf_vec[vec_idx].buf_iova; + buf_len = buf_vec[vec_idx].buf_len; + +if (unlikely (buf_len < dev->vhost_hlen && nr_vec <=1 )) { + error =-1 ; + goto out; + } + + hdr_mbuf = m; + hdr_addr = buf_addr; +if (unlikely (buf_len < dev->vhost_hlen)) + hdr = &tmp_hdr; +else + hdr = (struct virtio_net_hdr_mrg_rxbuf *)(uintptr_t )hdr_addr; + +VHOST_LOG_DATA (DEBUG ,"(%d) RX: num merge buffers %d\n" , + dev->vid, num_buffers); + +if (unlikely (buf_len < dev->vhost_hlen)) { + buf_offset = dev->vhost_hlen - buf_len; + vec_idx++; + buf_addr = buf_vec[vec_idx].buf_addr; + buf_iova = buf_vec[vec_idx].buf_iova; + buf_len = buf_vec[vec_idx].buf_len; + buf_avail = buf_len - buf_offset; + }else { + buf_offset = dev->vhost_hlen; + buf_avail = buf_len - dev->vhost_hlen; + } + + mbuf_avail =rte_pktmbuf_data_len (m); + mbuf_offset =0 ; + +while (mbuf_avail !=0 || m->next !=NULL ) { +/* done with current buf, get the next one */ +if (buf_avail ==0 ) { + vec_idx++; +if (unlikely (vec_idx >= nr_vec)) { + error =-1 ; + goto out; + } + + buf_addr = buf_vec[vec_idx].buf_addr; + buf_iova = buf_vec[vec_idx].buf_iova; + buf_len = buf_vec[vec_idx].buf_len; + + buf_offset =0 ; + buf_avail = buf_len; + } + +/* done with current mbuf, get the next one */ +if (mbuf_avail ==0 ) { + m = m->next; + + mbuf_offset =0 ; + mbuf_avail =rte_pktmbuf_data_len (m); + } + +if (hdr_addr) { +virtio_enqueue_offload (hdr_mbuf, &hdr->hdr); +if (rxvq_is_mergeable (dev)) +ASSIGN_UNLESS_EQUAL (hdr->num_buffers, + num_buffers); + +if (unlikely (hdr == &tmp_hdr)) { +copy_vnet_hdr_to_desc (dev, vq, buf_vec, hdr); + }else { +PRINT_PACKET (dev, (uintptr_t )hdr_addr, + dev->vhost_hlen,0 ); +vhost_log_cache_write_iova (dev, vq, + buf_vec[0 ].buf_iova, + dev->vhost_hlen);
lib/librte_vhost/virtio_net.c line 1080
Quoted 10 lines
lib/librte_vhost/virtio_net.c +10
-0+ } + + hdr_addr =0 ; + } + + cpy_len =RTE_MIN (buf_avail, mbuf_avail); + +if (unlikely (cpy_len >= cpy_threshold)) { + hpa = (void *)(uintptr_t )gpa_to_hpa (dev, + buf_iova + buf_offset, cpy_len);
I have one question here. If user has called async copy directly, should vhost library still check copy threshold for software fallback? If need software fallback, IMHO it will be more suitable to handle it in copy device driver.
IMHO, the cost will be too high for checking and fix virtio header in async copy function.
Since this is async copy datapath, could it possible that eliminate the cost in calculation of segmented addresses?
Quoted 231 lines
lib/librte_vhost/virtio_net.c +19
-0+ +if (unlikely (!hpa)) { + error =-1 ; + goto out; + } + +async_fill_vec (src_iovec + tvec_idx, + (void *)(uintptr_t )rte_pktmbuf_iova_offset (m, + mbuf_offset), cpy_len); + +async_fill_vec (dst_iovec + tvec_idx, hpa, cpy_len); + + tlen += cpy_len; + tvec_idx++; + }else { +if (unlikely (vq->batch_copy_nb_elems >= vq->size)) { + rte_memcpy( + (void *)((uintptr_t)(buf_addr + buf_offset)), + rte_pktmbuf_mtod_offset(m, void *,
mbuf_offset),lib/librte_vhost/virtio_net.c +10
-0+ cpy_len); + +PRINT_PACKET (dev, + (uintptr_t )(buf_addr + buf_offset), + cpy_len,0 ); + }else { + batch_copy[vq->batch_copy_nb_elems].dst = + (void *)((uintptr_t )(buf_addr + buf_offset)); + batch_copy[vq->batch_copy_nb_elems].src = + rte_pktmbuf_mtod_offset(m, void *,
mbuf_offset);lib/librte_vhost/virtio_net.c +1
-0+ batch_copy[vq-Quoted 1 line
batch_copy_nb_elems].log_addr =
lib/librte_vhost/virtio_net.c +121
-0+ buf_iova + buf_offset; + batch_copy[vq->batch_copy_nb_elems].len = + cpy_len; + vq->batch_copy_nb_elems++; + } + } + + mbuf_avail -= cpy_len; + mbuf_offset += cpy_len; + buf_avail -= cpy_len; + buf_offset += cpy_len; + } + +out: +async_fill_it (src_it, tlen, src_iovec, tvec_idx); +async_fill_it (dst_it, tlen, dst_iovec, tvec_idx); + +return error; +} + static __rte_always_inline int vhost_enqueue_single_packed(struct virtio_net *dev, struct vhost_virtqueue *vq,@@ -1236,6 +1459,317 @@return virtio_dev_rx (dev, queue_id, pkts, count); } +static __rte_always_inline void +virtio_dev_rx_async_submit_split_err (struct virtio_net *dev, +struct vhost_virtqueue *vq,uint16_t queue_id, +uint16_t last_idx,uint16_t shadow_idx) +{ +while (vq->async_pkts_inflight_n) { +int er = vq->async_ops.check_completed_copies (dev->vid, + queue_id,0 ,MAX_PKT_BURST ); + +if (er <0 ) { + vq->async_pkts_inflight_n =0 ; +break ; + } + + vq->async_pkts_inflight_n -= er; + } + + vq->shadow_used_idx = shadow_idx; + vq->last_avail_idx = last_idx; +} + +static __rte_noinline uint32_t +virtio_dev_rx_async_submit_split (struct virtio_net *dev, +struct vhost_virtqueue *vq,uint16_t queue_id, +struct rte_mbuf **pkts,uint32_t count) +{ +uint32_t pkt_idx =0 , pkt_burst_idx =0 ; +uint16_t num_buffers; +struct buf_vector buf_vec[BUF_VECTOR_MAX ]; +uint16_t avail_head, last_idx, shadow_idx; + +struct iov_it *it_pool = vq->it_pool; +struct iovec *vec_pool = vq->vec_pool; +struct dma_trans_desc tdes[MAX_PKT_BURST ]; +struct iovec *src_iovec = vec_pool; +struct iovec *dst_iovec = vec_pool + (VHOST_MAX_ASYNC_VEC >>1 ); +struct iov_it *src_it = it_pool; +struct iov_it *dst_it = it_pool +1 ; +uint16_t n_free_slot, slot_idx; +int n_pkts =0 ; + + avail_head = *((volatile uint16_t *)&vq->avail->idx); + last_idx = vq->last_avail_idx; + shadow_idx = vq->shadow_used_idx; + +/* +* The ordering between avail index and +* desc reads needs to be enforced. +*/ +rte_smp_rmb (); + +rte_prefetch0 (&vq->avail->ring[vq->last_avail_idx & (vq->size -1 )]); + +for (pkt_idx =0 ; pkt_idx < count; pkt_idx++) { +uint32_t pkt_len = pkts[pkt_idx]->pkt_len + dev->vhost_hlen; +uint16_t nr_vec =0 ; + +if (unlikely (reserve_avail_buf_split (dev, vq, + pkt_len, buf_vec, &num_buffers, + avail_head, &nr_vec) <0 )) { +VHOST_LOG_DATA (DEBUG , +"(%d) failed to get enough desc from vring\n", + dev->vid); + vq->shadow_used_idx -= num_buffers; +break ; + } + + VHOST_LOG_DATA(DEBUG, "(%d) current index %d | end index %d\n", + dev->vid, vq->last_avail_idx, + vq->last_avail_idx + num_buffers); + +if (async_mbuf_to_desc (dev, vq, pkts[pkt_idx], + buf_vec, nr_vec, num_buffers, + src_iovec, dst_iovec, src_it, dst_it) <0 ) { + vq->shadow_used_idx -= num_buffers; +break ; + } + + slot_idx = (vq->async_pkts_idx + pkt_idx) & (vq->size -1 ); +if (src_it->count) { +async_fill_des (&tdes[pkt_burst_idx], src_it, dst_it); + pkt_burst_idx++; + vq->async_pending_info[slot_idx] = + num_buffers | (src_it->nr_segs <<16 ); + src_iovec += src_it->nr_segs; + dst_iovec += dst_it->nr_segs; + src_it +=2 ; + dst_it +=2 ; + }else { + vq->async_pending_info[slot_idx] = num_buffers; + vq->async_pkts_inflight_n++; + } + + vq->last_avail_idx += num_buffers; + +if (pkt_burst_idx >=VHOST_ASYNC_BATCH_THRESHOLD || + (pkt_idx == count -1 && pkt_burst_idx)) { + n_pkts = vq->async_ops.transfer_data (dev->vid, + queue_id, tdes,0 , pkt_burst_idx); + src_iovec = vec_pool; + dst_iovec = vec_pool + (VHOST_MAX_ASYNC_VEC >>1);
lib/librte_vhost/virtio_net.c +22
-0+ src_it = it_pool; + dst_it = it_pool +1 ; + +if (unlikely (n_pkts < (int )pkt_burst_idx)) { + vq->async_pkts_inflight_n += + n_pkts >0 ? n_pkts :0 ; +virtio_dev_rx_async_submit_split_err (dev, + vq, queue_id, last_idx, shadow_idx); +return 0 ; + } + + pkt_burst_idx =0 ; + vq->async_pkts_inflight_n += n_pkts; + } + } + +if (pkt_burst_idx) { + n_pkts = vq->async_ops.transfer_data (dev->vid, + queue_id, tdes,0 , pkt_burst_idx); +if (unlikely (n_pkts <= (int )pkt_burst_idx)) { + vq->async_pkts_inflight_n += n_pkts >0 ? n_pkts :0 ; + virtio_dev_rx_async_submit_split_err(dev, vq,
queue_id,lib/librte_vhost/virtio_net.c +41
-0+ last_idx, shadow_idx); +return 0 ; + } + + vq->async_pkts_inflight_n += n_pkts; + } + +do_data_copy_enqueue (dev, vq); + + n_free_slot = vq->size - vq->async_pkts_idx; +if (n_free_slot > pkt_idx) { +rte_memcpy (&vq->async_pkts_pending[vq->async_pkts_idx], + pkts, pkt_idx *sizeof (uintptr_t )); + vq->async_pkts_idx += pkt_idx; + }else { +rte_memcpy (&vq->async_pkts_pending[vq->async_pkts_idx], + pkts, n_free_slot *sizeof (uintptr_t )); +rte_memcpy (&vq->async_pkts_pending[0 ], + &pkts[n_free_slot], + (pkt_idx - n_free_slot) *sizeof (uintptr_t )); + vq->async_pkts_idx = pkt_idx - n_free_slot; + } + +if (likely (vq->shadow_used_idx)) +async_flush_shadow_used_ring_split (dev, vq); + +return pkt_idx; +} + +uint16_t rte_vhost_poll_enqueue_completed (int vid,uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count) +{ +struct virtio_net *dev =get_device (vid); +struct vhost_virtqueue *vq; +uint16_t n_pkts_cpl, n_pkts_put =0 , n_descs =0 ; +uint16_t start_idx, pkts_idx, vq_size; +uint64_t *async_pending_info; + +VHOST_LOG_DATA (DEBUG ,"(%d) %s\n" , dev->vid, __func__); +if (unlikely (!is_valid_virt_queue_idx (queue_id,0 , dev->nr_vring))) { + VHOST_LOG_DATA(ERR, "(%d) %s: invalid virtqueueidx %d.\n",
lib/librte_vhost/virtio_net.c line 1631
Quoted 6 lines
lib/librte_vhost/virtio_net.c +6
-0+ dev->vid, __func__, queue_id); +return 0 ; + } + + vq = dev->virtqueue[queue_id]; +
Should check whether this device or queue support async copy, vq->async_pending_info is NULL if queue not enable async_copy.
Quoted 152 lines
lib/librte_vhost/virtio_net.c +12
-0+rte_spinlock_lock (&vq->access_lock); + + pkts_idx = vq->async_pkts_idx; + async_pending_info = vq->async_pending_info; + vq_size = vq->size; + start_idx = pkts_idx > vq->async_pkts_inflight_n ? + pkts_idx - vq->async_pkts_inflight_n : + (vq_size - vq->async_pkts_inflight_n + pkts_idx) & + (vq_size -1 ); + + n_pkts_cpl = + vq->async_ops.check_completed_copies(vid, queue_id, 0,count);
lib/librte_vhost/virtio_net.c +15
-0+ +rte_smp_wmb (); + +while (likely (((start_idx + n_pkts_put) & (vq_size -1 )) != pkts_idx)) { +uint64_t info = async_pending_info[ + (start_idx + n_pkts_put) & (vq_size -1 )]; +uint64_t n_segs; + n_pkts_put++; + n_descs += info &ASYNC_PENDING_INFO_N_MSK ; + n_segs = info >>ASYNC_PENDING_INFO_N_SFT ; + +if (n_segs) { +if (!n_pkts_cpl || n_pkts_cpl < n_segs) { + n_pkts_put--; + n_descs -= info &
ASYNC_PENDING_INFO_N_MSK;lib/librte_vhost/virtio_net.c +7
-0+if (n_pkts_cpl) { + async_pending_info[ + (start_idx + n_pkts_put) & + (vq_size -1 )] = + ((n_segs - n_pkts_cpl) << + ASYNC_PENDING_INFO_N_SFT) | + (info &
ASYNC_PENDING_INFO_N_MSK);lib/librte_vhost/virtio_net.c +22
-0+ n_pkts_cpl =0 ; + } +break ; + } + n_pkts_cpl -= n_segs; + } + } + +if (n_pkts_put) { + vq->async_pkts_inflight_n -= n_pkts_put; + *(volatile uint16_t *)&vq->used->idx += n_descs; + +vhost_vring_call_split (dev, vq); + } + +if (start_idx + n_pkts_put <= vq_size) { +rte_memcpy (pkts, &vq->async_pkts_pending[start_idx], + n_pkts_put *sizeof (uintptr_t )); + }else { +rte_memcpy (pkts, &vq->async_pkts_pending[start_idx], + (vq_size - start_idx) *sizeof (uintptr_t )); + rte_memcpy(&pkts[vq_size - start_idx], vq-Quoted 1 line
async_pkts_pending,lib/librte_vhost/virtio_net.c +19
-0+ (n_pkts_put - vq_size + start_idx) * sizeof(uintptr_t)); + } + +rte_spinlock_unlock (&vq->access_lock); + +return n_pkts_put; +} + +static __rte_always_inline uint32_t +virtio_dev_rx_async_submit (struct virtio_net *dev,uint16_t queue_id, +struct rte_mbuf **pkts,uint32_t count) +{ +struct vhost_virtqueue *vq; +uint32_t nb_tx =0 ; +bool drawback = false; + +VHOST_LOG_DATA (DEBUG ,"(%d) %s\n" , dev->vid, __func__); +if (unlikely (!is_valid_virt_queue_idx (queue_id,0 , dev->nr_vring))) { + VHOST_LOG_DATA(ERR, "(%d) %s: invalid virtqueueidx %d.\n",
lib/librte_vhost/virtio_net.c +43
-0+ dev->vid, __func__, queue_id); +return 0 ; + } + + vq = dev->virtqueue[queue_id]; + +rte_spinlock_lock (&vq->access_lock); + +if (unlikely (vq->enabled ==0 )) + goto out_access_unlock; + +if (unlikely (!vq->async_registered)) { + drawback = true; + goto out_access_unlock; + } + +if (dev->features & (1ULL <<VIRTIO_F_IOMMU_PLATFORM )) +vhost_user_iotlb_rd_lock (vq); + +if (unlikely (vq->access_ok ==0 )) +if (unlikely (vring_translate (dev, vq) <0 )) + goto out; + + count =RTE_MIN ((uint32_t )MAX_PKT_BURST , count); +if (count ==0 ) + goto out; + +/* TODO: packed queue not implemented */ +if (vq_is_packed (dev)) + nb_tx =0 ; +else + nb_tx =virtio_dev_rx_async_submit_split (dev, + vq, queue_id, pkts, count); + +out: +if (dev->features & (1ULL <<VIRTIO_F_IOMMU_PLATFORM )) +vhost_user_iotlb_rd_unlock (vq); + +out_access_unlock: +rte_spinlock_unlock (&vq->access_lock); + +if (drawback) + return rte_vhost_enqueue_burst(dev->vid, queue_id, pkts,count);
lib/librte_vhost/virtio_net.c +23
-1+ +return nb_tx; +} + +uint16_t +rte_vhost_submit_enqueue_burst (int vid,uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count) +{ +struct virtio_net *dev =get_device (vid); + +if (!dev) +return 0 ; + +if (unlikely (!(dev->flags &VIRTIO_DEV_BUILTIN_VIRTIO_NET ))) { +VHOST_LOG_DATA (ERR , +"(%d) %s: built-in vhost net backend is disabled.\n" , + dev->vid, __func__); +return 0 ; + } + +return virtio_dev_rx_async_submit (dev, queue_id, pkts, count); +} +static inline bool virtio_net_with_host_offload (struct virtio_net *dev) { --1.8.3.1
Re: [dpdk-dev] [PATCH v1 2/2] vhost: introduce async enqueue for split ring
Hi,
Quoted 26 lines
-----Original Message-----
From: Liu, Yong <[email protected]>
Sent: Thursday, June 18, 2020 2:57 PM
To: Fu, Patrick <[email protected]>
Cc: Fu, Patrick <[email protected]>; Jiang, Cheng1 <[email protected]>; Liang, Cunming <[email protected]>; [email protected]; [email protected]; Xia, Chenbo <[email protected]>; Wang, Zhihong <[email protected]>; Ye, Xiaolong <[email protected]>
Subject: RE: [dpdk-dev] [PATCH v1 2/2] vhost: introduce async enqueue for split ringThanks, Patrick. Some comments are inline.
Quoted 12 lines
From: Patrick <[email protected]>
This patch implement async enqueue data path for split ring.
Signed-off-by Patrick <[email protected]>--- lib/librte_vhost/rte_vhost_async.h | 38 +++ lib/librte_vhost/virtio_net.c | 538 ++++++++++++++++++++++++++++++++++++- 2 files changed, 574 insertions(+), 2 deletions(-)
Quoted 16 lines
lib/librte_vhost/rte_vhost_async.h
Quoted 12 lines
lib/librte_vhost/rte_vhost_async.h +7
-0+ +static __rte_always_inline int +async_mbuf_to_desc (struct virtio_net *dev,struct vhost_virtqueue *vq, +struct rte_mbuf *m,struct buf_vector *buf_vec, +uint16_t nr_vec,uint16_t num_buffers, +struct iovec *src_iovec,struct iovec *dst_iovec, +struct iov_it *src_it,struct iov_it *dst_it) {There're too much arguments in this function, please check whether it will impact performance.
I guess src_iovec & dst_iovec could be removed from the parameter list.
Quoted 104 lines
Quoted 104 lines
lib/librte_vhost/rte_vhost_async.h +37
-0+uint32_t vec_idx =0 ; +uint32_t mbuf_offset, mbuf_avail; +uint32_t buf_offset, buf_avail; +uint64_t buf_addr, buf_iova, buf_len; +uint32_t cpy_len, cpy_threshold; +uint64_t hdr_addr; +struct rte_mbuf *hdr_mbuf; +struct batch_copy_elem *batch_copy = vq->batch_copy_elems; +struct virtio_net_hdr_mrg_rxbuf tmp_hdr, *hdr =NULL ; +int error =0 ; + +uint32_t tlen =0 ; +int tvec_idx =0 ; +void *hpa; + +if (unlikely (m ==NULL )) { + error =-1 ; + goto out; + } + + cpy_threshold = vq->async_threshold; + + buf_addr = buf_vec[vec_idx].buf_addr; + buf_iova = buf_vec[vec_idx].buf_iova; + buf_len = buf_vec[vec_idx].buf_len; + +if (unlikely (buf_len < dev->vhost_hlen && nr_vec <=1 )) { + error =-1 ; + goto out; + } + + hdr_mbuf = m; + hdr_addr = buf_addr; +if (unlikely (buf_len < dev->vhost_hlen)) + hdr = &tmp_hdr; +else + hdr = (struct virtio_net_hdr_mrg_rxbuf*)(uintptr_t)hdr_addr;
lib/librte_vhost/rte_vhost_async.h +52
-0+ +VHOST_LOG_DATA (DEBUG ,"(%d) RX: num merge buffers %d\n" , + dev->vid, num_buffers); + +if (unlikely (buf_len < dev->vhost_hlen)) { + buf_offset = dev->vhost_hlen - buf_len; + vec_idx++; + buf_addr = buf_vec[vec_idx].buf_addr; + buf_iova = buf_vec[vec_idx].buf_iova; + buf_len = buf_vec[vec_idx].buf_len; + buf_avail = buf_len - buf_offset; + }else { + buf_offset = dev->vhost_hlen; + buf_avail = buf_len - dev->vhost_hlen; + } + + mbuf_avail =rte_pktmbuf_data_len (m); + mbuf_offset =0 ; + +while (mbuf_avail !=0 || m->next !=NULL ) { +/* done with current buf, get the next one */ +if (buf_avail ==0 ) { + vec_idx++; +if (unlikely (vec_idx >= nr_vec)) { + error =-1 ; + goto out; + } + + buf_addr = buf_vec[vec_idx].buf_addr; + buf_iova = buf_vec[vec_idx].buf_iova; + buf_len = buf_vec[vec_idx].buf_len; + + buf_offset =0 ; + buf_avail = buf_len; + } + +/* done with current mbuf, get the next one */ +if (mbuf_avail ==0 ) { + m = m->next; + + mbuf_offset =0 ; + mbuf_avail =rte_pktmbuf_data_len (m); + } + +if (hdr_addr) { +virtio_enqueue_offload (hdr_mbuf, &hdr->hdr); +if (rxvq_is_mergeable (dev)) +ASSIGN_UNLESS_EQUAL (hdr->num_buffers, + num_buffers); + +if (unlikely (hdr == &tmp_hdr)) { + copy_vnet_hdr_to_desc(dev, vq, buf_vec,hdr);
lib/librte_vhost/rte_vhost_async.h +13
-0+ }else { +PRINT_PACKET (dev, (uintptr_t )hdr_addr, + dev->vhost_hlen,0 ); +vhost_log_cache_write_iova (dev, vq, + buf_vec[0 ].buf_iova, + dev->vhost_hlen); + } + + hdr_addr =0 ; + } + + cpy_len =RTE_MIN (buf_avail, mbuf_avail); +
Quoted 9 lines
lib/librte_vhost/rte_vhost_async.h
Quoted 3 lines
lib/librte_vhost/rte_vhost_async.h +3
-0+if (unlikely (cpy_len >= cpy_threshold)) { + hpa = (void *)(uintptr_t )gpa_to_hpa (dev, + buf_iova + buf_offset, cpy_len);I have one question here. If user has called async copy directly, should vhost library still check copy threshold for software fallback?
If need software fallback, IMHO it will be more suitable to handle it in copy device driver.
Technically, we can delegate the threshold judgement from vhost to application callbacks. This will significantly increase the complexity of the callback implementations, which have to maintain correct ordering between dma copied data and CPU copies data. Meanwhile, it actually doesn't help to boost performance comparing with current vhost implementation. Considering this threshold is a generic design, I would still prefer to keep it in vhost.
Quoted 5 lines
IMHO, the cost will be too high for checking and fix virtio header in async copy function.
Since this is async copy datapath, could it possible that eliminate the cost in calculation of segmented addresses?
Yes, I believe async data path certainly brings new opportunity to apply more optimizations. However, at current time frame, settling down the overall async framework might be the priority.
Thanks,
Patrick
Re: [dpdk-dev] [PATCH v1 2/2] vhost: introduce async enqueue for split ring
In reply to [email protected]Quoted 3 lines · On 6/11/20 12:02 PM, [email protected] wrote:
From: Patrick <[email protected]>
This patch implement async enqueue data path for split ring.
A bit more verbose commit message would be helpful since the cover letter won't be in the git history. Duplicating relevant parts from the cover letter would be sufficient.
Quoted 563 lines
Signed-off-by Patrick <[email protected]>--- lib/librte_vhost/rte_vhost_async.h | 38 +++ lib/librte_vhost/virtio_net.c | 538 ++++++++++++++++++++++++++++++++++++- 2 files changed, 574 insertions(+), 2 deletions(-)lib/librte_vhost/rte_vhost_async.h +38
-0@@ -131,4 +131,42 @@ int rte_vhost_async_channel_register(int vid, uint16_t queue_id,*/ int rte_vhost_async_channel_unregister (int vid,uint16_t queue_id); +/** +* This function submit enqueue data to DMA. This function has no +* guranttee to the transfer completion upon return. Applications should +* poll transfer status by rte_vhost_poll_enqueue_completed() +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data +* @param pkts +* array of packets to be enqueued +* @param count +* packets num to be enqueued +* @return +* num of packets enqueued +*/ +uint16_t rte_vhost_submit_enqueue_burst (int vid,uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); + +/** +* This function check DMA completion status for a specific vhost +* device queue. Packets which finish copying (enqueue) operation +* will be returned in an array. +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data +* @param pkts +* blank array to get return packet pointer +* @param count +* size of the packet array +* @return +* num of packets returned +*/ +uint16_t rte_vhost_poll_enqueue_completed (int vid,uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); +#endif /* _RTE_VDPA_H_ */ lib/librte_vhost/virtio_net.c +473
-2@@ -17,14 +17,15 @@#include <rte_arp.h> #include <rte_spinlock.h> #include <rte_malloc.h> +#include <rte_vhost_async.h> #include "iotlb.h" #include "vhost.h" -#define MAX_PKT_BURST 32 -#define MAX_BATCH_LEN 256 +#define VHOST_ASYNC_BATCH_THRESHOLD 8 + static __rte_always_inline boolrxvq_is_mergeable (struct virtio_net *dev) {@@ -117,6 +118,35 @@ } static __rte_always_inline void +async_flush_shadow_used_ring_split (struct virtio_net *dev, +struct vhost_virtqueue *vq) +{ +uint16_t used_idx = vq->last_used_idx & (vq->size -1 ); + +if (used_idx + vq->shadow_used_idx <= vq->size) { +do_flush_shadow_used_ring_split (dev, vq, used_idx,0 , + vq->shadow_used_idx); + }else { +uint16_t size; + +/* update used ring interval [used_idx, vq->size] */ + size = vq->size - used_idx; +do_flush_shadow_used_ring_split (dev, vq, used_idx,0 , size); + +/* update the left half used ring interval [0, left_size] */ +do_flush_shadow_used_ring_split (dev, vq,0 , size, + vq->shadow_used_idx - size); + } + vq->last_used_idx += vq->shadow_used_idx; + +rte_smp_wmb (); + +vhost_log_cache_sync (dev, vq); + + vq->shadow_used_idx =0 ; +} + +static __rte_always_inline voidupdate_shadow_used_ring_split (struct vhost_virtqueue *vq,uint16_t desc_idx,uint32_t len) {@@ -905,6 +935,199 @@return error; } +static __rte_always_inline void +async_fill_vec (struct iovec *v,void *base,size_t len) +{ + v->iov_base = base; + v->iov_len = len; +} + +static __rte_always_inline void +async_fill_it (struct iov_it *it,size_t count, +struct iovec *vec,unsigned long nr_seg) +{ + it->offset =0 ; + it->count = count; + +if (count) { + it->iov = vec; + it->nr_segs = nr_seg; + }else { + it->iov =0 ; + it->nr_segs =0 ; + } +} + +static __rte_always_inline void +async_fill_des (struct dma_trans_desc *desc, +struct iov_it *src,struct iov_it *dst) +{ + desc->src = src; + desc->dst = dst; +} + +static __rte_always_inline int +async_mbuf_to_desc (struct virtio_net *dev,struct vhost_virtqueue *vq, +struct rte_mbuf *m,struct buf_vector *buf_vec, +uint16_t nr_vec,uint16_t num_buffers, +struct iovec *src_iovec,struct iovec *dst_iovec, +struct iov_it *src_it,struct iov_it *dst_it) +{ +uint32_t vec_idx =0 ; +uint32_t mbuf_offset, mbuf_avail; +uint32_t buf_offset, buf_avail; +uint64_t buf_addr, buf_iova, buf_len; +uint32_t cpy_len, cpy_threshold; +uint64_t hdr_addr; +struct rte_mbuf *hdr_mbuf; +struct batch_copy_elem *batch_copy = vq->batch_copy_elems; +struct virtio_net_hdr_mrg_rxbuf tmp_hdr, *hdr =NULL ; +int error =0 ; + +uint32_t tlen =0 ; +int tvec_idx =0 ; +void *hpa; + +if (unlikely (m ==NULL )) { + error =-1 ; + goto out; + } + + cpy_threshold = vq->async_threshold; + + buf_addr = buf_vec[vec_idx].buf_addr; + buf_iova = buf_vec[vec_idx].buf_iova; + buf_len = buf_vec[vec_idx].buf_len; + +if (unlikely (buf_len < dev->vhost_hlen && nr_vec <=1 )) { + error =-1 ; + goto out; + } + + hdr_mbuf = m; + hdr_addr = buf_addr; +if (unlikely (buf_len < dev->vhost_hlen)) + hdr = &tmp_hdr; +else + hdr = (struct virtio_net_hdr_mrg_rxbuf *)(uintptr_t )hdr_addr; + +VHOST_LOG_DATA (DEBUG ,"(%d) RX: num merge buffers %d\n" , + dev->vid, num_buffers); + +if (unlikely (buf_len < dev->vhost_hlen)) { + buf_offset = dev->vhost_hlen - buf_len; + vec_idx++; + buf_addr = buf_vec[vec_idx].buf_addr; + buf_iova = buf_vec[vec_idx].buf_iova; + buf_len = buf_vec[vec_idx].buf_len; + buf_avail = buf_len - buf_offset; + }else { + buf_offset = dev->vhost_hlen; + buf_avail = buf_len - dev->vhost_hlen; + } + + mbuf_avail =rte_pktmbuf_data_len (m); + mbuf_offset =0 ; + +while (mbuf_avail !=0 || m->next !=NULL ) { +/* done with current buf, get the next one */ +if (buf_avail ==0 ) { + vec_idx++; +if (unlikely (vec_idx >= nr_vec)) { + error =-1 ; + goto out; + } + + buf_addr = buf_vec[vec_idx].buf_addr; + buf_iova = buf_vec[vec_idx].buf_iova; + buf_len = buf_vec[vec_idx].buf_len; + + buf_offset =0 ; + buf_avail = buf_len; + } + +/* done with current mbuf, get the next one */ +if (mbuf_avail ==0 ) { + m = m->next; + + mbuf_offset =0 ; + mbuf_avail =rte_pktmbuf_data_len (m); + } + +if (hdr_addr) { +virtio_enqueue_offload (hdr_mbuf, &hdr->hdr); +if (rxvq_is_mergeable (dev)) +ASSIGN_UNLESS_EQUAL (hdr->num_buffers, + num_buffers); + +if (unlikely (hdr == &tmp_hdr)) { +copy_vnet_hdr_to_desc (dev, vq, buf_vec, hdr); + }else { +PRINT_PACKET (dev, (uintptr_t )hdr_addr, + dev->vhost_hlen,0 ); +vhost_log_cache_write_iova (dev, vq, + buf_vec[0 ].buf_iova, + dev->vhost_hlen); + } + + hdr_addr =0 ; + } + + cpy_len =RTE_MIN (buf_avail, mbuf_avail); + +if (unlikely (cpy_len >= cpy_threshold)) { + hpa = (void *)(uintptr_t )gpa_to_hpa (dev, + buf_iova + buf_offset, cpy_len); + +if (unlikely (!hpa)) { + error =-1 ; + goto out; + } + +async_fill_vec (src_iovec + tvec_idx, + (void *)(uintptr_t )rte_pktmbuf_iova_offset (m, + mbuf_offset), cpy_len); + +async_fill_vec (dst_iovec + tvec_idx, hpa, cpy_len); + + tlen += cpy_len; + tvec_idx++; + }else { +if (unlikely (vq->batch_copy_nb_elems >= vq->size)) { +rte_memcpy ( + (void *)((uintptr_t )(buf_addr + buf_offset)), + rte_pktmbuf_mtod_offset(m, void *, mbuf_offset), + cpy_len); + +PRINT_PACKET (dev, + (uintptr_t )(buf_addr + buf_offset), + cpy_len,0 ); + }else { + batch_copy[vq->batch_copy_nb_elems].dst = + (void *)((uintptr_t )(buf_addr + buf_offset)); + batch_copy[vq->batch_copy_nb_elems].src = + rte_pktmbuf_mtod_offset(m, void *, mbuf_offset); + batch_copy[vq->batch_copy_nb_elems].log_addr = + buf_iova + buf_offset; + batch_copy[vq->batch_copy_nb_elems].len = + cpy_len; + vq->batch_copy_nb_elems++; + } + } + + mbuf_avail -= cpy_len; + mbuf_offset += cpy_len; + buf_avail -= cpy_len; + buf_offset += cpy_len; + } + +out: +async_fill_it (src_it, tlen, src_iovec, tvec_idx); +async_fill_it (dst_it, tlen, dst_iovec, tvec_idx); + +return error; +} + static __rte_always_inline int vhost_enqueue_single_packed(struct virtio_net *dev, struct vhost_virtqueue *vq,@@ -1236,6 +1459,317 @@return virtio_dev_rx (dev, queue_id, pkts, count); } +static __rte_always_inline void +virtio_dev_rx_async_submit_split_err (struct virtio_net *dev, +struct vhost_virtqueue *vq,uint16_t queue_id, +uint16_t last_idx,uint16_t shadow_idx) +{ +while (vq->async_pkts_inflight_n) { +int er = vq->async_ops.check_completed_copies (dev->vid, + queue_id,0 ,MAX_PKT_BURST ); + +if (er <0 ) { + vq->async_pkts_inflight_n =0 ; +break ; + } + + vq->async_pkts_inflight_n -= er; + } + + vq->shadow_used_idx = shadow_idx; + vq->last_avail_idx = last_idx; +} + +static __rte_noinline uint32_t +virtio_dev_rx_async_submit_split (struct virtio_net *dev, +struct vhost_virtqueue *vq,uint16_t queue_id, +struct rte_mbuf **pkts,uint32_t count) +{ +uint32_t pkt_idx =0 , pkt_burst_idx =0 ; +uint16_t num_buffers; +struct buf_vector buf_vec[BUF_VECTOR_MAX ]; +uint16_t avail_head, last_idx, shadow_idx; + +struct iov_it *it_pool = vq->it_pool; +struct iovec *vec_pool = vq->vec_pool; +struct dma_trans_desc tdes[MAX_PKT_BURST ]; +struct iovec *src_iovec = vec_pool; +struct iovec *dst_iovec = vec_pool + (VHOST_MAX_ASYNC_VEC >>1 ); +struct iov_it *src_it = it_pool; +struct iov_it *dst_it = it_pool +1 ; +uint16_t n_free_slot, slot_idx; +int n_pkts =0 ; + + avail_head = *((volatile uint16_t *)&vq->avail->idx); + last_idx = vq->last_avail_idx; + shadow_idx = vq->shadow_used_idx; + +/* +* The ordering between avail index and +* desc reads needs to be enforced. +*/ +rte_smp_rmb (); + +rte_prefetch0 (&vq->avail->ring[vq->last_avail_idx & (vq->size -1 )]); + +for (pkt_idx =0 ; pkt_idx < count; pkt_idx++) { +uint32_t pkt_len = pkts[pkt_idx]->pkt_len + dev->vhost_hlen; +uint16_t nr_vec =0 ; + +if (unlikely (reserve_avail_buf_split (dev, vq, + pkt_len, buf_vec, &num_buffers, + avail_head, &nr_vec) <0 )) { +VHOST_LOG_DATA (DEBUG , +"(%d) failed to get enough desc from vring\n" , + dev->vid); + vq->shadow_used_idx -= num_buffers; +break ; + } + +VHOST_LOG_DATA (DEBUG ,"(%d) current index %d | end index %d\n" , + dev->vid, vq->last_avail_idx, + vq->last_avail_idx + num_buffers); + +if (async_mbuf_to_desc (dev, vq, pkts[pkt_idx], + buf_vec, nr_vec, num_buffers, + src_iovec, dst_iovec, src_it, dst_it) <0 ) { + vq->shadow_used_idx -= num_buffers; +break ; + } + + slot_idx = (vq->async_pkts_idx + pkt_idx) & (vq->size -1 ); +if (src_it->count) { +async_fill_des (&tdes[pkt_burst_idx], src_it, dst_it); + pkt_burst_idx++; + vq->async_pending_info[slot_idx] = + num_buffers | (src_it->nr_segs <<16 ); + src_iovec += src_it->nr_segs; + dst_iovec += dst_it->nr_segs; + src_it +=2 ; + dst_it +=2 ; + }else { + vq->async_pending_info[slot_idx] = num_buffers; + vq->async_pkts_inflight_n++; + } + + vq->last_avail_idx += num_buffers; + +if (pkt_burst_idx >=VHOST_ASYNC_BATCH_THRESHOLD || + (pkt_idx == count -1 && pkt_burst_idx)) { + n_pkts = vq->async_ops.transfer_data (dev->vid, + queue_id, tdes,0 , pkt_burst_idx); + src_iovec = vec_pool; + dst_iovec = vec_pool + (VHOST_MAX_ASYNC_VEC >>1 ); + src_it = it_pool; + dst_it = it_pool +1 ; + +if (unlikely (n_pkts < (int )pkt_burst_idx)) { + vq->async_pkts_inflight_n += + n_pkts >0 ? n_pkts :0 ; +virtio_dev_rx_async_submit_split_err (dev, + vq, queue_id, last_idx, shadow_idx); +return 0 ; + } + + pkt_burst_idx =0 ; + vq->async_pkts_inflight_n += n_pkts; + } + } + +if (pkt_burst_idx) { + n_pkts = vq->async_ops.transfer_data (dev->vid, + queue_id, tdes,0 , pkt_burst_idx); +if (unlikely (n_pkts <= (int )pkt_burst_idx)) { + vq->async_pkts_inflight_n += n_pkts >0 ? n_pkts :0 ; +virtio_dev_rx_async_submit_split_err (dev, vq, queue_id, + last_idx, shadow_idx); +return 0 ; + } + + vq->async_pkts_inflight_n += n_pkts; + } + +do_data_copy_enqueue (dev, vq); + + n_free_slot = vq->size - vq->async_pkts_idx; +if (n_free_slot > pkt_idx) { +rte_memcpy (&vq->async_pkts_pending[vq->async_pkts_idx], + pkts, pkt_idx *sizeof (uintptr_t )); + vq->async_pkts_idx += pkt_idx; + }else { +rte_memcpy (&vq->async_pkts_pending[vq->async_pkts_idx], + pkts, n_free_slot *sizeof (uintptr_t )); +rte_memcpy (&vq->async_pkts_pending[0 ], + &pkts[n_free_slot], + (pkt_idx - n_free_slot) *sizeof (uintptr_t )); + vq->async_pkts_idx = pkt_idx - n_free_slot; + } + +if (likely (vq->shadow_used_idx)) +async_flush_shadow_used_ring_split (dev, vq); + +return pkt_idx; +} + +uint16_t rte_vhost_poll_enqueue_completed (int vid,uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count) +{ +struct virtio_net *dev =get_device (vid); +struct vhost_virtqueue *vq; +uint16_t n_pkts_cpl, n_pkts_put =0 , n_descs =0 ; +uint16_t start_idx, pkts_idx, vq_size; +uint64_t *async_pending_info; + +VHOST_LOG_DATA (DEBUG ,"(%d) %s\n" , dev->vid, __func__); +if (unlikely (!is_valid_virt_queue_idx (queue_id,0 , dev->nr_vring))) { +VHOST_LOG_DATA (ERR ,"(%d) %s: invalid virtqueue idx %d.\n" , + dev->vid, __func__, queue_id); +return 0 ; + } + + vq = dev->virtqueue[queue_id]; + +rte_spinlock_lock (&vq->access_lock); + + pkts_idx = vq->async_pkts_idx; + async_pending_info = vq->async_pending_info; + vq_size = vq->size; + start_idx = pkts_idx > vq->async_pkts_inflight_n ? + pkts_idx - vq->async_pkts_inflight_n : + (vq_size - vq->async_pkts_inflight_n + pkts_idx) & + (vq_size -1 ); + + n_pkts_cpl = + vq->async_ops.check_completed_copies (vid, queue_id,0 , count); + +rte_smp_wmb (); + +while (likely (((start_idx + n_pkts_put) & (vq_size -1 )) != pkts_idx)) { +uint64_t info = async_pending_info[ + (start_idx + n_pkts_put) & (vq_size -1 )]; +uint64_t n_segs; + n_pkts_put++; + n_descs += info &ASYNC_PENDING_INFO_N_MSK ; + n_segs = info >>ASYNC_PENDING_INFO_N_SFT ; + +if (n_segs) { +if (!n_pkts_cpl || n_pkts_cpl < n_segs) { + n_pkts_put--; + n_descs -= info &ASYNC_PENDING_INFO_N_MSK ; +if (n_pkts_cpl) { + async_pending_info[ + (start_idx + n_pkts_put) & + (vq_size -1 )] = + ((n_segs - n_pkts_cpl) << +ASYNC_PENDING_INFO_N_SFT ) | + (info &ASYNC_PENDING_INFO_N_MSK ); + n_pkts_cpl =0 ; + } +break ; + } + n_pkts_cpl -= n_segs; + } + } + +if (n_pkts_put) { + vq->async_pkts_inflight_n -= n_pkts_put; + *(volatile uint16_t *)&vq->used->idx += n_descs; + +vhost_vring_call_split (dev, vq); + } + +if (start_idx + n_pkts_put <= vq_size) { +rte_memcpy (pkts, &vq->async_pkts_pending[start_idx], + n_pkts_put *sizeof (uintptr_t )); + }else { +rte_memcpy (pkts, &vq->async_pkts_pending[start_idx], + (vq_size - start_idx) *sizeof (uintptr_t )); +rte_memcpy (&pkts[vq_size - start_idx], vq->async_pkts_pending, + (n_pkts_put - vq_size + start_idx) *sizeof (uintptr_t )); + } + +rte_spinlock_unlock (&vq->access_lock); + +return n_pkts_put; +} + +static __rte_always_inline uint32_t +virtio_dev_rx_async_submit (struct virtio_net *dev,uint16_t queue_id, +struct rte_mbuf **pkts,uint32_t count) +{ +struct vhost_virtqueue *vq; +uint32_t nb_tx =0 ; +bool drawback = false; + +VHOST_LOG_DATA (DEBUG ,"(%d) %s\n" , dev->vid, __func__); +if (unlikely (!is_valid_virt_queue_idx (queue_id,0 , dev->nr_vring))) { +VHOST_LOG_DATA (ERR ,"(%d) %s: invalid virtqueue idx %d.\n" , + dev->vid, __func__, queue_id); +return 0 ; + }
lib/librte_vhost/virtio_net.c line 1719
Quoted 10 lines
lib/librte_vhost/virtio_net.c +10
-0+ + vq = dev->virtqueue[queue_id]; + +rte_spinlock_lock (&vq->access_lock); + +if (unlikely (vq->enabled ==0 )) + goto out_access_unlock; + +if (unlikely (!vq->async_registered)) { + drawback = true;
fallback instead?
Quoted 57 lines
lib/librte_vhost/virtio_net.c +53
-0+ goto out_access_unlock; + } + +if (dev->features & (1ULL <<VIRTIO_F_IOMMU_PLATFORM )) +vhost_user_iotlb_rd_lock (vq); + +if (unlikely (vq->access_ok ==0 )) +if (unlikely (vring_translate (dev, vq) <0 )) + goto out; + + count =RTE_MIN ((uint32_t )MAX_PKT_BURST , count); +if (count ==0 ) + goto out; + +/* TODO: packed queue not implemented */ +if (vq_is_packed (dev)) + nb_tx =0 ; +else + nb_tx =virtio_dev_rx_async_submit_split (dev, + vq, queue_id, pkts, count); + +out: +if (dev->features & (1ULL <<VIRTIO_F_IOMMU_PLATFORM )) +vhost_user_iotlb_rd_unlock (vq); + +out_access_unlock: +rte_spinlock_unlock (&vq->access_lock); + +if (drawback) +return rte_vhost_enqueue_burst (dev->vid, queue_id, pkts, count); + +return nb_tx; +} + +uint16_t +rte_vhost_submit_enqueue_burst (int vid,uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count) +{ +struct virtio_net *dev =get_device (vid); + +if (!dev) +return 0 ; + +if (unlikely (!(dev->flags &VIRTIO_DEV_BUILTIN_VIRTIO_NET ))) { +VHOST_LOG_DATA (ERR , +"(%d) %s: built-in vhost net backend is disabled.\n" , + dev->vid, __func__); +return 0 ; + } + +return virtio_dev_rx_async_submit (dev, queue_id, pkts, count); +} +static inline bool virtio_net_with_host_offload (struct virtio_net *dev) {
Re: [dpdk-dev] [PATCH v1 2/2] vhost: introduce async enqueue for split ring
In reply to [email protected]Quoted 46 lines · On 6/11/20 12:02 PM, [email protected] wrote:
From: Patrick <[email protected]>
This patch implement async enqueue data path for split ring.
Signed-off-by Patrick <[email protected]>--- lib/librte_vhost/rte_vhost_async.h | 38 +++ lib/librte_vhost/virtio_net.c | 538 ++++++++++++++++++++++++++++++++++++- 2 files changed, 574 insertions(+), 2 deletions(-)lib/librte_vhost/rte_vhost_async.h +28
-0@@ -131,4 +131,42 @@ int rte_vhost_async_channel_register(int vid, uint16_t queue_id,*/ int rte_vhost_async_channel_unregister (int vid,uint16_t queue_id); +/** +* This function submit enqueue data to DMA. This function has no +* guranttee to the transfer completion upon return. Applications should +* poll transfer status by rte_vhost_poll_enqueue_completed() +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data +* @param pkts +* array of packets to be enqueued +* @param count +* packets num to be enqueued +* @return +* num of packets enqueued +*/ +uint16_t rte_vhost_submit_enqueue_burst (int vid,uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); + +/** +* This function check DMA completion status for a specific vhost +* device queue. Packets which finish copying (enqueue) operation +* will be returned in an array. +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data
lib/librte_vhost/rte_vhost_async.h int rte_vhost_async_channel_register(int vid, uint16_t queue_id, · line 171
Quoted 10 lines
lib/librte_vhost/rte_vhost_async.h +10
-0+* @param pkts +* blank array to get return packet pointer +* @param count +* size of the packet array +* @return +* num of packets returned +*/ +uint16_t rte_vhost_poll_enqueue_completed (int vid,uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); +
These new APIs need to be tagged as experimental. We'll need a few releases before considering them stable.
You need to add them to rte_vhost_version.map too.
lib/librte_vhost/rte_vhost_async.h int rte_vhost_async_channel_register(int vid, uint16_t queue_id, · line 172
Quoted 1 line
lib/librte_vhost/rte_vhost_async.h +0
-0#endif /* _RTE_VDPA_H_ */
You need to fix the comment here (/* _RTE_VHOST_ASYNC_H_ */)
Re: [dpdk-dev] [PATCH v1 2/2] vhost: introduce async enqueue for split ring
Hi Maxime,
Quoted 77 lines
-----Original Message-----
From: Maxime Coquelin <[email protected]>
Sent: Friday, June 26, 2020 10:46 PM
To: Fu, Patrick <[email protected]>; [email protected]; Xia, Chenbo <[email protected]>; Wang, Zhihong <[email protected]>; Ye, Xiaolong <[email protected]>
Cc: Jiang, Cheng1 <[email protected]>; Liang, Cunming <[email protected]>
Subject: Re: [PATCH v1 2/2] vhost: introduce async enqueue for split ringQuoted 8 lines · On 6/11/20 12:02 PM, [email protected] wrote:
From: Patrick <[email protected]>
This patch implement async enqueue data path for split ring.
Signed-off-by Patrick <[email protected]>--- lib/librte_vhost/rte_vhost_async.h | 38 +++ lib/librte_vhost/virtio_net.c | 538++++++++++++++++++++++++++++++++++++-
lib/librte_vhost/rte_vhost_async.h int rte_vhost_async_channel_register(int vid,
Quoted 8 lines
2 files changed, 574 insertions(+), 2 deletions(-)lib/librte_vhost/rte_vhost_async.h +0
-0@@ -131,4 +131,42 @@ int rte_vhost_async_channel_register(int vid,
uint16_tqueue_id,Quoted 32 lines
lib/librte_vhost/rte_vhost_async.h +29
-0*/ int rte_vhost_async_channel_unregister (int vid,uint16_t queue_id); +/** +* This function submit enqueue data to DMA. This function has no +* guranttee to the transfer completion upon return. Applications +should +* poll transfer status by rte_vhost_poll_enqueue_completed() +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data +* @param pkts +* array of packets to be enqueued +* @param count +* packets num to be enqueued +* @return +* num of packets enqueued +*/ +uint16_t rte_vhost_submit_enqueue_burst (int vid,uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); + +/** +* This function check DMA completion status for a specific vhost +* device queue. Packets which finish copying (enqueue) operation +* will be returned in an array. +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data lib/librte_vhost/rte_vhost_async.h int rte_vhost_async_channel_register(int vid, uint16_t queue_id, · line 171
Quoted 10 lines
lib/librte_vhost/rte_vhost_async.h +10
-0+* @param pkts +* blank array to get return packet pointer +* @param count +* size of the packet array +* @return +* num of packets returned +*/ +uint16_t rte_vhost_poll_enqueue_completed (int vid,uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); +These new APIs need to be tagged as experimental. We'll need a few releases before considering them stable.
Quoted 4 lines
You need to add them to rte_vhost_version.map too.
Quoted 1 line
#endif /* _RTE_VDPA_H_ */
You need to fix the comment here (/* _RTE_VHOST_ASYNC_H_ */)
I will update in the v2 version
Thanks,
Patrick
Hi Patrick,
Quoted 16 lines · On 6/11/20 12:02 PM, [email protected] wrote:
From: Patrick Fu <[email protected]>
Performing large memory copies usually takes up a major part of CPU cycles and becomes the hot spot in vhost-user enqueue operation. To offload expensive memory operations from the CPU, this patch set proposes to leverage DMA engines, e.g., I/OAT, a DMA engine in the Intel's processor, to accelerate large copies.
Large copies are offloaded from the CPU to the DMA in an asynchronous manner. The CPU just submits copy jobs to the DMA but without waiting for its copy completion. Thus, there is no CPU intervention during data transfer; we can save precious CPU cycles and improve the overall throughput for vhost-user based applications, like OVS. During packet transmission, it offloads large copies to the DMA and performs small copies by the CPU, due to startup overheads associated with the DMA.
Quoted 8 lines
This patch set construct a general framework that applications can leverage to attach DMA channels with vhost-user transmit queues. Four new RTE APIs are introduced to vhost library for applications to register and use the asynchronous data path. In addition, two new DMA operation callbacks are defined, by which vhost-user asynchronous data path can interact with DMA hardware. Currently only enqueue operation for split queue is implemented, but the frame is flexible to extend support for dequeue & packed queue.
Thanks for this big rework of the Vhost DMA series.
It looks overall good to me and is consistent with what design you suggested few months back.
I don't see a big risk to integrate it in v20.08 once the few comments are taken into account.
I'll try to make another pass before you send a v2.
Maxime
Quoted 15 lines
Patrick Fu (2):
vhost: introduce async data path registration API
vhost: introduce async enqueue for split ringlib/librte_vhost/Makefile | 3 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 172 ++++++++++++ lib/librte_vhost/socket.c | 20 ++ lib/librte_vhost/vhost.c | 74 ++++- lib/librte_vhost/vhost.h | 30 ++- lib/librte_vhost/vhost_user.c | 28 +- lib/librte_vhost/virtio_net.c | 538 ++++++++++++++++++++++++++++++++++++- 8 files changed, 857 insertions(+), 9 deletions(-) create mode 100644 lib/librte_vhost/rte_vhost_async.h
v3 cover introduce asynchronous data path for vhost
In reply to [email protected]From: Patrick Fu <[email protected]>
Performing large memory copies usually takes up a major part of CPU cycles and becomes the hot spot in vhost-user enqueue operation. To offload expensive memory operations from the CPU, this patch set proposes to leverage DMA engines, e.g., I/OAT, a DMA engine in the Intel's processor, to accelerate large copies.
Large copies are offloaded from the CPU to the DMA in an asynchronous manner. The CPU just submits copy jobs to the DMA but without waiting for its copy completion. Thus, there is no CPU intervention during data transfer; we can save precious CPU cycles and improve the overall throughput for vhost-user based applications, like OVS. During packet transmission, it offloads large copies to the DMA and performs small copies by the CPU, due to startup overheads associated with the DMA.
This patch set construct a general framework that applications can leverage to attach DMA channels with vhost-user transmit queues. Four new RTE APIs are introduced to vhost library for applications to register and use the asynchronous data path. In addition, two new DMA operation callbacks are defined, by which vhost-user asynchronous data path can interact with DMA hardware. Currently only enqueue operation for split queue is implemented, but the framework is flexible to extend support for packed queue.
v2:
update meson file for new header file
update rte_vhost_version.map to include new APIs rename async APIs/structures to be prefixed with "rte_vhost" rename some variables/structures for readibility correct minor typo in comments/license statements refine memory allocation logic for vq internal buffer add error message printing in some failure cases check inflight async packets in unregistration API call mark new APIs as experimental
v3:
use atomic_xxx() functions in updating ring index
fix a bug in async enqueue failure handling
Patrick Fu (2):
vhost: introduce async enqueue registration API
vhost: introduce async enqueue for split ring
lib/librte_vhost/Makefile | 2 +- lib/librte_vhost/meson.build | 2 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 176 +++++++++++ lib/librte_vhost/rte_vhost_version.map | 4 + lib/librte_vhost/socket.c | 20 ++ lib/librte_vhost/vhost.c | 127 +++++++- lib/librte_vhost/vhost.h | 30 +- lib/librte_vhost/vhost_user.c | 23 +- lib/librte_vhost/virtio_net.c | 539 ++++++++++++++++++++++++++++++++- 10 files changed, 915 insertions(+), 9 deletions(-) create mode 100644 lib/librte_vhost/rte_vhost_async.h
Signature · 1 line
1.8.3.1
PATCH v3 1/2 vhost: introduce async enqueue registration API
From: Patrick Fu <[email protected]>
This patch introduces registration/un-registration APIs for vhost async data enqueue operation. Together with the registration APIs implementations, data structures and async callback functions required for async enqueue data path are also defined.
--- lib/librte_vhost/Makefile | 2 +- lib/librte_vhost/meson.build | 2 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 136 +++++++++++++++++++++++++++++++++ lib/librte_vhost/rte_vhost_version.map | 4 + lib/librte_vhost/socket.c | 20 +++++ lib/librte_vhost/vhost.c | 127 +++++++++++++++++++++++++++++- lib/librte_vhost/vhost.h | 30 +++++++- lib/librte_vhost/vhost_user.c | 23 +++++- 9 files changed, 338 insertions(+), 7 deletions(-) create mode 100644 lib/librte_vhost/rte_vhost_async.h
lib/librte_vhost/Makefile +1 -1
@@ -42,7 +42,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c iotlb.c socket.c vhost.c \ # install includes SYMLINK-$(CONFIG_RTE_LIBRTE_VHOST)-include += rte_vhost.h rte_vdpa.h \ - rte_vdpa_dev.h + rte_vdpa_dev.h rte_vhost_async.h # only compile vhost crypto when cryptodev is enabled ifeq ($(CONFIG_RTE_LIBRTE_CRYPTODEV),y)
lib/librte_vhost/meson.build +1 -1
@@ -22,5 +22,5 @@ sources = files('fd_man.c', 'iotlb.c', 'socket.c', 'vdpa.c', 'vhost.c', 'vhost_user.c', 'virtio_net.c', 'vhost_crypto.c') headers = files('rte_vhost.h', 'rte_vdpa.h', 'rte_vdpa_dev.h', - 'rte_vhost_crypto.h') + 'rte_vhost_crypto.h', 'rte_vhost_async.h') deps += ['ethdev', 'cryptodev', 'hash', 'pci']
lib/librte_vhost/rte_vhost.h +1 -0
@@ -35,6 +35,7 @@#define RTE_VHOST_USER_EXTBUF_SUPPORT (1ULL << 5)/* support only linear buffers (no chained mbufs) */ #define RTE_VHOST_USER_LINEARBUF_SUPPORT (1ULL << 6) +#define RTE_VHOST_USER_ASYNC_COPY (1ULL << 7)/* Features. */ #ifndef VIRTIO_NET_F_GUEST_ANNOUNCE
lib/librte_vhost/rte_vhost_async.h new file +136 -0
136 lines not on this page · raw message
lib/librte_vhost/rte_vhost_version.map +4 -0
@@ -71,4 +71,8 @@ EXPERIMENTAL { rte_vdpa_get_queue_num; rte_vdpa_get_features; rte_vdpa_get_protocol_features; + rte_vhost_async_channel_register; + rte_vhost_async_channel_unregister; + rte_vhost_submit_enqueue_burst; + rte_vhost_poll_enqueue_completed; };
lib/librte_vhost/socket.c +20 -0
@@ -42,6 +42,7 @@ struct vhost_user_socket {bool use_builtin_virtio_net;bool extbuf;bool linearbuf; +bool async_copy;/* * The "supported_features" indicates the feature bits the
@@ -205,6 +206,7 @@ struct vhost_user {size_t size;struct vhost_user_connection *conn;int ret; +struct virtio_net *dev;if (vsocket ==NULL )return ;
@@ -236,6 +238,13 @@ struct vhost_user {if (vsocket->linearbuf)vhost_enable_linearbuf (vid); +if (vsocket->async_copy) { + dev =get_device (vid); + +if (dev) + dev->async_copy =1 ; + } +VHOST_LOG_CONFIG (INFO ,"new device, handle is %d\n" , vid);if (vsocket->notify_ops->new_connection) {
@@ -881,6 +890,17 @@ struct rte_vdpa_device * goto out_mutex; } + vsocket->async_copy = flags &RTE_VHOST_USER_ASYNC_COPY ; + +if (vsocket->async_copy && + (flags & (RTE_VHOST_USER_IOMMU_SUPPORT | +RTE_VHOST_USER_POSTCOPY_SUPPORT ))) { +VHOST_LOG_CONFIG (ERR ,"error: enabling async copy and IOMMU " +"or post-copy feature simultaneously is not " +"supported\n" ); + goto out_mutex; + } +/* * Set the supported features correctly for the builtin vhost-user * net driver.
lib/librte_vhost/vhost.c +126 -1
137 lines not on this page · raw message
lib/librte_vhost/vhost.h +29 -1
@@ -24,6 +24,8 @@#include "rte_vdpa.h" #include "rte_vdpa_dev.h" +#include "rte_vhost_async.h" +/* Used to indicate that the device is running on a data core */ #define VIRTIO_DEV_RUNNING 1/* Used to indicate that the device is ready to operate */
@@ -40,6 +42,11 @@#define VHOST_LOG_CACHE_NR 32 +#define MAX_PKT_BURST 32 + +#define VHOST_MAX_ASYNC_IT (MAX_PKT_BURST * 2) +#define VHOST_MAX_ASYNC_VEC (BUF_VECTOR_MAX * 2) +#define PACKED_DESC_ENQUEUE_USED_FLAG (w) \ ((w) ? (VRING_DESC_F_AVAIL | VRING_DESC_F_USED | VRING_DESC_F_WRITE) : \ VRING_DESC_F_WRITE)
@@ -202,6 +209,25 @@ struct vhost_virtqueue { TAILQ_HEAD(, vhost_iotlb_entry) iotlb_list;int iotlb_cache_nr; TAILQ_HEAD(, vhost_iotlb_entry) iotlb_pending_list; + +/* operation callbacks for async dma */ +struct rte_vhost_async_channel_ops async_ops; + +struct rte_vhost_iov_iter it_pool[VHOST_MAX_ASYNC_IT ]; +struct iovec vec_pool[VHOST_MAX_ASYNC_VEC ]; + +/* async data transfer status */ +uintptr_t **async_pkts_pending; +#define ASYNC_PENDING_INFO_N_MSK 0xFFFF +#define ASYNC_PENDING_INFO_N_SFT 16 +uint64_t *async_pending_info; +uint16_t async_pkts_idx; +uint16_t async_pkts_inflight_n; + +/* vq async features */ +bool async_inorder; +bool async_registered; +uint16_t async_threshold; } __rte_cache_aligned;#define VHOST_MAX_VRING 0x100
@@ -338,6 +364,7 @@ struct virtio_net {int16_t broadcast_rarp;uint32_t nr_vring;int dequeue_zero_copy; +int async_copy;int extbuf;int linearbuf;struct vhost_virtqueue *virtqueue[VHOST_MAX_QUEUE_PAIRS *2 ];
@@ -683,7 +710,8 @@ uint64_t translate_log_addr(struct virtio_net *dev, struct vhost_virtqueue *vq,/* Don't kick guest if we don't reach index specified by guest. */ if (dev->features & (1ULL <<VIRTIO_RING_F_EVENT_IDX )) {uint16_t old = vq->signalled_used; -uint16_t new = vq->last_used_idx; +uint16_t new = vq->async_pkts_inflight_n ? + vq->used->idx:vq->last_used_idx;bool signalled_used_valid = vq->signalled_used_valid; vq->signalled_used = new;
lib/librte_vhost/vhost_user.c +20 -3
@@ -476,12 +476,14 @@ }else {if (vq->shadow_used_split)rte_free (vq->shadow_used_split); + vq->shadow_used_split =rte_malloc (NULL , vq->size *sizeof (struct vring_used_elem ),RTE_CACHE_LINE_SIZE ); +if (!vq->shadow_used_split) {VHOST_LOG_CONFIG (ERR , -"failed to allocate memory for shadow used ring.\n" ); +"failed to allocate memory for vq internal data.\n" );return RTE_VHOST_MSG_RESULT_ERR ; } }
@@ -1166,7 +1168,8 @@ goto err_mmap; } - populate = (dev->dequeue_zero_copy) ?MAP_POPULATE :0 ; + populate = (dev->dequeue_zero_copy || dev->async_copy) ? +MAP_POPULATE :0 ; mmap_addr =mmap (NULL , mmap_size,PROT_READ |PROT_WRITE ,MAP_SHARED | populate, fd,0 );
@@ -1181,7 +1184,7 @@ reg->host_user_addr = (uint64_t )(uintptr_t )mmap_addr + mmap_offset; -if (dev->dequeue_zero_copy) +if (dev->dequeue_zero_copy || dev->async_copy)if (add_guest_pages (dev, reg, alignment) <0 ) { VHOST_LOG_CONFIG(ERR, "adding guest pages to region %u failed.\n",
@@ -1979,6 +1982,12 @@ static int vhost_user_set_vring_err(struct virtio_net **pdev __rte_unused, }else {rte_free (vq->shadow_used_split); vq->shadow_used_split =NULL ; +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + vq->async_pkts_pending =NULL ; + vq->async_pending_info =NULL ; }rte_free (vq->batch_copy_elems);
@@ -2012,6 +2021,14 @@ static int vhost_user_set_vring_err(struct virtio_net **pdev __rte_unused,"set queue enable: %d to qp idx: %d\n" , enable, index); +if (!enable && dev->virtqueue[index]->async_registered) { +if (dev->virtqueue[index]->async_pkts_inflight_n) { +VHOST_LOG_CONFIG (ERR ,"failed to disable vring. " +"async inflight packets must be completed first\n" ); +return RTE_VHOST_MSG_RESULT_ERR ; + } + } +/* On disable, rings have to be stopped being processed. */ if (!enable && dev->dequeue_zero_copy)drain_zmbuf_list (dev->virtqueue[index]);
Signature · 1 line
1.8.3.1
PATCH v3 2/2 vhost: introduce async enqueue for split ring
In reply to [email protected]From: Patrick Fu <[email protected]>
This patch implements async enqueue data path for split ring. 2 new async data path APIs are defined, by which applications can submit and poll packets to/from async engines. The async enqueue data leverages callback functions registered by applications to work with the async engine.
--- lib/librte_vhost/rte_vhost_async.h | 40 +++ lib/librte_vhost/virtio_net.c | 539 ++++++++++++++++++++++++++++++++++++- 2 files changed, 577 insertions(+), 2 deletions(-)
lib/librte_vhost/rte_vhost_async.h +40 -0
@@ -133,4 +133,44 @@ int rte_vhost_async_channel_register(int vid, uint16_t queue_id,__rte_experimental int rte_vhost_async_channel_unregister(int vid, uint16_t queue_id); +/** +* This function submit enqueue data to async engine. This function has +* no guranttee to the transfer completion upon return. Applications +* should poll transfer status by rte_vhost_poll_enqueue_completed() +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data +* @param pkts +* array of packets to be enqueued +* @param count +* packets num to be enqueued +* @return +* num of packets enqueued +*/ +__rte_experimental +uint16_t rte_vhost_submit_enqueue_burst(int vid, uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); + +/** +* This function check async completion status for a specific vhost +* device queue. Packets which finish copying (enqueue) operation +* will be returned in an array. +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data +* @param pkts +* blank array to get return packet pointer +* @param count +* size of the packet array +* @return +* num of packets returned +*/ +__rte_experimental +uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); +#endif /* _RTE_VHOST_ASYNC_H_ */
lib/librte_vhost/virtio_net.c +537 -2
569 lines not on this page · raw message
Signature · 1 line
1.8.3.1
v4 cover introduce asynchronous data path for vhost
In reply to [email protected]From: Patrick Fu <[email protected]>
Performing large memory copies usually takes up a major part of CPU cycles and becomes the hot spot in vhost-user enqueue operation. To offload expensive memory operations from the CPU, this patch set proposes to leverage DMA engines, e.g., I/OAT, a DMA engine in the Intel's processor, to accelerate large copies.
Large copies are offloaded from the CPU to the DMA in an asynchronous manner. The CPU just submits copy jobs to the DMA but without waiting for its copy completion. Thus, there is no CPU intervention during data transfer; we can save precious CPU cycles and improve the overall throughput for vhost-user based applications, like OVS. During packet transmission, it offloads large copies to the DMA and performs small copies by the CPU, due to startup overheads associated with the DMA.
This patch set construct a general framework that applications can leverage to attach DMA channels with vhost-user transmit queues. Four new RTE APIs are introduced to vhost library for applications to register and use the asynchronous data path. In addition, two new DMA operation callbacks are defined, by which vhost-user asynchronous data path can interact with DMA hardware. Currently only enqueue operation for split queue is implemented, but the framework is flexible to extend support for packed queue.
v2:
update meson file for new header file
update rte_vhost_version.map to include new APIs rename async APIs/structures to be prefixed with "rte_vhost" rename some variables/structures for readibility correct minor typo in comments/license statements refine memory allocation logic for vq internal buffer add error message printing in some failure cases check inflight async packets in unregistration API call mark new APIs as experimental
v3:
use atomic_xxx() functions in updating ring index
fix a bug in async enqueue failure handling
v4:
part of the fix intended in v3 patch was missed, this patch adds all thoes fixes
Patrick Fu (2):
vhost: introduce async enqueue registration API
vhost: introduce async enqueue for split ring
lib/librte_vhost/Makefile | 2 +- lib/librte_vhost/meson.build | 2 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 176 +++++++++++ lib/librte_vhost/rte_vhost_version.map | 4 + lib/librte_vhost/socket.c | 20 ++ lib/librte_vhost/vhost.c | 127 +++++++- lib/librte_vhost/vhost.h | 30 +- lib/librte_vhost/vhost_user.c | 23 +- lib/librte_vhost/virtio_net.c | 554 ++++++++++++++++++++++++++++++++- 10 files changed, 930 insertions(+), 9 deletions(-) create mode 100644 lib/librte_vhost/rte_vhost_async.h
Signature · 1 line
1.8.3.1
PATCH v4 1/2 vhost: introduce async enqueue registration API
From: Patrick Fu <[email protected]>
This patch introduces registration/un-registration APIs for vhost async data enqueue operation. Together with the registration APIs implementations, data structures and async callback functions required for async enqueue data path are also defined.
--- lib/librte_vhost/Makefile | 2 +- lib/librte_vhost/meson.build | 2 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 136 +++++++++++++++++++++++++++++++++ lib/librte_vhost/rte_vhost_version.map | 4 + lib/librte_vhost/socket.c | 20 +++++ lib/librte_vhost/vhost.c | 127 +++++++++++++++++++++++++++++- lib/librte_vhost/vhost.h | 30 +++++++- lib/librte_vhost/vhost_user.c | 23 +++++- 9 files changed, 338 insertions(+), 7 deletions(-) create mode 100644 lib/librte_vhost/rte_vhost_async.h
lib/librte_vhost/Makefile +1 -1
@@ -42,7 +42,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c iotlb.c socket.c vhost.c \ # install includes SYMLINK-$(CONFIG_RTE_LIBRTE_VHOST)-include += rte_vhost.h rte_vdpa.h \ - rte_vdpa_dev.h + rte_vdpa_dev.h rte_vhost_async.h # only compile vhost crypto when cryptodev is enabled ifeq ($(CONFIG_RTE_LIBRTE_CRYPTODEV),y)
lib/librte_vhost/meson.build +1 -1
@@ -22,5 +22,5 @@ sources = files('fd_man.c', 'iotlb.c', 'socket.c', 'vdpa.c', 'vhost.c', 'vhost_user.c', 'virtio_net.c', 'vhost_crypto.c') headers = files('rte_vhost.h', 'rte_vdpa.h', 'rte_vdpa_dev.h', - 'rte_vhost_crypto.h') + 'rte_vhost_crypto.h', 'rte_vhost_async.h') deps += ['ethdev', 'cryptodev', 'hash', 'pci']
lib/librte_vhost/rte_vhost.h +1 -0
@@ -35,6 +35,7 @@#define RTE_VHOST_USER_EXTBUF_SUPPORT (1ULL << 5)/* support only linear buffers (no chained mbufs) */ #define RTE_VHOST_USER_LINEARBUF_SUPPORT (1ULL << 6) +#define RTE_VHOST_USER_ASYNC_COPY (1ULL << 7)/* Features. */ #ifndef VIRTIO_NET_F_GUEST_ANNOUNCE
lib/librte_vhost/rte_vhost_async.h new file +136 -0
136 lines not on this page · raw message
lib/librte_vhost/rte_vhost_version.map +4 -0
@@ -71,4 +71,8 @@ EXPERIMENTAL { rte_vdpa_get_queue_num; rte_vdpa_get_features; rte_vdpa_get_protocol_features; + rte_vhost_async_channel_register; + rte_vhost_async_channel_unregister; + rte_vhost_submit_enqueue_burst; + rte_vhost_poll_enqueue_completed; };
lib/librte_vhost/socket.c +20 -0
@@ -42,6 +42,7 @@ struct vhost_user_socket {bool use_builtin_virtio_net;bool extbuf;bool linearbuf; +bool async_copy;/* * The "supported_features" indicates the feature bits the
@@ -205,6 +206,7 @@ struct vhost_user {size_t size;struct vhost_user_connection *conn;int ret; +struct virtio_net *dev;if (vsocket ==NULL )return ;
@@ -236,6 +238,13 @@ struct vhost_user {if (vsocket->linearbuf)vhost_enable_linearbuf (vid); +if (vsocket->async_copy) { + dev =get_device (vid); + +if (dev) + dev->async_copy =1 ; + } +VHOST_LOG_CONFIG (INFO ,"new device, handle is %d\n" , vid);if (vsocket->notify_ops->new_connection) {
@@ -881,6 +890,17 @@ struct rte_vdpa_device * goto out_mutex; } + vsocket->async_copy = flags &RTE_VHOST_USER_ASYNC_COPY ; + +if (vsocket->async_copy && + (flags & (RTE_VHOST_USER_IOMMU_SUPPORT | +RTE_VHOST_USER_POSTCOPY_SUPPORT ))) { +VHOST_LOG_CONFIG (ERR ,"error: enabling async copy and IOMMU " +"or post-copy feature simultaneously is not " +"supported\n" ); + goto out_mutex; + } +/* * Set the supported features correctly for the builtin vhost-user * net driver.
lib/librte_vhost/vhost.c +126 -1
137 lines not on this page · raw message
lib/librte_vhost/vhost.h +29 -1
@@ -24,6 +24,8 @@#include "rte_vdpa.h" #include "rte_vdpa_dev.h" +#include "rte_vhost_async.h" +/* Used to indicate that the device is running on a data core */ #define VIRTIO_DEV_RUNNING 1/* Used to indicate that the device is ready to operate */
@@ -40,6 +42,11 @@#define VHOST_LOG_CACHE_NR 32 +#define MAX_PKT_BURST 32 + +#define VHOST_MAX_ASYNC_IT (MAX_PKT_BURST * 2) +#define VHOST_MAX_ASYNC_VEC (BUF_VECTOR_MAX * 2) +#define PACKED_DESC_ENQUEUE_USED_FLAG (w) \ ((w) ? (VRING_DESC_F_AVAIL | VRING_DESC_F_USED | VRING_DESC_F_WRITE) : \ VRING_DESC_F_WRITE)
@@ -202,6 +209,25 @@ struct vhost_virtqueue { TAILQ_HEAD(, vhost_iotlb_entry) iotlb_list;int iotlb_cache_nr; TAILQ_HEAD(, vhost_iotlb_entry) iotlb_pending_list; + +/* operation callbacks for async dma */ +struct rte_vhost_async_channel_ops async_ops; + +struct rte_vhost_iov_iter it_pool[VHOST_MAX_ASYNC_IT ]; +struct iovec vec_pool[VHOST_MAX_ASYNC_VEC ]; + +/* async data transfer status */ +uintptr_t **async_pkts_pending; +#define ASYNC_PENDING_INFO_N_MSK 0xFFFF +#define ASYNC_PENDING_INFO_N_SFT 16 +uint64_t *async_pending_info; +uint16_t async_pkts_idx; +uint16_t async_pkts_inflight_n; + +/* vq async features */ +bool async_inorder; +bool async_registered; +uint16_t async_threshold; } __rte_cache_aligned;#define VHOST_MAX_VRING 0x100
@@ -338,6 +364,7 @@ struct virtio_net {int16_t broadcast_rarp;uint32_t nr_vring;int dequeue_zero_copy; +int async_copy;int extbuf;int linearbuf;struct vhost_virtqueue *virtqueue[VHOST_MAX_QUEUE_PAIRS *2 ];
@@ -683,7 +710,8 @@ uint64_t translate_log_addr(struct virtio_net *dev, struct vhost_virtqueue *vq,/* Don't kick guest if we don't reach index specified by guest. */ if (dev->features & (1ULL <<VIRTIO_RING_F_EVENT_IDX )) {uint16_t old = vq->signalled_used; -uint16_t new = vq->last_used_idx; +uint16_t new = vq->async_pkts_inflight_n ? + vq->used->idx:vq->last_used_idx;bool signalled_used_valid = vq->signalled_used_valid; vq->signalled_used = new;
lib/librte_vhost/vhost_user.c +20 -3
@@ -476,12 +476,14 @@ }else {if (vq->shadow_used_split)rte_free (vq->shadow_used_split); + vq->shadow_used_split =rte_malloc (NULL , vq->size *sizeof (struct vring_used_elem ),RTE_CACHE_LINE_SIZE ); +if (!vq->shadow_used_split) {VHOST_LOG_CONFIG (ERR , -"failed to allocate memory for shadow used ring.\n" ); +"failed to allocate memory for vq internal data.\n" );return RTE_VHOST_MSG_RESULT_ERR ; } }
@@ -1166,7 +1168,8 @@ goto err_mmap; } - populate = (dev->dequeue_zero_copy) ?MAP_POPULATE :0 ; + populate = (dev->dequeue_zero_copy || dev->async_copy) ? +MAP_POPULATE :0 ; mmap_addr =mmap (NULL , mmap_size,PROT_READ |PROT_WRITE ,MAP_SHARED | populate, fd,0 );
@@ -1181,7 +1184,7 @@ reg->host_user_addr = (uint64_t )(uintptr_t )mmap_addr + mmap_offset; -if (dev->dequeue_zero_copy) +if (dev->dequeue_zero_copy || dev->async_copy)if (add_guest_pages (dev, reg, alignment) <0 ) { VHOST_LOG_CONFIG(ERR, "adding guest pages to region %u failed.\n",
@@ -1979,6 +1982,12 @@ static int vhost_user_set_vring_err(struct virtio_net **pdev __rte_unused, }else {rte_free (vq->shadow_used_split); vq->shadow_used_split =NULL ; +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + vq->async_pkts_pending =NULL ; + vq->async_pending_info =NULL ; }rte_free (vq->batch_copy_elems);
@@ -2012,6 +2021,14 @@ static int vhost_user_set_vring_err(struct virtio_net **pdev __rte_unused,"set queue enable: %d to qp idx: %d\n" , enable, index); +if (!enable && dev->virtqueue[index]->async_registered) { +if (dev->virtqueue[index]->async_pkts_inflight_n) { +VHOST_LOG_CONFIG (ERR ,"failed to disable vring. " +"async inflight packets must be completed first\n" ); +return RTE_VHOST_MSG_RESULT_ERR ; + } + } +/* On disable, rings have to be stopped being processed. */ if (!enable && dev->dequeue_zero_copy)drain_zmbuf_list (dev->virtqueue[index]);
Signature · 1 line
1.8.3.1
Re: [dpdk-dev] [PATCH v4 1/2] vhost: introduce async enqueue registration API
Hi Patrick,
Few comments are inline, others are fine to me.
Regards,
Marvin
Quoted 5 lines
lib/librte_vhost/vhost.c +0
-0
lib/librte_vhost/vhost.c line 340
Quoted 10 lines
lib/librte_vhost/vhost.c +5
-1@@ -332,8 +332,13 @@ {if (vq_is_packed (dev))rte_free (vq->shadow_used_packed); -else +else {rte_free (vq->shadow_used_split); +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info);
Missed pointer set and feature set to 0.
Quoted 29 lines
lib/librte_vhost/vhost.c +22
-0+int rte_vhost_async_channel_unregister (int vid,uint16_t queue_id) +{ +struct vhost_virtqueue *vq; +struct virtio_net *dev =get_device (vid); +int ret =-1 ; + +if (dev ==NULL ) +return ret; + + vq = dev->virtqueue[queue_id]; + +if (vq ==NULL ) +return ret; + + ret =0 ; +rte_spinlock_lock (&vq->access_lock); + +if (!vq->async_registered) + goto out; + +if (vq->async_pkts_inflight_n) { + VHOST_LOG_CONFIG(ERR, "Failed to unregister asyncchannel. "
lib/librte_vhost/vhost.c +1
-0+ "async inflight packets must be completed beforeunregistration.\n");
lib/librte_vhost/vhost.c +4
-0+ ret =-1 ; + goto out; + } +
lib/librte_vhost/vhost.c int rte_vhost_extern_callback_register(int vid, · line 1639
Quoted 10 lines
lib/librte_vhost/vhost.c +10
-0+if (vq->async_pkts_pending) { +rte_free (vq->async_pkts_pending); + vq->async_pkts_pending =0 ; + } + +if (vq->async_pending_info) { +rte_free (vq->async_pending_info); + vq->async_pending_info =0 ; + } +
Please unify the async pending pointer check and free logic and pointer should be set to NULL.
Quoted 10 lines
lib/librte_vhost/vhost.c +10
-0+ vq->async_ops.transfer_data =NULL ; + vq->async_ops.check_completed_copies =NULL ; + vq->async_registered = false; + +out: +rte_spinlock_unlock (&vq->access_lock); + +return ret; +} +
Re: [dpdk-dev] [PATCH v4 1/2] vhost: introduce async enqueue registration API
Hi,
Quoted 27 lines
-----Original Message-----
From: Liu, Yong <[email protected]>
Sent: Monday, July 6, 2020 11:06 AM
To: Fu, Patrick <[email protected]>; [email protected]; [email protected]; Xia, Chenbo <[email protected]>; Wang, Zhihong <[email protected]>
Cc: Fu, Patrick <[email protected]>; Wang, Yinan <[email protected]>; Jiang, Cheng1 <[email protected]>; Liang, Cunming <[email protected]>
Subject: RE: [dpdk-dev] [PATCH v4 1/2] vhost: introduce async enqueue registration APIHi Patrick,
Few comments are inline, others are fine to me.Regards,
MarvinQuoted 9 lines
lib/librte_vhost/vhost.c index renamed from lib/librte_vhost/vhost.c +0
-00d822d6..58ee3ef 100644
lib/librte_vhost/vhost.c +0
-1@@ -332,8 +332,13 @@ {if (vq_is_packed (dev))rte_free (vq->shadow_used_packed); -else
Quoted 9 lines
lib/librte_vhost/vhost.c line 340
Quoted 6 lines
lib/librte_vhost/vhost.c +5
-0+else {rte_free (vq->shadow_used_split); +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info);Missed pointer set and feature set to 0.
This memory free statement is part of vq free operation, which should be safe to leave the vq member pointer just as is
Quoted 5 lines
Quoted 5 lines
lib/librte_vhost/vhost.c +5
-0+if (vq->async_pkts_pending) { +rte_free (vq->async_pkts_pending); + vq->async_pkts_pending =0 ; + } +
Quoted 9 lines
lib/librte_vhost/vhost.c int rte_vhost_extern_callback_register(int vid, · line 1639
Quoted 5 lines
lib/librte_vhost/vhost.c +5
-0+if (vq->async_pending_info) { +rte_free (vq->async_pending_info); + vq->async_pending_info =0 ; + } +Please unify the async pending pointer check and free logic and pointer should be set to NULL.
Will change it in the next patch version
Thanks,
Patrick
PATCH v4 2/2 vhost: introduce async enqueue for split ring
In reply to [email protected]From: Patrick Fu <[email protected]>
This patch implements async enqueue data path for split ring. 2 new async data path APIs are defined, by which applications can submit and poll packets to/from async engines. The async enqueue data leverages callback functions registered by applications to work with the async engine.
--- lib/librte_vhost/rte_vhost_async.h | 40 +++ lib/librte_vhost/virtio_net.c | 554 ++++++++++++++++++++++++++++++++++++- 2 files changed, 592 insertions(+), 2 deletions(-)
lib/librte_vhost/rte_vhost_async.h +40 -0
@@ -133,4 +133,44 @@ int rte_vhost_async_channel_register(int vid, uint16_t queue_id,__rte_experimental int rte_vhost_async_channel_unregister(int vid, uint16_t queue_id); +/** +* This function submit enqueue data to async engine. This function has +* no guranttee to the transfer completion upon return. Applications +* should poll transfer status by rte_vhost_poll_enqueue_completed() +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data +* @param pkts +* array of packets to be enqueued +* @param count +* packets num to be enqueued +* @return +* num of packets enqueued +*/ +__rte_experimental +uint16_t rte_vhost_submit_enqueue_burst(int vid, uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); + +/** +* This function check async completion status for a specific vhost +* device queue. Packets which finish copying (enqueue) operation +* will be returned in an array. +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data +* @param pkts +* blank array to get return packet pointer +* @param count +* size of the packet array +* @return +* num of packets returned +*/ +__rte_experimental +uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); +#endif /* _RTE_VHOST_ASYNC_H_ */
lib/librte_vhost/virtio_net.c +552 -2
584 lines not on this page · raw message
Signature · 1 line
1.8.3.1
v5 cover introduce asynchronous data path for vhost
In reply to [email protected]From: Patrick Fu <[email protected]>
Performing large memory copies usually takes up a major part of CPU cycles and becomes the hot spot in vhost-user enqueue operation. To offload expensive memory operations from the CPU, this patch set proposes to leverage DMA engines, e.g., I/OAT, a DMA engine in the Intel's processor, to accelerate large copies.
Large copies are offloaded from the CPU to the DMA in an asynchronous manner. The CPU just submits copy jobs to the DMA but without waiting for its copy completion. Thus, there is no CPU intervention during data transfer; we can save precious CPU cycles and improve the overall throughput for vhost-user based applications, like OVS. During packet transmission, it offloads large copies to the DMA and performs small copies by the CPU, due to startup overheads associated with the DMA.
This patch set construct a general framework that applications can leverage to attach DMA channels with vhost-user transmit queues. Four new RTE APIs are introduced to vhost library for applications to register and use the asynchronous data path. In addition, two new DMA operation callbacks are defined, by which vhost-user asynchronous data path can interact with DMA hardware. Currently only enqueue operation for split queue is implemented, but the framework is flexible to extend support for packed queue.
v2:
update meson file for new header file
update rte_vhost_version.map to include new APIs rename async APIs/structures to be prefixed with "rte_vhost" rename some variables/structures for readibility correct minor typo in comments/license statements refine memory allocation logic for vq internal buffer add error message printing in some failure cases check inflight async packets in unregistration API call mark new APIs as experimental
v3:
use atomic_xxx() functions in updating ring index
fix a bug in async enqueue failure handling
v4:
part of the fix intended in v3 patch was missed, this patch adds all thoes fixes
v5:
minor changes on some function/variable names reset CPU batch copy packet count when async enqueue error occurs
disable virtio log feature in async copy mode minor optimization on async shadow index flush
Patrick Fu (2):
vhost: introduce async enqueue registration API
vhost: introduce async enqueue for split ring
lib/librte_vhost/Makefile | 2 +- lib/librte_vhost/meson.build | 2 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 176 ++++++++ lib/librte_vhost/rte_vhost_version.map | 4 + lib/librte_vhost/socket.c | 27 ++ lib/librte_vhost/vhost.c | 127 +++++- lib/librte_vhost/vhost.h | 30 +- lib/librte_vhost/vhost_user.c | 23 +- lib/librte_vhost/virtio_net.c | 551 ++++++++++++++++++++++++- 10 files changed, 934 insertions(+), 9 deletions(-) create mode 100644 lib/librte_vhost/rte_vhost_async.h
Signature · 1 line
2.18.4
PATCH v5 1/2 vhost: introduce async enqueue registration API
From: Patrick Fu <[email protected]>
This patch introduces registration/un-registration APIs for vhost async data enqueue operation. Together with the registration APIs implementations, data structures and async callback functions required for async enqueue data path are also defined.
--- lib/librte_vhost/Makefile | 2 +- lib/librte_vhost/meson.build | 2 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 136 +++++++++++++++++++++++++ lib/librte_vhost/rte_vhost_version.map | 4 + lib/librte_vhost/socket.c | 27 +++++ lib/librte_vhost/vhost.c | 127 ++++++++++++++++++++++- lib/librte_vhost/vhost.h | 30 +++++- lib/librte_vhost/vhost_user.c | 23 ++++- 9 files changed, 345 insertions(+), 7 deletions(-) create mode 100644 lib/librte_vhost/rte_vhost_async.h
lib/librte_vhost/Makefile +1 -1
@@ -42,7 +42,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c iotlb.c socket.c vhost.c \ # install includes SYMLINK-$(CONFIG_RTE_LIBRTE_VHOST)-include += rte_vhost.h rte_vdpa.h \ - rte_vdpa_dev.h + rte_vdpa_dev.h rte_vhost_async.h # only compile vhost crypto when cryptodev is enabled ifeq ($(CONFIG_RTE_LIBRTE_CRYPTODEV),y)
lib/librte_vhost/meson.build +1 -1
@@ -22,5 +22,5 @@ sources = files('fd_man.c', 'iotlb.c', 'socket.c', 'vdpa.c', 'vhost.c', 'vhost_user.c', 'virtio_net.c', 'vhost_crypto.c') headers = files('rte_vhost.h', 'rte_vdpa.h', 'rte_vdpa_dev.h', - 'rte_vhost_crypto.h') + 'rte_vhost_crypto.h', 'rte_vhost_async.h') deps += ['ethdev', 'cryptodev', 'hash', 'pci']
lib/librte_vhost/rte_vhost.h +1 -0
@@ -35,6 +35,7 @@ extern "C" {#define RTE_VHOST_USER_EXTBUF_SUPPORT (1ULL << 5)/* support only linear buffers (no chained mbufs) */ #define RTE_VHOST_USER_LINEARBUF_SUPPORT (1ULL << 6) +#define RTE_VHOST_USER_ASYNC_COPY (1ULL << 7)/* Features. */ #ifndef VIRTIO_NET_F_GUEST_ANNOUNCE
lib/librte_vhost/rte_vhost_async.h new file +136 -0
136 lines not on this page · raw message
lib/librte_vhost/rte_vhost_version.map +4 -0
@@ -71,4 +71,8 @@ EXPERIMENTAL { rte_vdpa_get_queue_num; rte_vdpa_get_features; rte_vdpa_get_protocol_features; + rte_vhost_async_channel_register; + rte_vhost_async_channel_unregister; + rte_vhost_submit_enqueue_burst; + rte_vhost_poll_enqueue_completed; };
lib/librte_vhost/socket.c +27 -0
@@ -42,6 +42,7 @@ struct vhost_user_socket {bool use_builtin_virtio_net;bool extbuf;bool linearbuf; +bool async_copy;/* * The "supported_features" indicates the feature bits the
@@ -205,6 +206,7 @@ vhost_user_add_connection(int fd, struct vhost_user_socket *vsocket)size_t size;struct vhost_user_connection *conn;int ret; +struct virtio_net *dev;if (vsocket ==NULL )return ;
@@ -236,6 +238,13 @@ vhost_user_add_connection(int fd, struct vhost_user_socket *vsocket)if (vsocket->linearbuf)vhost_enable_linearbuf (vid); +if (vsocket->async_copy) { + dev =get_device (vid); + +if (dev) + dev->async_copy =1 ; + } +VHOST_LOG_CONFIG (INFO ,"new device, handle is %d\n" , vid);if (vsocket->notify_ops->new_connection) {
@@ -881,6 +890,17 @@ rte_vhost_driver_register(const char *path, uint64_t flags) goto out_mutex; } + vsocket->async_copy = flags &RTE_VHOST_USER_ASYNC_COPY ; + +if (vsocket->async_copy && + (flags & (RTE_VHOST_USER_IOMMU_SUPPORT | +RTE_VHOST_USER_POSTCOPY_SUPPORT ))) { +VHOST_LOG_CONFIG (ERR ,"error: enabling async copy and IOMMU " +"or post-copy feature simultaneously is not " +"supported\n" ); + goto out_mutex; + } +/* * Set the supported features correctly for the builtin vhost-user * net driver.
@@ -931,6 +951,13 @@ rte_vhost_driver_register(const char *path, uint64_t flags) ~(1ULL <<VHOST_USER_PROTOCOL_F_PAGEFAULT ); } +if (vsocket->async_copy) { + vsocket->supported_features &= ~(1ULL <<VHOST_F_LOG_ALL ); + vsocket->features &= ~(1ULL <<VHOST_F_LOG_ALL ); +VHOST_LOG_CONFIG (INFO , +"Logging feature is disabled in async copy mode\n" ); + } +/* * We'll not be able to receive a buffer from guest in linear mode * without external buffer if it will not fit in a single mbuf, which is
lib/librte_vhost/vhost.c +126 -1
137 lines not on this page · raw message
lib/librte_vhost/vhost.h +29 -1
@@ -24,6 +24,8 @@#include "rte_vdpa.h" #include "rte_vdpa_dev.h" +#include "rte_vhost_async.h" +/* Used to indicate that the device is running on a data core */ #define VIRTIO_DEV_RUNNING 1/* Used to indicate that the device is ready to operate */
@@ -40,6 +42,11 @@#define VHOST_LOG_CACHE_NR 32 +#define MAX_PKT_BURST 32 + +#define VHOST_MAX_ASYNC_IT (MAX_PKT_BURST * 2) +#define VHOST_MAX_ASYNC_VEC (BUF_VECTOR_MAX * 2) +#define PACKED_DESC_ENQUEUE_USED_FLAG (w) \ ((w) ? (VRING_DESC_F_AVAIL | VRING_DESC_F_USED | VRING_DESC_F_WRITE) : \ VRING_DESC_F_WRITE)
@@ -202,6 +209,25 @@ struct vhost_virtqueue { TAILQ_HEAD(, vhost_iotlb_entry) iotlb_list;int iotlb_cache_nr; TAILQ_HEAD(, vhost_iotlb_entry) iotlb_pending_list; + +/* operation callbacks for async dma */ +struct rte_vhost_async_channel_ops async_ops; + +struct rte_vhost_iov_iter it_pool[VHOST_MAX_ASYNC_IT ]; +struct iovec vec_pool[VHOST_MAX_ASYNC_VEC ]; + +/* async data transfer status */ +uintptr_t **async_pkts_pending; +#define ASYNC_PENDING_INFO_N_MSK 0xFFFF +#define ASYNC_PENDING_INFO_N_SFT 16 +uint64_t *async_pending_info; +uint16_t async_pkts_idx; +uint16_t async_pkts_inflight_n; + +/* vq async features */ +bool async_inorder; +bool async_registered; +uint16_t async_threshold; } __rte_cache_aligned;#define VHOST_MAX_VRING 0x100
@@ -338,6 +364,7 @@ struct virtio_net {int16_t broadcast_rarp;uint32_t nr_vring;int dequeue_zero_copy; +int async_copy;int extbuf;int linearbuf;struct vhost_virtqueue *virtqueue[VHOST_MAX_QUEUE_PAIRS *2 ];
@@ -683,7 +710,8 @@ vhost_vring_call_split(struct virtio_net *dev, struct vhost_virtqueue *vq)/* Don't kick guest if we don't reach index specified by guest. */ if (dev->features & (1ULL <<VIRTIO_RING_F_EVENT_IDX )) {uint16_t old = vq->signalled_used; -uint16_t new = vq->last_used_idx; +uint16_t new = vq->async_pkts_inflight_n ? + vq->used->idx:vq->last_used_idx;bool signalled_used_valid = vq->signalled_used_valid; vq->signalled_used = new;
lib/librte_vhost/vhost_user.c +20 -3
@@ -476,12 +476,14 @@ vhost_user_set_vring_num(struct virtio_net **pdev, }else {if (vq->shadow_used_split)rte_free (vq->shadow_used_split); + vq->shadow_used_split =rte_malloc (NULL , vq->size *sizeof (struct vring_used_elem ),RTE_CACHE_LINE_SIZE ); +if (!vq->shadow_used_split) {VHOST_LOG_CONFIG (ERR , -"failed to allocate memory for shadow used ring.\n" ); +"failed to allocate memory for vq internal data.\n" );return RTE_VHOST_MSG_RESULT_ERR ; } }
@@ -1166,7 +1168,8 @@ vhost_user_set_mem_table(struct virtio_net **pdev, struct VhostUserMsg *msg, goto err_mmap; } - populate = (dev->dequeue_zero_copy) ?MAP_POPULATE :0 ; + populate = (dev->dequeue_zero_copy || dev->async_copy) ? +MAP_POPULATE :0 ; mmap_addr =mmap (NULL , mmap_size,PROT_READ |PROT_WRITE ,MAP_SHARED | populate, fd,0 );
@@ -1181,7 +1184,7 @@ vhost_user_set_mem_table(struct virtio_net **pdev, struct VhostUserMsg *msg, reg->host_user_addr = (uint64_t )(uintptr_t )mmap_addr + mmap_offset; -if (dev->dequeue_zero_copy) +if (dev->dequeue_zero_copy || dev->async_copy)if (add_guest_pages (dev, reg, alignment) <0 ) { VHOST_LOG_CONFIG(ERR, "adding guest pages to region %u failed.\n",
@@ -1979,6 +1982,12 @@ vhost_user_get_vring_base(struct virtio_net **pdev, }else {rte_free (vq->shadow_used_split); vq->shadow_used_split =NULL ; +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + vq->async_pkts_pending =NULL ; + vq->async_pending_info =NULL ; }rte_free (vq->batch_copy_elems);
@@ -2012,6 +2021,14 @@ vhost_user_set_vring_enable(struct virtio_net **pdev,"set queue enable: %d to qp idx: %d\n" , enable, index); +if (!enable && dev->virtqueue[index]->async_registered) { +if (dev->virtqueue[index]->async_pkts_inflight_n) { +VHOST_LOG_CONFIG (ERR ,"failed to disable vring. " +"async inflight packets must be completed first\n" ); +return RTE_VHOST_MSG_RESULT_ERR ; + } + } +/* On disable, rings have to be stopped being processed. */ if (!enable && dev->dequeue_zero_copy)drain_zmbuf_list (dev->virtqueue[index]);
Signature · 1 line
2.18.4
PATCH v5 2/2 vhost: introduce async enqueue for split ring
In reply to [email protected]From: Patrick Fu <[email protected]>
This patch implements async enqueue data path for split ring. 2 new async data path APIs are defined, by which applications can submit and poll packets to/from async engines. The async enqueue data leverages callback functions registered by applications to work with the async engine.
--- lib/librte_vhost/rte_vhost_async.h | 40 +++ lib/librte_vhost/virtio_net.c | 551 ++++++++++++++++++++++++++++- 2 files changed, 589 insertions(+), 2 deletions(-)
lib/librte_vhost/rte_vhost_async.h +40 -0
@@ -133,4 +133,44 @@ int rte_vhost_async_channel_register(int vid, uint16_t queue_id,__rte_experimental int rte_vhost_async_channel_unregister(int vid, uint16_t queue_id); +/** +* This function submit enqueue data to async engine. This function has +* no guranttee to the transfer completion upon return. Applications +* should poll transfer status by rte_vhost_poll_enqueue_completed() +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data +* @param pkts +* array of packets to be enqueued +* @param count +* packets num to be enqueued +* @return +* num of packets enqueued +*/ +__rte_experimental +uint16_t rte_vhost_submit_enqueue_burst(int vid, uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); + +/** +* This function check async completion status for a specific vhost +* device queue. Packets which finish copying (enqueue) operation +* will be returned in an array. +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data +* @param pkts +* blank array to get return packet pointer +* @param count +* size of the packet array +* @return +* num of packets returned +*/ +__rte_experimental +uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); +#endif /* _RTE_VHOST_ASYNC_H_ */
lib/librte_vhost/virtio_net.c +549 -2
581 lines not on this page · raw message
Signature · 1 line
2.18.4
v6 cover introduce asynchronous data path for vhost
In reply to [email protected]From: Patrick Fu <[email protected]>
Performing large memory copies usually takes up a major part of CPU cycles and becomes the hot spot in vhost-user enqueue operation. To offload expensive memory operations from the CPU, this patch set proposes to leverage DMA engines, e.g., I/OAT, a DMA engine in the Intel's processor, to accelerate large copies.
Large copies are offloaded from the CPU to the DMA in an asynchronous manner. The CPU just submits copy jobs to the DMA but without waiting for its copy completion. Thus, there is no CPU intervention during data transfer; we can save precious CPU cycles and improve the overall throughput for vhost-user based applications, like OVS. During packet transmission, it offloads large copies to the DMA and performs small copies by the CPU, due to startup overheads associated with the DMA.
This patch set construct a general framework that applications can leverage to attach DMA channels with vhost-user transmit queues. Four new RTE APIs are introduced to vhost library for applications to register and use the asynchronous data path. In addition, two new DMA operation callbacks are defined, by which vhost-user asynchronous data path can interact with DMA hardware. Currently only enqueue operation for split queue is implemented, but the framework is flexible to extend support for packed queue.
v2:
update meson file for new header file
update rte_vhost_version.map to include new APIs rename async APIs/structures to be prefixed with "rte_vhost" rename some variables/structures for readibility correct minor typo in comments/license statements refine memory allocation logic for vq internal buffer add error message printing in some failure cases check inflight async packets in unregistration API call mark new APIs as experimental
v3:
use atomic_xxx() functions in updating ring index
fix a bug in async enqueue failure handling
v4:
part of the fix intended in v3 patch was missed, this patch adds all thoes fixes
v5:
minor changes on some function/variable names reset CPU batch copy packet count when async enqueue error occurs
disable virtio log feature in async copy mode minor optimization on async shadow index flush
v6:
add some background introduction in the commit message
Patrick Fu (2):
vhost: introduce async enqueue registration API
vhost: introduce async enqueue for split ring
lib/librte_vhost/Makefile | 2 +- lib/librte_vhost/meson.build | 2 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 176 ++++++++ lib/librte_vhost/rte_vhost_version.map | 4 + lib/librte_vhost/socket.c | 27 ++ lib/librte_vhost/vhost.c | 127 +++++- lib/librte_vhost/vhost.h | 30 +- lib/librte_vhost/vhost_user.c | 23 +- lib/librte_vhost/virtio_net.c | 551 ++++++++++++++++++++++++- 10 files changed, 934 insertions(+), 9 deletions(-) create mode 100644 lib/librte_vhost/rte_vhost_async.h
Signature · 1 line
2.18.4
PATCH v6 1/2 vhost: introduce async enqueue registration API
From: Patrick Fu <[email protected]>
Performing large memory copies usually takes up a major part of CPU cycles and becomes the hot spot in vhost-user enqueue operation. To offload the large copies from CPU to the DMA devices, asynchronous APIs are introduced, with which the CPU just submits copy jobs to the DMA but without waiting for its copy completion. Thus, there is no CPU intervention during data transfer. We can save precious CPU cycles and improve the overall throughput for vhost-user based applications. This patch introduces registration/un-registration APIs for vhost async data enqueue operation. Together with the registration APIs implementations, data structures and the prototype of the async callback functions required for async enqueue data path are also defined.
--- lib/librte_vhost/Makefile | 2 +- lib/librte_vhost/meson.build | 2 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 136 +++++++++++++++++++++++++ lib/librte_vhost/rte_vhost_version.map | 4 + lib/librte_vhost/socket.c | 27 +++++ lib/librte_vhost/vhost.c | 127 ++++++++++++++++++++++- lib/librte_vhost/vhost.h | 30 +++++- lib/librte_vhost/vhost_user.c | 23 ++++- 9 files changed, 345 insertions(+), 7 deletions(-) create mode 100644 lib/librte_vhost/rte_vhost_async.h
lib/librte_vhost/Makefile +1 -1
@@ -42,7 +42,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c iotlb.c socket.c vhost.c \ # install includes SYMLINK-$(CONFIG_RTE_LIBRTE_VHOST)-include += rte_vhost.h rte_vdpa.h \ - rte_vdpa_dev.h + rte_vdpa_dev.h rte_vhost_async.h # only compile vhost crypto when cryptodev is enabled ifeq ($(CONFIG_RTE_LIBRTE_CRYPTODEV),y)
lib/librte_vhost/meson.build +1 -1
@@ -22,5 +22,5 @@ sources = files('fd_man.c', 'iotlb.c', 'socket.c', 'vdpa.c', 'vhost.c', 'vhost_user.c', 'virtio_net.c', 'vhost_crypto.c') headers = files('rte_vhost.h', 'rte_vdpa.h', 'rte_vdpa_dev.h', - 'rte_vhost_crypto.h') + 'rte_vhost_crypto.h', 'rte_vhost_async.h') deps += ['ethdev', 'cryptodev', 'hash', 'pci']
lib/librte_vhost/rte_vhost.h +1 -0
@@ -35,6 +35,7 @@ extern "C" {#define RTE_VHOST_USER_EXTBUF_SUPPORT (1ULL << 5)/* support only linear buffers (no chained mbufs) */ #define RTE_VHOST_USER_LINEARBUF_SUPPORT (1ULL << 6) +#define RTE_VHOST_USER_ASYNC_COPY (1ULL << 7)/* Features. */ #ifndef VIRTIO_NET_F_GUEST_ANNOUNCE
lib/librte_vhost/rte_vhost_async.h new file +136 -0
136 lines not on this page · raw message
lib/librte_vhost/rte_vhost_version.map +4 -0
@@ -71,4 +71,8 @@ EXPERIMENTAL { rte_vdpa_get_queue_num; rte_vdpa_get_features; rte_vdpa_get_protocol_features; + rte_vhost_async_channel_register; + rte_vhost_async_channel_unregister; + rte_vhost_submit_enqueue_burst; + rte_vhost_poll_enqueue_completed; };
lib/librte_vhost/socket.c +27 -0
@@ -42,6 +42,7 @@ struct vhost_user_socket {bool use_builtin_virtio_net;bool extbuf;bool linearbuf; +bool async_copy;/* * The "supported_features" indicates the feature bits the
@@ -205,6 +206,7 @@ vhost_user_add_connection(int fd, struct vhost_user_socket *vsocket)size_t size;struct vhost_user_connection *conn;int ret; +struct virtio_net *dev;if (vsocket ==NULL )return ;
@@ -236,6 +238,13 @@ vhost_user_add_connection(int fd, struct vhost_user_socket *vsocket)if (vsocket->linearbuf)vhost_enable_linearbuf (vid); +if (vsocket->async_copy) { + dev =get_device (vid); + +if (dev) + dev->async_copy =1 ; + } +VHOST_LOG_CONFIG (INFO ,"new device, handle is %d\n" , vid);if (vsocket->notify_ops->new_connection) {
@@ -881,6 +890,17 @@ rte_vhost_driver_register(const char *path, uint64_t flags) goto out_mutex; } + vsocket->async_copy = flags &RTE_VHOST_USER_ASYNC_COPY ; + +if (vsocket->async_copy && + (flags & (RTE_VHOST_USER_IOMMU_SUPPORT | +RTE_VHOST_USER_POSTCOPY_SUPPORT ))) { +VHOST_LOG_CONFIG (ERR ,"error: enabling async copy and IOMMU " +"or post-copy feature simultaneously is not " +"supported\n" ); + goto out_mutex; + } +/* * Set the supported features correctly for the builtin vhost-user * net driver.
@@ -931,6 +951,13 @@ rte_vhost_driver_register(const char *path, uint64_t flags) ~(1ULL <<VHOST_USER_PROTOCOL_F_PAGEFAULT ); } +if (vsocket->async_copy) { + vsocket->supported_features &= ~(1ULL <<VHOST_F_LOG_ALL ); + vsocket->features &= ~(1ULL <<VHOST_F_LOG_ALL ); +VHOST_LOG_CONFIG (INFO , +"Logging feature is disabled in async copy mode\n" ); + } +/* * We'll not be able to receive a buffer from guest in linear mode * without external buffer if it will not fit in a single mbuf, which is
lib/librte_vhost/vhost.c +126 -1
137 lines not on this page · raw message
lib/librte_vhost/vhost.h +29 -1
@@ -24,6 +24,8 @@#include "rte_vdpa.h" #include "rte_vdpa_dev.h" +#include "rte_vhost_async.h" +/* Used to indicate that the device is running on a data core */ #define VIRTIO_DEV_RUNNING 1/* Used to indicate that the device is ready to operate */
@@ -40,6 +42,11 @@#define VHOST_LOG_CACHE_NR 32 +#define MAX_PKT_BURST 32 + +#define VHOST_MAX_ASYNC_IT (MAX_PKT_BURST * 2) +#define VHOST_MAX_ASYNC_VEC (BUF_VECTOR_MAX * 2) +#define PACKED_DESC_ENQUEUE_USED_FLAG (w) \ ((w) ? (VRING_DESC_F_AVAIL | VRING_DESC_F_USED | VRING_DESC_F_WRITE) : \ VRING_DESC_F_WRITE)
@@ -202,6 +209,25 @@ struct vhost_virtqueue { TAILQ_HEAD(, vhost_iotlb_entry) iotlb_list;int iotlb_cache_nr; TAILQ_HEAD(, vhost_iotlb_entry) iotlb_pending_list; + +/* operation callbacks for async dma */ +struct rte_vhost_async_channel_ops async_ops; + +struct rte_vhost_iov_iter it_pool[VHOST_MAX_ASYNC_IT ]; +struct iovec vec_pool[VHOST_MAX_ASYNC_VEC ]; + +/* async data transfer status */ +uintptr_t **async_pkts_pending; +#define ASYNC_PENDING_INFO_N_MSK 0xFFFF +#define ASYNC_PENDING_INFO_N_SFT 16 +uint64_t *async_pending_info; +uint16_t async_pkts_idx; +uint16_t async_pkts_inflight_n; + +/* vq async features */ +bool async_inorder; +bool async_registered; +uint16_t async_threshold; } __rte_cache_aligned;#define VHOST_MAX_VRING 0x100
@@ -338,6 +364,7 @@ struct virtio_net {int16_t broadcast_rarp;uint32_t nr_vring;int dequeue_zero_copy; +int async_copy;int extbuf;int linearbuf;struct vhost_virtqueue *virtqueue[VHOST_MAX_QUEUE_PAIRS *2 ];
@@ -683,7 +710,8 @@ vhost_vring_call_split(struct virtio_net *dev, struct vhost_virtqueue *vq)/* Don't kick guest if we don't reach index specified by guest. */ if (dev->features & (1ULL <<VIRTIO_RING_F_EVENT_IDX )) {uint16_t old = vq->signalled_used; -uint16_t new = vq->last_used_idx; +uint16_t new = vq->async_pkts_inflight_n ? + vq->used->idx:vq->last_used_idx;bool signalled_used_valid = vq->signalled_used_valid; vq->signalled_used = new;
lib/librte_vhost/vhost_user.c +20 -3
@@ -476,12 +476,14 @@ vhost_user_set_vring_num(struct virtio_net **pdev, }else {if (vq->shadow_used_split)rte_free (vq->shadow_used_split); + vq->shadow_used_split =rte_malloc (NULL , vq->size *sizeof (struct vring_used_elem ),RTE_CACHE_LINE_SIZE ); +if (!vq->shadow_used_split) {VHOST_LOG_CONFIG (ERR , -"failed to allocate memory for shadow used ring.\n" ); +"failed to allocate memory for vq internal data.\n" );return RTE_VHOST_MSG_RESULT_ERR ; } }
@@ -1166,7 +1168,8 @@ vhost_user_set_mem_table(struct virtio_net **pdev, struct VhostUserMsg *msg, goto err_mmap; } - populate = (dev->dequeue_zero_copy) ?MAP_POPULATE :0 ; + populate = (dev->dequeue_zero_copy || dev->async_copy) ? +MAP_POPULATE :0 ; mmap_addr =mmap (NULL , mmap_size,PROT_READ |PROT_WRITE ,MAP_SHARED | populate, fd,0 );
@@ -1181,7 +1184,7 @@ vhost_user_set_mem_table(struct virtio_net **pdev, struct VhostUserMsg *msg, reg->host_user_addr = (uint64_t )(uintptr_t )mmap_addr + mmap_offset; -if (dev->dequeue_zero_copy) +if (dev->dequeue_zero_copy || dev->async_copy)if (add_guest_pages (dev, reg, alignment) <0 ) { VHOST_LOG_CONFIG(ERR, "adding guest pages to region %u failed.\n",
@@ -1979,6 +1982,12 @@ vhost_user_get_vring_base(struct virtio_net **pdev, }else {rte_free (vq->shadow_used_split); vq->shadow_used_split =NULL ; +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + vq->async_pkts_pending =NULL ; + vq->async_pending_info =NULL ; }rte_free (vq->batch_copy_elems);
@@ -2012,6 +2021,14 @@ vhost_user_set_vring_enable(struct virtio_net **pdev,"set queue enable: %d to qp idx: %d\n" , enable, index); +if (!enable && dev->virtqueue[index]->async_registered) { +if (dev->virtqueue[index]->async_pkts_inflight_n) { +VHOST_LOG_CONFIG (ERR ,"failed to disable vring. " +"async inflight packets must be completed first\n" ); +return RTE_VHOST_MSG_RESULT_ERR ; + } + } +/* On disable, rings have to be stopped being processed. */ if (!enable && dev->dequeue_zero_copy)drain_zmbuf_list (dev->virtqueue[index]);
Signature · 1 line
2.18.4
Re: [dpdk-dev] [PATCH v6 1/2] vhost: introduce async enqueue registration API
Quoted 592 lines
-----Original Message-----
From: Fu, Patrick <[email protected]>
Sent: Tuesday, July 7, 2020 1:07 PM
To: [email protected]; [email protected]; Xia, Chenbo <[email protected]>; Wang, Zhihong <[email protected]>
Cc: Fu, Patrick <[email protected]>; Wang, Yinan <[email protected]>; Jiang, Cheng1 <[email protected]>; Liang, Cunming <[email protected]>
Subject: [PATCH v6 1/2] vhost: introduce async enqueue registration APIFrom: Patrick Fu <[email protected]>
Performing large memory copies usually takes up a major part of CPU cycles and becomes the hot spot in vhost-user enqueue operation. To offload the large copies from CPU to the DMA devices, asynchronous APIs are introduced, with which the CPU just submits copy jobs to the DMA but without waiting for its copy completion. Thus, there is no CPU intervention during data transfer. We can save precious CPU cycles and improve the overall throughput for vhost-user based applications. This patch introduces registration/un-registration APIs for vhost async data enqueue operation. Together with the registration APIs implementations, data structures and the prototype of the async callback functions required for async enqueue data path are also defined.
Signed-off-by Patrick Fu <[email protected]>--- lib/librte_vhost/Makefile | 2 +- lib/librte_vhost/meson.build | 2 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 136 +++++++++++++++++++++++++ lib/librte_vhost/rte_vhost_version.map | 4 + lib/librte_vhost/socket.c | 27 +++++ lib/librte_vhost/vhost.c | 127 ++++++++++++++++++++++- lib/librte_vhost/vhost.h | 30 +++++- lib/librte_vhost/vhost_user.c | 23 ++++- 9 files changed, 345 insertions(+), 7 deletions(-) create mode 100644
lib/librte_vhost/rte_vhost_async.hlib/librte_vhost/Makefile index renamed from lib/librte_vhost/Makefile +0
-0
b7ff7dc4b..4f2f3e47d100644lib/librte_vhost/Makefile +1
-1@@ -42,7 +42,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_VHOST) := fd_man.c iotlb.c socket.c vhost.c \ # install includes SYMLINK-$(CONFIG_RTE_LIBRTE_VHOST)-include += rte_vhost.h rte_vdpa.h \ - rte_vdpa_dev.h + rte_vdpa_dev.h
rte_vhost_async.h# only compile vhost crypto when cryptodev is enabled ifeq ($(CONFIG_RTE_LIBRTE_CRYPTODEV),y)lib/librte_vhost/meson.build index renamed from lib/librte_vhost/meson.build +0
-0
882a0eaf4..cc9aa65c6100644lib/librte_vhost/meson.build +1
-1@@ -22,5 +22,5 @@ sources = files('fd_man.c', 'iotlb.c', 'socket.c', 'vdpa.c', 'vhost.c', 'vhost_user.c', 'virtio_net.c', 'vhost_crypto.c') headers = files('rte_vhost.h', 'rte_vdpa.h', 'rte_vdpa_dev.h', - 'rte_vhost_crypto.h') + 'rte_vhost_crypto.h', 'rte_vhost_async.h') deps += ['ethdev', 'cryptodev', 'hash', 'pci'] diff --git
a/lib/librte_vhost/rte_vhost.hb/lib/librte_vhost/rte_vhost.hindex8a5c332c8..f93f9595a100644lib/librte_vhost/rte_vhost.h +1
-0@@ -35,6 +35,7 @@ extern "C" {#define RTE_VHOST_USER_EXTBUF_SUPPORT (1ULL << 5)/* support only linear buffers (no chained mbufs) */ #define RTE_VHOST_USER_LINEARBUF_SUPPORT (1ULL << 6) +#define RTE_VHOST_USER_ASYNC_COPY (1ULL << 7)/* Features. */ #ifndef VIRTIO_NET_F_GUEST_ANNOUNCE lib/librte_vhost/rte_vhost_async.h new file +135
-0@@ -0,0 +1,136 @@ +/* SPDX-License-Identifier: BSD-3-Clause +* Copyright(c) 2020 Intel Corporation +*/ + +#ifndef _RTE_VHOST_ASYNC_H_ +#define _RTE_VHOST_ASYNC_H_ + +#include "rte_vhost.h" + +/** +* iovec iterator +*/ +struct rte_vhost_iov_iter { +/** offset to the first byte of interesting data */ +size_t offset; +/** total bytes of data in this iterator */ +size_t count; +/** pointer to the iovec array */ +struct iovec *iov; +/** number of iovec in this iterator */ +unsigned long nr_segs; +}; + +/** +* dma transfer descriptor pair +*/ +struct rte_vhost_async_desc { +/** source memory iov_iter */ +struct rte_vhost_iov_iter *src; +/** destination memory iov_iter */ +struct rte_vhost_iov_iter *dst; +}; + +/** +* dma transfer status +*/ +struct rte_vhost_async_status { +/** An array of application specific data for source memory */ +uintptr_t *src_opaque_data; +/** An array of application specific data for destination memory */ +uintptr_t *dst_opaque_data; +}; + +/** +* dma operation callbacks to be implemented by applications */ struct +rte_vhost_async_channel_ops { +/** +* instruct async engines to perform copies for a batch of packets +* +* @param vid +* id of vhost device to perform data copies +* @param queue_id +* queue id to perform data copies +* @param descs +* an array of DMA transfer memory descriptors +* @param opaque_data +* opaque data pair sending to DMA engine +* @param count +* number of elements in the "descs" array +* @return +* -1 on failure, number of descs processed on success +*/ +int (*transfer_data)(int vid,uint16_t queue_id, +struct rte_vhost_async_desc *descs, +struct rte_vhost_async_status *opaque_data, +uint16_t count); +/** +* check copy-completed packets from the async engine +* @param vid +* id of vhost device to check copy completion +* @param queue_id +* queue id to check copyp completion +* @param opaque_data +* buffer to receive the opaque data pair from DMA engine +* @param max_packets +* max number of packets could be completed +* @return +* -1 on failure, number of iov segments completed on success +*/ +int (*check_completed_copies)(int vid,uint16_t queue_id, +struct rte_vhost_async_status *opaque_data, +uint16_t max_packets); +}; + +/** +* dma channel feature bit definition +*/ +struct rte_vhost_async_features { +union { +uint32_t intval; +struct { +uint32_t async_inorder:1 ; +uint32_t resvd_0:15 ; +uint32_t async_threshold:12 ; +uint32_t resvd_1:4 ; + }; + }; +}; + +/** +* register a async channel for vhost +* +* @param vid +* vhost device id async channel to be attached to +* @param queue_id +* vhost queue id async channel to be attached to +* @param features +* DMA channel feature bit +* b0 : DMA supports inorder data transfer +* b1 - b15: reserved +* b16 - b27: Packet length threshold for DMA transfer +* b28 - b31: reserved +* @param ops +* DMA operation callbacks +* @return +* 0 on success, -1 on failures +*/ +__rte_experimental +int rte_vhost_async_channel_register(int vid, uint16_t queue_id, +uint32_t features,struct rte_vhost_async_channel_ops *ops); + +/** +* unregister a dma channel for vhost +* +* @param vid +* vhost device id DMA channel to be detached +* @param queue_id +* vhost queue id DMA channel to be detached +* @return +* 0 on success, -1 on failures +*/ +__rte_experimental +int rte_vhost_async_channel_unregister(int vid, uint16_t queue_id); + +#endif /* _RTE_VHOST_ASYNC_H_ */ lib/librte_vhost/rte_vhost_version.map +4
-0@@ -71,4 +71,8 @@ EXPERIMENTAL { rte_vdpa_get_queue_num; rte_vdpa_get_features; rte_vdpa_get_protocol_features; + rte_vhost_async_channel_register; + rte_vhost_async_channel_unregister; + rte_vhost_submit_enqueue_burst; + rte_vhost_poll_enqueue_completed; };lib/librte_vhost/socket.c index renamed from lib/librte_vhost/socket.c +0
-0
49267cebf..c4626d2c4100644lib/librte_vhost/socket.c +2
-0@@ -42,6 +42,7 @@ struct vhost_user_socket {bool use_builtin_virtio_net;bool extbuf;bool linearbuf; +bool async_copy;/* * The "supported_features" indicates the feature bits the @@ -205,6 +206,7 @@ vhost_user_add_connection(int fd, struct vhost_user_socket *vsocket)
lib/librte_vhost/socket.c +8
-0size_t size;struct vhost_user_connection *conn;int ret; +struct virtio_net *dev;if (vsocket ==NULL )return ;@@ -236,6 +238,13 @@ vhost_user_add_connection(int fd, struct vhost_user_socket *vsocket)if (vsocket->linearbuf)vhost_enable_linearbuf (vid); +if (vsocket->async_copy) { + dev =get_device (vid); + +if (dev) + dev->async_copy =1 ; + } +VHOST_LOG_CONFIG (INFO ,"new device, handle is %d\n" , vid);if (
vsocket->notify_ops->new_connection) { @@ -881,6 +890,17 @@rte_vhost_driver_register(const char *path, uint64_t flags)lib/librte_vhost/socket.c +6
-0goto out_mutex; } + vsocket->async_copy = flags &RTE_VHOST_USER_ASYNC_COPY ; + +if (vsocket->async_copy && + (flags & (RTE_VHOST_USER_IOMMU_SUPPORT | +RTE_VHOST_USER_POSTCOPY_SUPPORT ))) { + VHOST_LOG_CONFIG(ERR, "error: enabling async copy andIOMMU "
lib/librte_vhost/socket.c +12
-0+"or post-copy feature simultaneously is not " + "supported\n"); + goto out_mutex; + } +/* * Set the supported features correctly for the builtin vhost-user * net driver. @@ -931,6 +951,13 @@ rte_vhost_driver_register(const char *path, uint64_t flags) ~(1ULL <<VHOST_USER_PROTOCOL_F_PAGEFAULT ); } +if (vsocket->async_copy) { + vsocket->supported_features &= ~(1ULL <<VHOST_F_LOG_ALL ); + vsocket->features &= ~(1ULL <<VHOST_F_LOG_ALL ); +VHOST_LOG_CONFIG (INFO , +"Logging feature is disabled in async copy mode\n" ); + } +/* * We'll not be able to receive a buffer from guest in linear mode * without external buffer if it will not fit in a single mbuf, which is diff --
gita/lib/librte_vhost/vhost.cb/lib/librte_vhost/vhost.cindex0d822d6a3..a11385f39100644lib/librte_vhost/vhost.c +10
-1@@ -332,8 +332,13 @@ free_vq(struct virtio_net *dev, struct vhost_virtqueue *vq) {if (vq_is_packed (dev))rte_free (vq->shadow_used_packed); -else +else {rte_free (vq->shadow_used_split); +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + }rte_free (vq->batch_copy_elems);rte_mempool_free (vq->iotlb_pool);rte_free (vq);@@ -1522,3 +1527,123 @@ RTE_INIT(vhost_log_init)if (vhost_data_log_level >=0 )rte_log_set_level (vhost_data_log_level,RTE_LOG_WARNING ); } + +int rte_vhost_async_channel_register (int vid,uint16_t queue_id, +uint32_t features, + struct rte_vhost_async_channel_ops*ops) {
lib/librte_vhost/vhost.c +18
-0+struct vhost_virtqueue *vq; +struct virtio_net *dev =get_device (vid); +struct rte_vhost_async_features f; + +if (dev ==NULL || ops ==NULL ) +return -1 ; + + f.intval = features; + + vq = dev->virtqueue[queue_id]; + +if (unlikely (vq ==NULL || !dev->async_copy)) +return -1 ; + +/* packed queue is not supported */ +if (unlikely (vq_is_packed (dev) || !f.async_inorder)) { + VHOST_LOG_CONFIG(ERR, + "async copy is not supported on packed queue or non-inorder mode "
lib/librte_vhost/vhost.c +32
-0+ "(vid %d, qid: %d)\n", vid, queue_id); +return -1 ; + } + +if (unlikely (ops->check_completed_copies ==NULL || + ops->transfer_data ==NULL )) +return -1 ; + +rte_spinlock_lock (&vq->access_lock); + +if (unlikely (vq->async_registered)) { +VHOST_LOG_CONFIG (ERR , +"async register failed: channel already registered " +"(vid %d, qid: %d)\n" , vid, queue_id); + goto reg_out; + } + + vq->async_pkts_pending =rte_malloc (NULL , + vq->size *sizeof (uintptr_t ), +RTE_CACHE_LINE_SIZE ); + vq->async_pending_info =rte_malloc (NULL , + vq->size *sizeof (uint64_t ), +RTE_CACHE_LINE_SIZE ); +if (!vq->async_pkts_pending || !vq->async_pending_info) { +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); + +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + + VHOST_LOG_CONFIG(ERR, + "async register failed: cannot allocate memoryfor vq data "
lib/librte_vhost/vhost.c +5
-0+ "(vid %d, qid: %d)\n", vid, queue_id); + goto reg_out; + } + + vq->async_ops.check_completed_copies = ops-Quoted 1 line
check_completed_copies;lib/librte_vhost/vhost.c +34
-0+ vq->async_ops.transfer_data = ops->transfer_data; + + vq->async_inorder = f.async_inorder; + vq->async_threshold = f.async_threshold; + + vq->async_registered = true; + +reg_out: +rte_spinlock_unlock (&vq->access_lock); + +return 0 ; +} + +int rte_vhost_async_channel_unregister (int vid,uint16_t queue_id) { +struct vhost_virtqueue *vq; +struct virtio_net *dev =get_device (vid); +int ret =-1 ; + +if (dev ==NULL ) +return ret; + + vq = dev->virtqueue[queue_id]; + +if (vq ==NULL ) +return ret; + + ret =0 ; +rte_spinlock_lock (&vq->access_lock); + +if (!vq->async_registered) + goto out; + +if (vq->async_pkts_inflight_n) { + VHOST_LOG_CONFIG(ERR, "Failed to unregister async channel."
lib/librte_vhost/vhost.c +1
-0+ "async inflight packets must be completed beforeunregistration.\n");
lib/librte_vhost/vhost.c +24
-0+ ret =-1 ; + goto out; + } + +if (vq->async_pkts_pending) { +rte_free (vq->async_pkts_pending); + vq->async_pkts_pending =NULL ; + } + +if (vq->async_pending_info) { +rte_free (vq->async_pending_info); + vq->async_pending_info =NULL ; + } + + vq->async_ops.transfer_data =NULL ; + vq->async_ops.check_completed_copies =NULL ; + vq->async_registered = false; + +out: +rte_spinlock_unlock (&vq->access_lock); + +return ret; +} +lib/librte_vhost/vhost.h index renamed from lib/librte_vhost/vhost.h +0
-0034463699..f3731982b 100644
lib/librte_vhost/vhost.h +2
-0@@ -24,6 +24,8 @@#include "rte_vdpa.h" #include "rte_vdpa_dev.h" +#include "rte_vhost_async.h" + /* Used to indicate that the device is running on a data core */ #define
VIRTIO_DEV_RUNNING1
/* Used to indicate that the device is ready to operate */ @@ -40,6 +42,11 @@#define
VHOST_LOG_CACHE_NR32lib/librte_vhost/vhost.h +5
-0+#define MAX_PKT_BURST 32 + +#define VHOST_MAX_ASYNC_IT (MAX_PKT_BURST * 2) #define +VHOST_MAX_ASYNC_VEC (BUF_VECTOR_MAX * 2) +#define PACKED_DESC_ENQUEUE_USED_FLAG (w) \ ((w) ? (VRING_DESC_F_AVAIL | VRING_DESC_F_USED |
VRING_DESC_F_WRITE) : \lib/librte_vhost/vhost.h +22
-1VRING_DESC_F_WRITE)@@ -202,6 +209,25 @@ struct vhost_virtqueue { TAILQ_HEAD(, vhost_iotlb_entry) iotlb_list;int iotlb_cache_nr; TAILQ_HEAD(, vhost_iotlb_entry) iotlb_pending_list; + +/* operation callbacks for async dma */ +struct rte_vhost_async_channel_ops async_ops; + +struct rte_vhost_iov_iter it_pool[VHOST_MAX_ASYNC_IT ]; +struct iovec vec_pool[VHOST_MAX_ASYNC_VEC ]; + +/* async data transfer status */ +uintptr_t **async_pkts_pending; +#define ASYNC_PENDING_INFO_N_MSK 0xFFFF +#define ASYNC_PENDING_INFO_N_SFT 16 +uint64_t *async_pending_info; +uint16_t async_pkts_idx; +uint16_t async_pkts_inflight_n; + +/* vq async features */ +bool async_inorder; +bool async_registered; +uint16_t async_threshold; } __rte_cache_aligned;#define VHOST_MAX_VRING 0x100@@ -338,6 +364,7 @@ struct virtio_net {int16_t broadcast_rarp;uint32_t nr_vring;int dequeue_zero_copy; +int async_copy;int extbuf;int linearbuf;struct vhost_virtqueue *virtqueue[VHOST_MAX_QUEUE_PAIRS *2 ];@@ -683,7 +710,8 @@ vhost_vring_call_split(struct virtio_net *dev, struct vhost_virtqueue *vq)/* Don't kick guest if we don't reach index specified by guest. */ if (dev->features & (1ULL <<VIRTIO_RING_F_EVENT_IDX )) {uint16_t old = vq->signalled_used; -uint16_t new = vq->last_used_idx; +uint16_t new = vq->async_pkts_inflight_n ? + vq->used->idx:vq->last_used_idx;bool signalled_used_valid = vq->signalled_used_valid;lib/librte_vhost/vhost.h +0
-0vq->signalled_used = new;lib/librte_vhost/vhost_user.c index renamed from lib/librte_vhost/vhost_user.c +0
-0
6039a8fdb..aa8605523100644lib/librte_vhost/vhost_user.c +3
-1@@ -476,12 +476,14 @@ vhost_user_set_vring_num(struct virtio_net **pdev, }else {if (vq->shadow_used_split)rte_free (vq->shadow_used_split); + vq->shadow_used_split =rte_malloc (NULL , vq->size *sizeof (struct vring_used_elem ),RTE_CACHE_LINE_SIZE ); +if (!vq->shadow_used_split) {VHOST_LOG_CONFIG (ERR , - "failed to allocate memory for shadow used ring.\n"); +" failed to allocate memory for vq internal data.\n");return RTE_VHOST_MSG_RESULT_ERR ;lib/librte_vhost/vhost_user.c +2
-1} }@@ -1166,7 +1168,8 @@ vhost_user_set_mem_table(struct virtio_net **pdev,struct VhostUserMsg *msg, goto err_mmap; } - populate = (dev->dequeue_zero_copy) ?MAP_POPULATE :0 ; + populate = (dev->dequeue_zero_copy || dev->async_copy) ? +MAP_POPULATE :0 ; mmap_addr = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE,lib/librte_vhost/vhost_user.c +1
-1MAP_SHARED | populate, fd, 0);@@ -1181,7 +1184,7 @@ vhost_user_set_mem_table(struct virtio_net **pdev,struct VhostUserMsg *msg, reg->host_user_addr = (uint64_t)(uintptr_t)mmap_addr + mmap_offset; -if (dev->dequeue_zero_copy) +if (dev->dequeue_zero_copy || dev->async_copy)if (add_guest_pages (dev, reg, alignment) <0 ) { VHOST_LOG_CONFIG(ERR,"adding guest pages to region %u
failed.\n", @@ -1979,6 +1982,12 @@ vhost_user_get_vring_base(structvirtio_net**pdev,lib/librte_vhost/vhost_user.c +14
-0}else {rte_free (vq->shadow_used_split); vq->shadow_used_split =NULL ; +if (vq->async_pkts_pending) +rte_free (vq->async_pkts_pending); +if (vq->async_pending_info) +rte_free (vq->async_pending_info); + vq->async_pkts_pending =NULL ; + vq->async_pending_info =NULL ; }rte_free (vq->batch_copy_elems);@@ -2012,6 +2021,14 @@ vhost_user_set_vring_enable(struct virtio_net **pdev,"set queue enable: %d to qp idx: %d\n" , enable, index); +if (!enable && dev->virtqueue[index]->async_registered) { +if (dev->virtqueue[index]->async_pkts_inflight_n) { +VHOST_LOG_CONFIG (ERR ,"failed to disable vring. " +"async inflight packets must be completed first\n" ); +return RTE_VHOST_MSG_RESULT_ERR ; + } + } +/* On disable, rings have to be stopped being processed. */ if (!enable && dev->dequeue_zero_copy)
Quoted 3 lines
drain_zmbuf_list(dev->virtqueue[index]);
--
2.18.4
PATCH v6 2/2 vhost: introduce async enqueue for split ring
In reply to [email protected]From: Patrick Fu <[email protected]>
This patch implements async enqueue data path for split ring. 2 new async data path APIs are defined, by which applications can submit and poll packets to/from async engines. The async engine is either a physical DMA device or it could also be a software emulated backend. The async enqueue data path leverages callback functions registered by applications to work with the async engine.
--- lib/librte_vhost/rte_vhost_async.h | 40 +++ lib/librte_vhost/virtio_net.c | 551 ++++++++++++++++++++++++++++- 2 files changed, 589 insertions(+), 2 deletions(-)
lib/librte_vhost/rte_vhost_async.h +40 -0
@@ -133,4 +133,44 @@ int rte_vhost_async_channel_register(int vid, uint16_t queue_id,__rte_experimental int rte_vhost_async_channel_unregister(int vid, uint16_t queue_id); +/** +* This function submit enqueue data to async engine. This function has +* no guranttee to the transfer completion upon return. Applications +* should poll transfer status by rte_vhost_poll_enqueue_completed() +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data +* @param pkts +* array of packets to be enqueued +* @param count +* packets num to be enqueued +* @return +* num of packets enqueued +*/ +__rte_experimental +uint16_t rte_vhost_submit_enqueue_burst(int vid, uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); + +/** +* This function check async completion status for a specific vhost +* device queue. Packets which finish copying (enqueue) operation +* will be returned in an array. +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data +* @param pkts +* blank array to get return packet pointer +* @param count +* size of the packet array +* @return +* num of packets returned +*/ +__rte_experimental +uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); +#endif /* _RTE_VHOST_ASYNC_H_ */
lib/librte_vhost/virtio_net.c +549 -2
581 lines not on this page · raw message
Signature · 1 line
2.18.4
Re: [dpdk-dev] [PATCH v6 2/2] vhost: introduce async enqueue for split ring
Quoted 666 lines
-----Original Message-----
From: Fu, Patrick <[email protected]>
Sent: Tuesday, July 7, 2020 1:07 PM
To: [email protected]; [email protected]; Xia, Chenbo <[email protected]>; Wang, Zhihong <[email protected]>
Cc: Fu, Patrick <[email protected]>; Wang, Yinan <[email protected]>; Jiang, Cheng1 <[email protected]>; Liang, Cunming <[email protected]>
Subject: [PATCH v6 2/2] vhost: introduce async enqueue for split ringFrom: Patrick Fu <[email protected]>
This patch implements async enqueue data path for split ring. 2 new async data path APIs are defined, by which applications can submit and poll packets to/from async engines. The async engine is either a physical DMA device or it could also be a software emulated backend.
The async enqueue data path leverages callback functions registered by applications to work with the async engine.Signed-off-by Patrick Fu <[email protected]>--- lib/librte_vhost/rte_vhost_async.h | 40 +++ lib/librte_vhost/virtio_net.c | 551 ++++++++++++++++++++++++++++- 2 files changed, 589 insertions(+), 2 deletions(-)lib/librte_vhost/rte_vhost_async.h +40
-0@@ -133,4 +133,44 @@ int rte_vhost_async_channel_register(int vid, uint16_t queue_id, __rte_experimental int rte_vhost_async_channel_unregister(int vid,uint16_t queue_id); +/** +* This function submit enqueue data to async engine. This function has +* no guranttee to the transfer completion upon return. Applications +* should poll transfer status by rte_vhost_poll_enqueue_completed() +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data +* @param pkts +* array of packets to be enqueued +* @param count +* packets num to be enqueued +* @return +* num of packets enqueued +*/ +__rte_experimental +uint16_t rte_vhost_submit_enqueue_burst(int vid, uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); + +/** +* This function check async completion status for a specific vhost +* device queue. Packets which finish copying (enqueue) operation +* will be returned in an array. +* +* @param vid +* id of vhost device to enqueue data +* @param queue_id +* queue id to enqueue data +* @param pkts +* blank array to get return packet pointer +* @param count +* size of the packet array +* @return +* num of packets returned +*/ +__rte_experimental +uint16_t rte_vhost_poll_enqueue_completed(int vid, uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count); +#endif /* _RTE_VHOST_ASYNC_H_ */ lib/librte_vhost/virtio_net.c index renamed from lib/librte_vhost/virtio_net.c +0
-0
751c1f373..236498f71100644lib/librte_vhost/virtio_net.c +3
-2@@ -17,14 +17,15 @@#include <rte_arp.h> #include <rte_spinlock.h> #include <rte_malloc.h> +#include <rte_vhost_async.h> #include "iotlb.h" #include "vhost.h" -#define MAX_PKT_BURST 32 -#define MAX_BATCH_LEN 256 +#define VHOST_ASYNC_BATCH_THRESHOLD 32 + static __rte_always_inline bool rxvq_is_mergeable(struct virtio_net *dev) { @@ -116,6 +117,31 @@ flush_shadow_used_ring_split(struct virtio_net *dev, struct vhost_virtqueue *vq)lib/librte_vhost/virtio_net.c +196
-0sizeof(vq->used->idx)); } +static __rte_always_inline void +async_flush_shadow_used_ring_split (struct virtio_net *dev, +struct vhost_virtqueue *vq) +{ +uint16_t used_idx = vq->last_used_idx & (vq->size -1 ); + +if (used_idx + vq->shadow_used_idx <= vq->size) { +do_flush_shadow_used_ring_split (dev, vq, used_idx,0 , + vq->shadow_used_idx); + }else { +uint16_t size; + +/* update used ring interval [used_idx, vq->size] */ + size = vq->size - used_idx; +do_flush_shadow_used_ring_split (dev, vq, used_idx,0 , size); + +/* update the left half used ring interval [0, left_size] */ +do_flush_shadow_used_ring_split (dev, vq,0 , size, + vq->shadow_used_idx - size); + } + + vq->last_used_idx += vq->shadow_used_idx; + vq->shadow_used_idx =0 ; +} + static __rte_always_inline voidupdate_shadow_used_ring_split (struct vhost_virtqueue *vq,uint16_t desc_idx,uint32_t len)@@ -905,6 +931,200 @@ copy_mbuf_to_desc(struct virtio_net *dev, structvhost_virtqueue *vq, return error; } +static __rte_always_inline void +async_fill_vec (struct iovec *v,void *base,size_t len) { + v->iov_base = base; + v->iov_len = len; +} + +static __rte_always_inline void +async_fill_iter (struct rte_vhost_iov_iter *it,size_t count, +struct iovec *vec,unsigned long nr_seg) { + it->offset =0 ; + it->count = count; + +if (count) { + it->iov = vec; + it->nr_segs = nr_seg; + }else { + it->iov =0 ; + it->nr_segs =0 ; + } +} + +static __rte_always_inline void +async_fill_desc (struct rte_vhost_async_desc *desc, +struct rte_vhost_iov_iter *src,struct rte_vhost_iov_iter *dst) { + desc->src = src; + desc->dst = dst; +} + +static __rte_always_inline int +async_mbuf_to_desc (struct virtio_net *dev,struct vhost_virtqueue *vq, +struct rte_mbuf *m,struct buf_vector *buf_vec, +uint16_t nr_vec,uint16_t num_buffers, +struct iovec *src_iovec,struct iovec *dst_iovec, +struct rte_vhost_iov_iter *src_it, +struct rte_vhost_iov_iter *dst_it) +{ +uint32_t vec_idx =0 ; +uint32_t mbuf_offset, mbuf_avail; +uint32_t buf_offset, buf_avail; +uint64_t buf_addr, buf_iova, buf_len; +uint32_t cpy_len, cpy_threshold; +uint64_t hdr_addr; +struct rte_mbuf *hdr_mbuf; +struct batch_copy_elem *batch_copy = vq->batch_copy_elems; +struct virtio_net_hdr_mrg_rxbuf tmp_hdr, *hdr =NULL ; +int error =0 ; + +uint32_t tlen =0 ; +int tvec_idx =0 ; +void *hpa; + +if (unlikely (m ==NULL )) { + error =-1 ; + goto out; + } + + cpy_threshold = vq->async_threshold; + + buf_addr = buf_vec[vec_idx].buf_addr; + buf_iova = buf_vec[vec_idx].buf_iova; + buf_len = buf_vec[vec_idx].buf_len; + +if (unlikely (buf_len < dev->vhost_hlen && nr_vec <=1 )) { + error =-1 ; + goto out; + } + + hdr_mbuf = m; + hdr_addr = buf_addr; +if (unlikely (buf_len < dev->vhost_hlen)) + hdr = &tmp_hdr; +else + hdr = (struct virtio_net_hdr_mrg_rxbuf *)(uintptr_t )hdr_addr; + +VHOST_LOG_DATA (DEBUG ,"(%d) RX: num merge buffers %d\n" , + dev->vid, num_buffers); + +if (unlikely (buf_len < dev->vhost_hlen)) { + buf_offset = dev->vhost_hlen - buf_len; + vec_idx++; + buf_addr = buf_vec[vec_idx].buf_addr; + buf_iova = buf_vec[vec_idx].buf_iova; + buf_len = buf_vec[vec_idx].buf_len; + buf_avail = buf_len - buf_offset; + }else { + buf_offset = dev->vhost_hlen; + buf_avail = buf_len - dev->vhost_hlen; + } + + mbuf_avail =rte_pktmbuf_data_len (m); + mbuf_offset =0 ; + +while (mbuf_avail !=0 || m->next !=NULL ) { +/* done with current buf, get the next one */ +if (buf_avail ==0 ) { + vec_idx++; +if (unlikely (vec_idx >= nr_vec)) { + error =-1 ; + goto out; + } + + buf_addr = buf_vec[vec_idx].buf_addr; + buf_iova = buf_vec[vec_idx].buf_iova; + buf_len = buf_vec[vec_idx].buf_len; + + buf_offset =0 ; + buf_avail = buf_len; + } + +/* done with current mbuf, get the next one */ +if (mbuf_avail ==0 ) { + m = m->next; + + mbuf_offset =0 ; + mbuf_avail =rte_pktmbuf_data_len (m); + } + +if (hdr_addr) { +virtio_enqueue_offload (hdr_mbuf, &hdr->hdr); +if (rxvq_is_mergeable (dev)) +ASSIGN_UNLESS_EQUAL (hdr->num_buffers, + num_buffers); + +if (unlikely (hdr == &tmp_hdr)) { +copy_vnet_hdr_to_desc (dev, vq, buf_vec, hdr); + }else { +PRINT_PACKET (dev, (uintptr_t )hdr_addr, + dev->vhost_hlen,0 ); +vhost_log_cache_write_iova (dev, vq, + buf_vec[0 ].buf_iova, + dev->vhost_hlen); + } + + hdr_addr =0 ; + } + + cpy_len =RTE_MIN (buf_avail, mbuf_avail); + +if (unlikely (cpy_len >= cpy_threshold)) { + hpa = (void *)(uintptr_t )gpa_to_hpa (dev, + buf_iova + buf_offset, cpy_len); + +if (unlikely (!hpa)) { + error =-1 ; + goto out; + } + +async_fill_vec (src_iovec + tvec_idx, + (void *)(uintptr_t )rte_pktmbuf_iova_offset (m, + mbuf_offset), cpy_len); + +async_fill_vec (dst_iovec + tvec_idx, hpa, cpy_len); + + tlen += cpy_len; + tvec_idx++; + }else { +if (unlikely (vq->batch_copy_nb_elems >= vq->size)) { +rte_memcpy ( + (void *)((uintptr_t )(buf_addr + buf_offset)), + rte_pktmbuf_mtod_offset(m, void *, mbuf_offset), + cpy_len); + +PRINT_PACKET (dev, + (uintptr_t )(buf_addr + buf_offset), + cpy_len,0 ); + }else { + batch_copy[vq->batch_copy_nb_elems].dst = + (void *)((uintptr_t )(buf_addr + buf_offset)); + batch_copy[vq->batch_copy_nb_elems].src = + rte_pktmbuf_mtod_offset(m, void *, mbuf_offset); + batch_copy[vq-Quoted 1 line
batch_copy_nb_elems].log_addr =
lib/librte_vhost/virtio_net.c +213
-0+ buf_iova + buf_offset; + batch_copy[vq->batch_copy_nb_elems].len = + cpy_len; + vq->batch_copy_nb_elems++; + } + } + + mbuf_avail -= cpy_len; + mbuf_offset += cpy_len; + buf_avail -= cpy_len; + buf_offset += cpy_len; + } + +out: +async_fill_iter (src_it, tlen, src_iovec, tvec_idx); +async_fill_iter (dst_it, tlen, dst_iovec, tvec_idx); + +return error; +} + static __rte_always_inline int vhost_enqueue_single_packed(struct virtio_net *dev, struct vhost_virtqueue *vq,@@ -1236,6 +1456,333 @@ rte_vhost_enqueue_burst(int vid, uint16_t queue_id, return virtio_dev_rx(dev, queue_id, pkts, count); } +static __rte_always_inline uint16_t +virtio_dev_rx_async_get_info_idx (uint16_t pkts_idx, +uint16_t vq_size,uint16_t n_inflight) { +return pkts_idx > n_inflight ? (pkts_idx - n_inflight) : + (vq_size - n_inflight + pkts_idx) & (vq_size -1 ); } + +static __rte_always_inline void +virtio_dev_rx_async_submit_split_err (struct virtio_net *dev, +struct vhost_virtqueue *vq,uint16_t queue_id, +uint16_t last_idx,uint16_t shadow_idx) { +uint16_t start_idx, pkts_idx, vq_size; +uint64_t *async_pending_info; + + pkts_idx = vq->async_pkts_idx; + async_pending_info = vq->async_pending_info; + vq_size = vq->size; + start_idx =virtio_dev_rx_async_get_info_idx (pkts_idx, + vq_size, vq->async_pkts_inflight_n); + +while (likely ((start_idx & (vq_size -1 )) != pkts_idx)) { +uint64_t n_seg = + async_pending_info[(start_idx) & (vq_size -1 )] >> +ASYNC_PENDING_INFO_N_SFT ; + +while (n_seg) + n_seg -= vq->async_ops.check_completed_copies (dev- >vid, + queue_id,0 ,1 ); + } + + vq->async_pkts_inflight_n =0 ; + vq->batch_copy_nb_elems =0 ; + + vq->shadow_used_idx = shadow_idx; + vq->last_avail_idx = last_idx; +} + +static __rte_noinline uint32_t +virtio_dev_rx_async_submit_split (struct virtio_net *dev, +struct vhost_virtqueue *vq,uint16_t queue_id, +struct rte_mbuf **pkts,uint32_t count) { +uint32_t pkt_idx =0 , pkt_burst_idx =0 ; +uint16_t num_buffers; +struct buf_vector buf_vec[BUF_VECTOR_MAX ]; +uint16_t avail_head, last_idx, shadow_idx; + +struct rte_vhost_iov_iter *it_pool = vq->it_pool; +struct iovec *vec_pool = vq->vec_pool; +struct rte_vhost_async_desc tdes[MAX_PKT_BURST ]; +struct iovec *src_iovec = vec_pool; +struct iovec *dst_iovec = vec_pool + (VHOST_MAX_ASYNC_VEC >>1 ); +struct rte_vhost_iov_iter *src_it = it_pool; +struct rte_vhost_iov_iter *dst_it = it_pool +1 ; +uint16_t n_free_slot, slot_idx; +int n_pkts =0 ; + + avail_head =__atomic_load_n (&vq->avail->idx, __ATOMIC_ACQUIRE); + last_idx = vq->last_avail_idx; + shadow_idx = vq->shadow_used_idx; + +/* +* The ordering between avail index and +* desc reads needs to be enforced. +*/ +rte_smp_rmb (); + +rte_prefetch0 (&vq->avail->ring[vq->last_avail_idx & (vq->size -1 )]); + +for (pkt_idx =0 ; pkt_idx < count; pkt_idx++) { +uint32_t pkt_len = pkts[pkt_idx]->pkt_len + dev->vhost_hlen; +uint16_t nr_vec =0 ; + +if (unlikely (reserve_avail_buf_split (dev, vq, + pkt_len, buf_vec, &num_buffers, + avail_head, &nr_vec) <0 )) { +VHOST_LOG_DATA (DEBUG , +"(%d) failed to get enough desc from vring\n" , + dev->vid); + vq->shadow_used_idx -= num_buffers; +break ; + } + + VHOST_LOG_DATA(DEBUG, "(%d) current index %d | end index %d\n", + dev->vid, vq->last_avail_idx, + vq->last_avail_idx + num_buffers); + +if (async_mbuf_to_desc (dev, vq, pkts[pkt_idx], + buf_vec, nr_vec, num_buffers, + src_iovec, dst_iovec, src_it, dst_it) <0 ) { + vq->shadow_used_idx -= num_buffers; +break ; + } + + slot_idx = (vq->async_pkts_idx + pkt_idx) & (vq->size -1 ); +if (src_it->count) { +async_fill_desc (&tdes[pkt_burst_idx], src_it, dst_it); + pkt_burst_idx++; + vq->async_pending_info[slot_idx] = + num_buffers | (src_it->nr_segs <<16 ); + src_iovec += src_it->nr_segs; + dst_iovec += dst_it->nr_segs; + src_it +=2 ; + dst_it +=2 ; + }else { + vq->async_pending_info[slot_idx] = num_buffers; + vq->async_pkts_inflight_n++; + } + + vq->last_avail_idx += num_buffers; + +if (pkt_burst_idx >=VHOST_ASYNC_BATCH_THRESHOLD || + (pkt_idx == count -1 && pkt_burst_idx)) { + n_pkts = vq->async_ops.transfer_data (dev->vid, + queue_id, tdes,0 , pkt_burst_idx); + src_iovec = vec_pool; + dst_iovec = vec_pool + (VHOST_MAX_ASYNC_VEC >>1 ); + src_it = it_pool; + dst_it = it_pool +1 ; + +if (unlikely (n_pkts < (int )pkt_burst_idx)) { + vq->async_pkts_inflight_n += + n_pkts >0 ? n_pkts :0 ; +virtio_dev_rx_async_submit_split_err (dev, + vq, queue_id, last_idx, shadow_idx); +return 0 ; + } + + pkt_burst_idx =0 ; + vq->async_pkts_inflight_n += n_pkts; + } + } + +if (pkt_burst_idx) { + n_pkts = vq->async_ops.transfer_data (dev->vid, + queue_id, tdes,0 , pkt_burst_idx); +if (unlikely (n_pkts < (int )pkt_burst_idx)) { + vq->async_pkts_inflight_n += n_pkts >0 ? n_pkts :0 ; +virtio_dev_rx_async_submit_split_err (dev, vq, queue_id, + last_idx, shadow_idx); +return 0 ; + } + + vq->async_pkts_inflight_n += n_pkts; + } + +do_data_copy_enqueue (dev, vq); + + n_free_slot = vq->size - vq->async_pkts_idx; +if (n_free_slot > pkt_idx) { +rte_memcpy (&vq->async_pkts_pending[vq->async_pkts_idx], + pkts, pkt_idx *sizeof (uintptr_t )); + vq->async_pkts_idx += pkt_idx; + }else { +rte_memcpy (&vq->async_pkts_pending[vq->async_pkts_idx], + pkts, n_free_slot *sizeof (uintptr_t )); +rte_memcpy (&vq->async_pkts_pending[0 ], + &pkts[n_free_slot], + (pkt_idx - n_free_slot) *sizeof (uintptr_t )); + vq->async_pkts_idx = pkt_idx - n_free_slot; + } + +if (likely (vq->shadow_used_idx)) +async_flush_shadow_used_ring_split (dev, vq); + +return pkt_idx; +} + +uint16_t rte_vhost_poll_enqueue_completed (int vid,uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count) { +struct virtio_net *dev =get_device (vid); +struct vhost_virtqueue *vq; +uint16_t n_pkts_cpl, n_pkts_put =0 , n_descs =0 ; +uint16_t start_idx, pkts_idx, vq_size; +uint64_t *async_pending_info; + +VHOST_LOG_DATA (DEBUG ,"(%d) %s\n" , dev->vid, __func__); +if (unlikely (!is_valid_virt_queue_idx (queue_id,0 , dev->nr_vring))) { +VHOST_LOG_DATA (ERR ,"(%d) %s: invalid virtqueue idx %d.\n" , + dev->vid, __func__, queue_id); +return 0 ; + } + + vq = dev->virtqueue[queue_id]; + +rte_spinlock_lock (&vq->access_lock); + + pkts_idx = vq->async_pkts_idx; + async_pending_info = vq->async_pending_info; + vq_size = vq->size; + start_idx =virtio_dev_rx_async_get_info_idx (pkts_idx, + vq_size, vq->async_pkts_inflight_n); + + n_pkts_cpl = + vq->async_ops.check_completed_copies(vid, queue_id, 0,count);
lib/librte_vhost/virtio_net.c +15
-0+ +rte_smp_wmb (); + +while (likely (((start_idx + n_pkts_put) & (vq_size -1 )) != pkts_idx)) { +uint64_t info = async_pending_info[ + (start_idx + n_pkts_put) & (vq_size -1 )]; +uint64_t n_segs; + n_pkts_put++; + n_descs += info &ASYNC_PENDING_INFO_N_MSK ; + n_segs = info >>ASYNC_PENDING_INFO_N_SFT ; + +if (n_segs) { +if (!n_pkts_cpl || n_pkts_cpl < n_segs) { + n_pkts_put--; + n_descs -= info &
ASYNC_PENDING_INFO_N_MSK;lib/librte_vhost/virtio_net.c +7
-0+if (n_pkts_cpl) { + async_pending_info[ + (start_idx + n_pkts_put) & + (vq_size -1 )] = + ((n_segs - n_pkts_cpl) << + ASYNC_PENDING_INFO_N_SFT) | + (info &
ASYNC_PENDING_INFO_N_MSK);lib/librte_vhost/virtio_net.c +11
-0+ n_pkts_cpl =0 ; + } +break ; + } + n_pkts_cpl -= n_segs; + } + } + +if (n_pkts_put) { + vq->async_pkts_inflight_n -= n_pkts_put; + __atomic_add_fetch(&vq->used->idx, n_descs,
__ATOMIC_RELEASE);lib/librte_vhost/virtio_net.c +11
-0+ +vhost_vring_call_split (dev, vq); + } + +if (start_idx + n_pkts_put <= vq_size) { +rte_memcpy (pkts, &vq->async_pkts_pending[start_idx], + n_pkts_put *sizeof (uintptr_t )); + }else { +rte_memcpy (pkts, &vq->async_pkts_pending[start_idx], + (vq_size - start_idx) *sizeof (uintptr_t )); + rte_memcpy(&pkts[vq_size - start_idx], vq-Quoted 1 line
async_pkts_pending,lib/librte_vhost/virtio_net.c +61
-0+ (n_pkts_put - vq_size + start_idx) * sizeof(uintptr_t)); + } + +rte_spinlock_unlock (&vq->access_lock); + +return n_pkts_put; +} + +static __rte_always_inline uint32_t +virtio_dev_rx_async_submit (struct virtio_net *dev,uint16_t queue_id, +struct rte_mbuf **pkts,uint32_t count) { +struct vhost_virtqueue *vq; +uint32_t nb_tx =0 ; +bool drawback = false; + +VHOST_LOG_DATA (DEBUG ,"(%d) %s\n" , dev->vid, __func__); +if (unlikely (!is_valid_virt_queue_idx (queue_id,0 , dev->nr_vring))) { +VHOST_LOG_DATA (ERR ,"(%d) %s: invalid virtqueue idx %d.\n" , + dev->vid, __func__, queue_id); +return 0 ; + } + + vq = dev->virtqueue[queue_id]; + +rte_spinlock_lock (&vq->access_lock); + +if (unlikely (vq->enabled ==0 )) + goto out_access_unlock; + +if (unlikely (!vq->async_registered)) { + drawback = true; + goto out_access_unlock; + } + +if (dev->features & (1ULL <<VIRTIO_F_IOMMU_PLATFORM )) +vhost_user_iotlb_rd_lock (vq); + +if (unlikely (vq->access_ok ==0 )) +if (unlikely (vring_translate (dev, vq) <0 )) + goto out; + + count =RTE_MIN ((uint32_t )MAX_PKT_BURST , count); +if (count ==0 ) + goto out; + +/* TODO: packed queue not implemented */ +if (vq_is_packed (dev)) + nb_tx =0 ; +else + nb_tx =virtio_dev_rx_async_submit_split (dev, + vq, queue_id, pkts, count); + +out: +if (dev->features & (1ULL <<VIRTIO_F_IOMMU_PLATFORM )) +vhost_user_iotlb_rd_unlock (vq); + +out_access_unlock: +rte_spinlock_unlock (&vq->access_lock); + +if (drawback) + return rte_vhost_enqueue_burst(dev->vid, queue_id, pkts,count);
lib/librte_vhost/virtio_net.c +21
-1+ +return nb_tx; +} + +uint16_t +rte_vhost_submit_enqueue_burst (int vid,uint16_t queue_id, +struct rte_mbuf **pkts,uint16_t count) { +struct virtio_net *dev =get_device (vid); + +if (!dev) +return 0 ; + +if (unlikely (!(dev->flags &VIRTIO_DEV_BUILTIN_VIRTIO_NET ))) { +VHOST_LOG_DATA (ERR , +"(%d) %s: built-in vhost net backend is disabled.\n" , + dev->vid, __func__); +return 0 ; + } + +return virtio_dev_rx_async_submit (dev, queue_id, pkts, count); } +static inline bool virtio_net_with_host_offload (struct virtio_net *dev) { --
Quoted 1 line
2.18.4
Quoted 51 lines · On 7/7/2020 6:07 AM, [email protected] wrote:
From: Patrick Fu <[email protected]>
Performing large memory copies usually takes up a major part of CPU cycles and becomes the hot spot in vhost-user enqueue operation. To offload expensive memory operations from the CPU, this patch set proposes to leverage DMA engines, e.g., I/OAT, a DMA engine in the Intel's processor, to accelerate large copies.
Large copies are offloaded from the CPU to the DMA in an asynchronous manner. The CPU just submits copy jobs to the DMA but without waiting for its copy completion. Thus, there is no CPU intervention during data transfer; we can save precious CPU cycles and improve the overall throughput for vhost-user based applications, like OVS. During packet transmission, it offloads large copies to the DMA and performs small copies by the CPU, due to startup overheads associated with the DMA.
This patch set construct a general framework that applications can leverage to attach DMA channels with vhost-user transmit queues. Four new RTE APIs are introduced to vhost library for applications to register and use the asynchronous data path. In addition, two new DMA operation callbacks are defined, by which vhost-user asynchronous data path can interact with DMA hardware. Currently only enqueue operation for split queue is implemented, but the framework is flexible to extend support for packed queue.
v2:
update meson file for new header file
update rte_vhost_version.map to include new APIs rename async APIs/structures to be prefixed with "rte_vhost" rename some variables/structures for readibility correct minor typo in comments/license statements refine memory allocation logic for vq internal buffer add error message printing in some failure cases check inflight async packets in unregistration API call mark new APIs as experimentalv3:
useatomic_xxx()functions in updating ring index
fix a bug in async enqueue failure handlingv4:
part of the fix intended in v3 patch was missed, this patch adds all thoes fixesv5:
minor changes on some function/variable names reset CPU batch copy packet count when async enqueue error occurs
disable virtio log feature in async copy mode minor optimization on async shadow index flush
Quoted 7 lines
v6:
add some background introduction in the commit messagePatrick Fu (2):
vhost: introduce async enqueue registration API
vhost: introduce async enqueue for split ring
Series applied to dpdk-next-net/master, thanks.
Hi Patrick,
Thanks for the series.
I think we miss a chapter in the Vhost lib documentation to explain what this new API is about.
Do you think you can write something by -rc3?
Thanks in advance,
Maxime
Quoted 71 lines · On 7/7/20 7:07 AM, [email protected] wrote:
From: Patrick Fu <[email protected]>
Performing large memory copies usually takes up a major part of CPU cycles and becomes the hot spot in vhost-user enqueue operation. To offload expensive memory operations from the CPU, this patch set proposes to leverage DMA engines, e.g., I/OAT, a DMA engine in the Intel's processor, to accelerate large copies.
Large copies are offloaded from the CPU to the DMA in an asynchronous manner. The CPU just submits copy jobs to the DMA but without waiting for its copy completion. Thus, there is no CPU intervention during data transfer; we can save precious CPU cycles and improve the overall throughput for vhost-user based applications, like OVS. During packet transmission, it offloads large copies to the DMA and performs small copies by the CPU, due to startup overheads associated with the DMA.
This patch set construct a general framework that applications can leverage to attach DMA channels with vhost-user transmit queues. Four new RTE APIs are introduced to vhost library for applications to register and use the asynchronous data path. In addition, two new DMA operation callbacks are defined, by which vhost-user asynchronous data path can interact with DMA hardware. Currently only enqueue operation for split queue is implemented, but the framework is flexible to extend support for packed queue.
v2:
update meson file for new header file
update rte_vhost_version.map to include new APIs rename async APIs/structures to be prefixed with "rte_vhost" rename some variables/structures for readibility correct minor typo in comments/license statements refine memory allocation logic for vq internal buffer add error message printing in some failure cases check inflight async packets in unregistration API call mark new APIs as experimentalv3:
useatomic_xxx()functions in updating ring index
fix a bug in async enqueue failure handlingv4:
part of the fix intended in v3 patch was missed, this patch adds all thoes fixesv5:
minor changes on some function/variable names reset CPU batch copy packet count when async enqueue error occurs
disable virtio log feature in async copy mode minor optimization on async shadow index flushv6:
add some background introduction in the commit messagePatrick Fu (2):
vhost: introduce async enqueue registration API
vhost: introduce async enqueue for split ringlib/librte_vhost/Makefile | 2 +- lib/librte_vhost/meson.build | 2 +- lib/librte_vhost/rte_vhost.h | 1 + lib/librte_vhost/rte_vhost_async.h | 176 ++++++++ lib/librte_vhost/rte_vhost_version.map | 4 + lib/librte_vhost/socket.c | 27 ++ lib/librte_vhost/vhost.c | 127 +++++- lib/librte_vhost/vhost.h | 30 +- lib/librte_vhost/vhost_user.c | 23 +- lib/librte_vhost/virtio_net.c | 551 ++++++++++++++++++++++++- 10 files changed, 934 insertions(+), 9 deletions(-) create mode 100644 lib/librte_vhost/rte_vhost_async.h
Hi Maxime,
Quoted 9 lines
-----Original Message-----
From: Maxime Coquelin <[email protected]>
Sent: Monday, July 20, 2020 9:27 PM
To: Fu, Patrick <[email protected]>; [email protected]; Xia, Chenbo <[email protected]>; Wang, Zhihong <[email protected]>
Cc: Wang, Yinan <[email protected]>; Jiang, Cheng1 <[email protected]>; Liang, Cunming <[email protected]>
Subject: Re: [PATCH v6 0/2] introduce asynchronous data path for vhost
Quoted 7 lines
Hi Patrick,
Thanks for the series.
I think we miss a chapter in the Vhost lib documentation to explain what this new API is about.Do you think you can write something by -rc3?
Yes, I'm preparing for the doc currently. Since there is still a slight change to the API proto-type I would like to propose, I will send both of the doc and the change in a day or two.
Thanks,
Patrick
Quoted 17 lines · Patrick
Hi Maxime,
Quoted 15 lines
-----Original Message-----
From: Maxime Coquelin <[email protected]>
Sent: Monday, July 20, 2020 9:27 PM
To: Fu, Patrick <[email protected]>; [email protected]; Xia, Chenbo <[email protected]>; Wang, Zhihong <[email protected]>
Cc: Wang, Yinan <[email protected]>; Jiang, Cheng1 <[email protected]>; Liang, Cunming <[email protected]>
Subject: Re: [PATCH v6 0/2] introduce asynchronous data path for vhostHi Patrick,
Thanks for the series.
I think we miss a chapter in the Vhost lib documentation to explain what this new API is about.
Quoted 8 lines
Quoted 1 line
Do you think you can write something by -rc3?
Yes, I'm preparing for the doc currently. Since there is still a slight change to the API proto-type I would like to propose, I will send both of the doc and the change in a day or two.
Thanks,
Patrick
Thanks Patrick!