net/smc: Introduce virtually contiguous buffers for SMC-R
Subsystems (6)
Wen Gu
reviewerv2 cover net/smc: Introduce virtually contiguous buffers for SMC-R
On long-running enterprise production servers, high-order contiguous memory pages are usually very rare and in most cases we can only get fragmented pages.
When replacing TCP with SMC-R in such production scenarios, attempting to allocate high-order physically contiguous sndbufs and RMBs may result in frequent memory compaction, which will cause unexpected hung issue and further stability risks.
So this patch set is aimed to allow SMC-R link group to use virtually contiguous sndbufs and RMBs to avoid potential issues mentioned above. Whether to use physically or virtually contiguous buffers can be set by sysctl smcr_buf_type.
Note that using virtually contiguous buffers will bring an acceptable performance regression, which can be mainly divided into two parts:
1) regression in data path, which is brought by additional address translation of sndbuf by RNIC in Tx. But in general, translating address through MTT is fast. According to qperf test, this part regression is basically less than 10% in latency and bandwidth. (see patch 5/6 for details)
2) regression in buffer initialization and destruction path, which is brought by additional MR operations of sndbufs. But thanks to link group buffer reuse mechanism, the impact of this kind of regression decreases as times of buffer reuse increases.
Patch set overview:
- Patch 1/6 and 2/6 mainly about simplifying and optimizing DMA sync operation, which will reduce overhead on the data path, especially when using virtually contiguous buffers;
- Patch 3/6 and 4/6 introduce a sysctl smcr_buf_type to set the type of buffers in new created link group;
- Patch 5/6 allows SMC-R to use virtually contiguous sndbufs and RMBs, including buffer creation, destruction, MR operation and access;
- patch 6/6 extends netlink attribute for buffer type of SMC-R link group;
v1->v2:
- Patch 5/6 fixes build issue on 32bit;
- Patch 3/6 adds description of new sysctl in smc-sysctl.rst;
Guangguan Wang (2):
net/smc: remove redundant dma sync ops net/smc: optimize for smc_sndbuf_sync_sg_for_device and
smc_rmb_sync_sg_for_cpu
Wen Gu (4):
net/smc: Introduce a sysctl for setting SMC-R buffer type net/smc: Use sysctl-specified types of buffers in new link group net/smc: Allow virtually contiguous sndbufs or RMBs for SMC-R net/smc: Extend SMC-R link group netlink attribute
Documentation/networking/smc-sysctl.rst | 13 ++ include/net/netns/smc.h | 1 + include/uapi/linux/smc.h | 1 + net/smc/af_smc.c | 68 +++++++-- net/smc/smc_clc.c | 8 +- net/smc/smc_clc.h | 2 +- net/smc/smc_core.c | 246 +++++++++++++++++++++----------- net/smc/smc_core.h | 20 ++- net/smc/smc_ib.c | 44 +++++- net/smc/smc_ib.h | 2 + net/smc/smc_llc.c | 33 +++-- net/smc/smc_rx.c | 92 +++++++++--- net/smc/smc_sysctl.c | 11 ++ net/smc/smc_tx.c | 10 +- 14 files changed, 404 insertions(+), 147 deletions(-)
Signature · 1 line
1.8.3.1
Wen Gu
reviewerPATCH v2 1/6 net/smc: remove redundant dma sync ops
From: Guangguan Wang <[email protected]>
smc_ib_sync_sg_for_cpu/device are the ops used for dma memory cache consistency. Smc sndbufs are dma buffers, where CPU writes data to it and PCIE device reads data from it. So for sndbufs, smc_ib_sync_sg_for_device is needed and smc_ib_sync_sg_for_cpu is redundant as PCIE device will not write the buffers. Smc rmbs are dma buffers, where PCIE device write data to it and CPU read data from it. So for rmbs, smc_ib_sync_sg_for_cpu is needed and smc_ib_sync_sg_for_device is redundant as CPU will not write the buffers.
--- net/smc/af_smc.c | 2 -- net/smc/smc_core.c | 22 ---------------------- net/smc/smc_core.h | 2 -- net/smc/smc_rx.c | 2 -- net/smc/smc_tx.c | 1 - 5 files changed, 29 deletions(-)
net/smc/af_smc.c +0 -2
@@ -1226,7 +1226,6 @@ static int smc_connect_rdma(struct smc_sock *smc, goto connect_abort; } } -smc_rmb_sync_sg_for_device (&smc->conn);if (aclc->hdr.version >SMC_V1 ) { struct smc_clc_msg_accept_confirm_v2 *clc_v2 =
@@ -2113,7 +2112,6 @@ static int smc_listen_rdma_reg(struct smc_sock *new_smc, bool local_first)if (smcr_lgr_reg_rmbs (conn->lnk, conn->rmb_desc))return SMC_CLC_DECL_ERR_REGRMB ; } -smc_rmb_sync_sg_for_device (&new_smc->conn);return 0 ; }
net/smc/smc_core.c +0 -22
@@ -2290,14 +2290,6 @@ static int __smc_buf_create(struct smc_sock *smc, bool is_smcd, bool is_rmb)return 0 ; } -void smc_sndbuf_sync_sg_for_cpu (struct smc_connection *conn) -{ -if (!smc_conn_lgr_valid (conn) || conn->lgr->is_smcd || - !smc_link_active (conn->lnk)) -return ; -smc_ib_sync_sg_for_cpu (conn->lnk, conn->sndbuf_desc,DMA_TO_DEVICE ); -} -void smc_sndbuf_sync_sg_for_device (struct smc_connection *conn) { if (!smc_conn_lgr_valid(conn) || conn->lgr->is_smcd ||
@@ -2320,20 +2312,6 @@ void smc_rmb_sync_sg_for_cpu(struct smc_connection *conn) } } -void smc_rmb_sync_sg_for_device (struct smc_connection *conn) -{ -int i; - -if (!smc_conn_lgr_valid (conn) || conn->lgr->is_smcd) -return ; -for (i =0 ; i <SMC_LINKS_PER_LGR_MAX ; i++) { -if (!smc_link_active (&conn->lgr->lnk[i])) -continue ; -smc_ib_sync_sg_for_device (&conn->lgr->lnk[i], conn->rmb_desc, -DMA_FROM_DEVICE ); - } -} -/* create the send and receive buffer for an SMC socket; * receive buffers are called RMBs; * (even though the SMC protocol allows more than one RMB-element per RMB,
net/smc/smc_core.h +0 -2
@@ -513,10 +513,8 @@ void smc_rtoken_set(struct smc_link_group *lgr, int link_idx, int link_idx_new, __be32 nw_rkey_known, __be64 nw_vaddr, __be32 nw_rkey);void smc_rtoken_set2 (struct smc_link_group *lgr,int rtok_idx,int link_id,__be64 nw_vaddr,__be32 nw_rkey); -void smc_sndbuf_sync_sg_for_cpu (struct smc_connection *conn);void smc_sndbuf_sync_sg_for_device (struct smc_connection *conn);void smc_rmb_sync_sg_for_cpu (struct smc_connection *conn); -void smc_rmb_sync_sg_for_device (struct smc_connection *conn);int smc_vlan_by_tcpsk (struct socket *clcsock,struct smc_init_info *ini);void smc_conn_free (struct smc_connection *conn);
net/smc/smc_rx.c +0 -2
@@ -413,7 +413,6 @@ int smc_rx_recvmsg(struct smc_sock *smc, struct msghdr *msg,if (rc <0 ) {if (!read_done) read_done = -EFAULT ; -smc_rmb_sync_sg_for_device (conn); goto out; } }
@@ -427,7 +426,6 @@ int smc_rx_recvmsg(struct smc_sock *smc, struct msghdr *msg, chunk_len_sum += chunk_len; chunk_off =0 ;/* modulo offset in recv ring buffer */ } -smc_rmb_sync_sg_for_device (conn);/* update cursors */ if (!(flags &MSG_PEEK )) {
net/smc/smc_tx.c +0 -1
@@ -246,7 +246,6 @@ int smc_tx_sendmsg(struct smc_sock *smc, struct msghdr *msg, size_t len) tx_cnt_prep); chunk_len_sum = chunk_len; chunk_off = tx_cnt_prep; -smc_sndbuf_sync_sg_for_cpu (conn);for (chunk =0 ; chunk <2 ; chunk++) { rc =memcpy_from_msg (sndbuf_base + chunk_off, msg, chunk_len);
Signature · 1 line
1.8.3.1
Wen Gu
reviewerPATCH v2 2/6 net/smc: optimize for smc_sndbuf_sync_sg_for_device and smc_rmb_sync_sg_for_cpu
In reply to Wen GuFrom: Guangguan Wang <[email protected]>
Some CPU, such as Xeon, can guarantee DMA cache coherency. So it is no need to use dma sync APIs to flush cache on such CPUs. In order to avoid calling dma sync APIs on the IO path, use the dma_need_sync to check whether smc_buf_desc needs dma sync when creating smc_buf_desc.
--- net/smc/smc_core.c | 8 ++++++++ net/smc/smc_core.h | 1 + net/smc/smc_ib.c | 29 +++++++++++++++++++++++++++++ net/smc/smc_ib.h | 2 ++ 4 files changed, 40 insertions(+)
net/smc/smc_core.c +8 -0
@@ -2016,6 +2016,9 @@ static int smcr_buf_map_link(struct smc_buf_desc *buf_desc, bool is_rmb, goto free_table; } + buf_desc->is_dma_need_sync |= +smc_ib_is_sg_need_sync (lnk, buf_desc) << lnk->link_idx; +/* create a new memory region for the RMB */ if (is_rmb) { rc = smc_ib_get_memory_region(lnk->roce_pd,
@@ -2234,6 +2237,7 @@ static int __smc_buf_create(struct smc_sock *smc, bool is_smcd, bool is_rmb)/* check for reusable slot in the link group */ buf_desc =smc_buf_get_slot (bufsize_short, lock, buf_list);if (buf_desc) { + buf_desc->is_dma_need_sync =0 ;SMC_STAT_RMB_SIZE (smc, is_smcd, is_rmb, bufsize);SMC_STAT_BUF_REUSE (smc, is_smcd, is_rmb);break ;/* found reusable slot */
@@ -2292,6 +2296,8 @@ static int __smc_buf_create(struct smc_sock *smc, bool is_smcd, bool is_rmb)void smc_sndbuf_sync_sg_for_device (struct smc_connection *conn) { +if (!conn->sndbuf_desc->is_dma_need_sync) +return ;if (!smc_conn_lgr_valid (conn) || conn->lgr->is_smcd || !smc_link_active (conn->lnk))return ;
@@ -2302,6 +2308,8 @@ void smc_rmb_sync_sg_for_cpu(struct smc_connection *conn) {int i; +if (!conn->rmb_desc->is_dma_need_sync) +return ;if (!smc_conn_lgr_valid (conn) || conn->lgr->is_smcd)return ;for (i =0 ; i <SMC_LINKS_PER_LGR_MAX ; i++) {
net/smc/smc_core.h +1 -0
@@ -180,6 +180,7 @@ struct smc_buf_desc {/* mem region registered */ u8 is_map_ib[SMC_LINKS_PER_LGR_MAX ];/* mem region mapped to lnk */ +u8 is_dma_need_sync;u8 is_reg_err;/* buffer registration err */ };
net/smc/smc_ib.c +29 -0
@@ -729,6 +729,29 @@ int smc_ib_get_memory_region(struct ib_pd *pd, int access_flags,return 0 ; } +bool smc_ib_is_sg_need_sync (struct smc_link *lnk, +struct smc_buf_desc *buf_slot) +{ +struct scatterlist *sg; +unsigned int i; +bool ret = false; + +/* for now there is just one DMA address */ +for_each_sg (buf_slot->sgt[lnk->link_idx].sgl, sg, + buf_slot->sgt[lnk->link_idx].nents, i) { +if (!sg_dma_len (sg)) +break ; +if (dma_need_sync (lnk->smcibdev->ibdev->dma_device, +sg_dma_address (sg))) { + ret = true; + goto out; + } + } + +out: +return ret; +} +/* synchronize buffer usage for cpu access */ void smc_ib_sync_sg_for_cpu(struct smc_link *lnk, struct smc_buf_desc *buf_slot,
@@ -737,6 +760,9 @@ void smc_ib_sync_sg_for_cpu(struct smc_link *lnk,struct scatterlist *sg;unsigned int i; +if (!(buf_slot->is_dma_need_sync & (1U << lnk->link_idx))) +return ; +/* for now there is just one DMA address */ for_each_sg (buf_slot->sgt[lnk->link_idx].sgl, sg, buf_slot->sgt[lnk->link_idx].nents, i) {
@@ -757,6 +783,9 @@ void smc_ib_sync_sg_for_device(struct smc_link *lnk,struct scatterlist *sg;unsigned int i; +if (!(buf_slot->is_dma_need_sync & (1U << lnk->link_idx))) +return ; +/* for now there is just one DMA address */ for_each_sg (buf_slot->sgt[lnk->link_idx].sgl, sg, buf_slot->sgt[lnk->link_idx].nents, i) {
net/smc/smc_ib.h +2 -0
@@ -102,6 +102,8 @@ void smc_ib_buf_unmap_sg(struct smc_link *lnk,int smc_ib_get_memory_region (struct ib_pd *pd,int access_flags,struct smc_buf_desc *buf_slot,u8 link_idx);void smc_ib_put_memory_region (struct ib_mr *mr); +bool smc_ib_is_sg_need_sync (struct smc_link *lnk, +struct smc_buf_desc *buf_slot);void smc_ib_sync_sg_for_cpu (struct smc_link *lnk,struct smc_buf_desc *buf_slot,enum dma_data_direction data_direction);
Signature · 1 line
1.8.3.1
Wen Gu
reviewerPATCH v2 3/6 net/smc: Introduce a sysctl for setting SMC-R buffer type
In reply to Wen GuThis patch introduces the sysctl smcr_buf_type for setting the type of SMC-R sndbufs and RMBs.
Valid values includes:
- SMCR_PHYS_CONT_BUFS, which means use physically contiguous buffers for better performance and is the default value.
- SMCR_VIRT_CONT_BUFS, which means use virtually contiguous buffers in case of physically contiguous memory is scarce.
- SMCR_MIXED_BUFS, which means first try to use physically contiguous buffers. If not available, then use virtually contiguous buffers.
--- Documentation/networking/smc-sysctl.rst | 13 +++++++++++++ include/net/netns/smc.h | 1 + net/smc/smc_core.h | 6 ++++++ net/smc/smc_sysctl.c | 11 +++++++++++ 4 files changed, 31 insertions(+)
Documentation/networking/smc-sysctl.rst +13 -0
@@ -21,3 +21,16 @@ autocorking_size - INTEGER know how/when to uncork their sockets. Default: 64K + +smcr_buf_type - INTEGER + Controls which type of sndbufs and RMBs to use in later newly created + SMC-R link group. Only for SMC-R. + + Default: 0 (physically contiguous sndbufs and RMBs) + + Possible values: + + - 0 - Use physically contiguous buffers + - 1 - Use virtually contiguous buffers + - 2 - Mixed use of the two types. Try physically contiguous buffers first. + If not available, use virtually contiguous buffers then.
include/net/netns/smc.h +1 -0
@@ -18,5 +18,6 @@ struct netns_smc {struct ctl_table_header *smc_hdr;#endif unsigned int sysctl_autocorking_size; + unsigned int sysctl_smcr_buf_type; };#endif
net/smc/smc_core.h +6 -0
@@ -217,6 +217,12 @@ enum smc_lgr_type { /* redundancy state of lgr */ SMC_LGR_ASYMMETRIC_LOCAL, /* local has 1, peer 2 active RNICs */ }; +enum smcr_buf_type {/* types of SMC-R sndbufs and RMBs */ +SMCR_PHYS_CONT_BUFS =0 , +SMCR_VIRT_CONT_BUFS =1 , +SMCR_MIXED_BUFS =2 , +}; +enum smc_llc_flowtype {SMC_LLC_FLOW_NONE =0 ,SMC_LLC_FLOW_ADD_LINK =2 ,
net/smc/smc_sysctl.c +11 -0
@@ -15,6 +15,7 @@#include <net/net_namespace.h> #include "smc.h" +#include "smc_core.h" #include "smc_sysctl.h" static struct ctl_table smc_table[] = {
@@ -25,6 +26,15 @@ .mode = 0644, .proc_handler = proc_douintvec, }, + { + .procname = "smcr_buf_type", + .data = &init_net.smc.sysctl_smcr_buf_type, + .maxlen = sizeof(unsigned int), + .mode = 0644, + .proc_handler = proc_douintvec_minmax, + .extra1 = SYSCTL_ZERO, + .extra2 = SYSCTL_TWO, + }, { } };
@@ -49,6 +59,7 @@ int __net_init smc_sysctl_net_init(struct net *net) goto err_reg; net->smc.sysctl_autocorking_size =SMC_AUTOCORKING_DEFAULT_SIZE ; + net->smc.sysctl_smcr_buf_type =SMCR_PHYS_CONT_BUFS ;return 0 ;
Signature · 1 line
1.8.3.1
Wen Gu
reviewerPATCH v2 4/6 net/smc: Use sysctl-specified types of buffers in new link group
In reply to Wen GuThis patch introduces a new SMC-R specific element buf_type in struct smc_link_group, for recording the value of sysctl smcr_buf_type when link group is created.
New created link group will create and reuse buffers of the type specified by buf_type.
--- net/smc/smc_core.c | 1 + net/smc/smc_core.h | 1 + 2 files changed, 2 insertions(+)
net/smc/smc_core.c +1 -0
@@ -907,6 +907,7 @@ static int smc_lgr_create(struct smc_sock *smc, struct smc_init_info *ini) lgr->net =smc_ib_net (lnk->smcibdev); lgr_list = &smc_lgr_list.list; lgr_lock = &smc_lgr_list.lock; + lgr->buf_type = lgr->net->smc.sysctl_smcr_buf_type;atomic_inc (&lgr_cnt); } smc->conn.lgr = lgr;
net/smc/smc_core.h +1 -0
@@ -284,6 +284,7 @@ struct smc_link_group {/* used rtoken elements */ u8 next_link_id;enum smc_lgr_type type; +enum smcr_buf_type buf_type;/* redundancy state */ u8 pnet_id[SMC_MAX_PNETID_LEN +1 ];/* pnet id of this lgr */
Signature · 1 line
1.8.3.1
Wen Gu
reviewerPATCH v2 5/6 net/smc: Allow virtually contiguous sndbufs or RMBs for SMC-R
In reply to Wen GuOn long-running enterprise production servers, high-order contiguous memory pages are usually very rare and in most cases we can only get fragmented pages.
When replacing TCP with SMC-R in such production scenarios, attempting to allocate high-order physically contiguous sndbufs and RMBs may result in frequent memory compaction, which will cause unexpected hung issue and further stability risks.
So this patch is aimed to allow SMC-R link group to use virtually contiguous sndbufs and RMBs to avoid potential issues mentioned above. Whether to use physically or virtually contiguous buffers can be set by sysctl smcr_buf_type.
Note that using virtually contiguous buffers will bring an acceptable performance regression, which can be mainly divided into two parts:
1) regression in data path, which is brought by additional address translation of sndbuf by RNIC in Tx. But in general, translating address through MTT is fast.
Taking 256KB sndbuf and RMB as an example, the comparisons in qperf latency and bandwidth test with physically and virtually contiguous buffers are as follows:
- client:
smc_run taskset -c <cpu> qperf <server> -oo msg_size:1:64K:*2\
-t 5 -vu tcp_{bw|lat}
- server:
smc_run taskset -c <cpu> qperf
[latency]
msgsize tcp smcr smcr-use-virt-buf
1 11.17 us 7.56 us 7.51 us (-0.67%) 2 10.65 us 7.74 us 7.56 us (-2.31%) 4 11.11 us 7.52 us 7.59 us ( 0.84%) 8 10.83 us 7.55 us 7.51 us (-0.48%) 16 11.21 us 7.46 us 7.51 us ( 0.71%) 32 10.65 us 7.53 us 7.58 us ( 0.61%) 64 10.95 us 7.74 us 7.80 us ( 0.76%) 128 11.14 us 7.83 us 7.87 us ( 0.47%) 256 10.97 us 7.94 us 7.92 us (-0.28%) 512 11.23 us 7.94 us 8.20 us ( 3.25%) 1024 11.60 us 8.12 us 8.20 us ( 0.96%) 2048 14.04 us 8.30 us 8.51 us ( 2.49%) 4096 16.88 us 9.13 us 9.07 us (-0.64%) 8192 22.50 us 10.56 us 11.22 us ( 6.26%) 16384 28.99 us 12.88 us 13.83 us ( 7.37%) 32768 40.13 us 16.76 us 16.95 us ( 1.16%) 65536 68.70 us 24.68 us 24.85 us ( 0.68%) [bandwidth] msgsize tcp smcr smcr-use-virt-buf 1 1.65 MB/s 1.59 MB/s 1.53 MB/s (-3.88%) 2 3.32 MB/s 3.17 MB/s 3.08 MB/s (-2.67%) 4 6.66 MB/s 6.33 MB/s 6.09 MB/s (-3.85%) 8 13.67 MB/s 13.45 MB/s 11.97 MB/s (-10.99%) 16 25.36 MB/s 27.15 MB/s 24.16 MB/s (-11.01%) 32 48.22 MB/s 54.24 MB/s 49.41 MB/s (-8.89%) 64 106.79 MB/s 107.32 MB/s 99.05 MB/s (-7.71%) 128 210.21 MB/s 202.46 MB/s 201.02 MB/s (-0.71%) 256 400.81 MB/s 416.81 MB/s 393.52 MB/s (-5.59%) 512 746.49 MB/s 834.12 MB/s 809.99 MB/s (-2.89%) 1024 1292.33 MB/s 1641.96 MB/s 1571.82 MB/s (-4.27%) 2048 2007.64 MB/s 2760.44 MB/s 2717.68 MB/s (-1.55%) 4096 2665.17 MB/s 4157.44 MB/s 4070.76 MB/s (-2.09%) 8192 3159.72 MB/s 4361.57 MB/s 4270.65 MB/s (-2.08%) 16384 4186.70 MB/s 4574.13 MB/s 4501.17 MB/s (-1.60%) 32768 4093.21 MB/s 4487.42 MB/s 4322.43 MB/s (-3.68%) 65536 4057.14 MB/s 4735.61 MB/s 4555.17 MB/s (-3.81%)
2) regression in buffer initialization and destruction path, which is brought by additional MR operations of sndbufs. But thanks to link group buffer reuse mechanism, the impact of this kind of regression decreases as times of buffer reuse increases.
Taking 256KB sndbuf and RMB as an example, latency of some key SMC-R buffer-related function obtained by bpftrace are as follows:
Function Phys-bufs Virt-bufs
smcr_new_buf_create() 67154 ns 79164 ns
smc_ib_buf_map_sg() 525 ns 928 ns
smc_ib_get_memory_region() 162294 ns 161191 ns
smc_wr_reg_send() 9957 ns 9635 ns
smc_ib_put_memory_region() 203548 ns 198374 ns
smc_ib_buf_unmap_sg() 508 ns 1158 ns
------------
Test environment notes:
1. Above tests run on 2 VMs within the same Host.
2. The NIC is ConnectX-4Lx, using SRIOV and passing through 2 VFs to the each VM respectively.
3. VMs' vCPUs are binded to different physical CPUs, and the binded physical CPUs are isolated by isolcpus=xxx cmdline.
4. NICs' queue number are set to 1.
--- net/smc/af_smc.c | 66 +++++++++++++++-- net/smc/smc_clc.c | 8 +- net/smc/smc_clc.h | 2 +- net/smc/smc_core.c | 213 +++++++++++++++++++++++++++++++++++++---------------- net/smc/smc_core.h | 10 ++- net/smc/smc_ib.c | 15 ++-- net/smc/smc_llc.c | 33 +++++---- net/smc/smc_rx.c | 90 ++++++++++++++++++---- net/smc/smc_tx.c | 9 ++- 9 files changed, 328 insertions(+), 118 deletions(-)
net/smc/af_smc.c +58 -8
@@ -487,6 +487,29 @@ static void smc_copy_sock_settings_to_smc(struct smc_sock *smc)smc_copy_sock_settings (&smc->sk, smc->clcsock->sk,SK_FLAGS_CLC_TO_SMC ); } +/* register the new vzalloced sndbuf on all links */ +static int smcr_lgr_reg_sndbufs (struct smc_link *link, +struct smc_buf_desc *snd_desc) +{ +struct smc_link_group *lgr = link->lgr; +int i, rc =0 ; + +if (!snd_desc->is_vm) +return -EINVAL ; + +/* protect against parallel smcr_link_reg_buf() */ +mutex_lock (&lgr->llc_conf_mutex); +for (i =0 ; i <SMC_LINKS_PER_LGR_MAX ; i++) { +if (!smc_link_active (&lgr->lnk[i])) +continue ; + rc =smcr_link_reg_buf (&lgr->lnk[i], snd_desc); +if (rc) +break ; + } +mutex_unlock (&lgr->llc_conf_mutex); +return rc; +} +/* register the new rmb on all links */ static int smcr_lgr_reg_rmbs (struct smc_link *link,struct smc_buf_desc *rmb_desc)
@@ -498,13 +521,13 @@ static int smcr_lgr_reg_rmbs(struct smc_link *link,if (rc)return rc;/* protect against parallel smc_llc_cli_rkey_exchange() and -* parallel smcr_link_reg_rmb() +* parallel smcr_link_reg_buf() */ mutex_lock (&lgr->llc_conf_mutex);for (i =0 ; i <SMC_LINKS_PER_LGR_MAX ; i++) {if (!smc_link_active (&lgr->lnk[i]))continue ; - rc =smcr_link_reg_rmb (&lgr->lnk[i], rmb_desc); + rc =smcr_link_reg_buf (&lgr->lnk[i], rmb_desc);if (rc) goto out; }
@@ -550,8 +573,15 @@ static int smcr_clnt_conf_first_link(struct smc_sock *smc)smc_wr_remember_qp_attr (link); -if (smcr_link_reg_rmb (link, smc->conn.rmb_desc)) -return SMC_CLC_DECL_ERR_REGRMB ; +/* reg the sndbuf if it was vzalloced */ +if (smc->conn.sndbuf_desc->is_vm) { +if (smcr_link_reg_buf (link, smc->conn.sndbuf_desc)) +return SMC_CLC_DECL_ERR_REGBUF ; + } + +/* reg the rmb */ +if (smcr_link_reg_buf (link, smc->conn.rmb_desc)) +return SMC_CLC_DECL_ERR_REGBUF ;/* confirm_rkey is implicit on 1st contact */ smc->conn.rmb_desc->is_conf_rkey = true;
@@ -1221,8 +1251,15 @@ static int smc_connect_rdma(struct smc_sock *smc, goto connect_abort; } }else { +/* reg sendbufs if they were vzalloced */ +if (smc->conn.sndbuf_desc->is_vm) { +if (smcr_lgr_reg_sndbufs (link, smc->conn.sndbuf_desc)) { + reason_code =SMC_CLC_DECL_ERR_REGBUF ; + goto connect_abort; + } + }if (smcr_lgr_reg_rmbs (link, smc->conn.rmb_desc)) { - reason_code =SMC_CLC_DECL_ERR_REGRMB ; + reason_code =SMC_CLC_DECL_ERR_REGBUF ; goto connect_abort; } }
@@ -1749,8 +1786,15 @@ static int smcr_serv_conf_first_link(struct smc_sock *smc)struct smc_llc_qentry *qentry;int rc; -if (smcr_link_reg_rmb (link, smc->conn.rmb_desc)) -return SMC_CLC_DECL_ERR_REGRMB ; +/* reg the sndbuf if it was vzalloced*/ +if (smc->conn.sndbuf_desc->is_vm) { +if (smcr_link_reg_buf (link, smc->conn.sndbuf_desc)) +return SMC_CLC_DECL_ERR_REGBUF ; + } + +/* reg the rmb */ +if (smcr_link_reg_buf (link, smc->conn.rmb_desc)) +return SMC_CLC_DECL_ERR_REGBUF ;/* send CONFIRM LINK request to client over the RoCE fabric */ rc =smc_llc_send_confirm_link (link,SMC_LLC_REQ );
@@ -2109,8 +2153,14 @@ static int smc_listen_rdma_reg(struct smc_sock *new_smc, bool local_first)struct smc_connection *conn = &new_smc->conn;if (!local_first) { +/* reg sendbufs if they were vzalloced */ +if (conn->sndbuf_desc->is_vm) { +if (smcr_lgr_reg_sndbufs (conn->lnk, + conn->sndbuf_desc)) +return SMC_CLC_DECL_ERR_REGBUF ; + }if (smcr_lgr_reg_rmbs (conn->lnk, conn->rmb_desc)) -return SMC_CLC_DECL_ERR_REGRMB ; +return SMC_CLC_DECL_ERR_REGBUF ; }return 0 ;
net/smc/smc_clc.c +5 -3
@@ -1034,7 +1034,7 @@ static int smc_clc_send_confirm_accept(struct smc_sock *smc, ETH_ALEN);hton24 (clc->r0.qpn, link->roce_qp->qp_num); clc->r0.rmb_rkey = -htonl (conn->rmb_desc->mr_rx[link->link_idx]->rkey); +htonl (conn->rmb_desc->mr[link->link_idx]->rkey); clc->r0.rmbe_idx =1 ;/* for now: 1 RMB = 1 RMBE */ clc->r0.rmbe_alert_token =htonl (conn->alert_token_local);switch (clc->hdr.type) {
@@ -1046,8 +1046,10 @@ static int smc_clc_send_confirm_accept(struct smc_sock *smc,break ; } clc->r0.rmbe_size = conn->rmbe_size_short; - clc->r0.rmb_dma_addr =cpu_to_be64 ((u64 )sg_dma_address - (conn->rmb_desc->sgt[link->link_idx].sgl)); + clc->r0.rmb_dma_addr = conn->rmb_desc->is_vm ? +cpu_to_be64 ((uintptr_t )conn->rmb_desc->cpu_addr) : +cpu_to_be64 ((u64 )sg_dma_address + (conn->rmb_desc->sgt[link->link_idx].sgl));hton24 (clc->r0.psn, link->psn_initial);if (version ==SMC_V1 ) { clc->hdr.length =htons (SMCR_CLC_ACCEPT_CONFIRM_LEN );
net/smc/smc_clc.h +1 -1
@@ -62,7 +62,7 @@#define SMC_CLC_DECL_INTERR 0x09990000/* internal error */ #define SMC_CLC_DECL_ERR_RTOK 0x09990001/* rtoken handling failed */ #define SMC_CLC_DECL_ERR_RDYLNK 0x09990002/* ib ready link failed */ -#define SMC_CLC_DECL_ERR_REGRMB 0x09990003/* reg rmb failed */ +#define SMC_CLC_DECL_ERR_REGBUF 0x09990003/* reg rdma bufs failed */ #define SMC_FIRST_CONTACT_MASK 0b10/* first contact bit within typev2 */
net/smc/smc_core.c +149 -64
330 lines not on this page · raw message
net/smc/smc_core.h +7 -3
@@ -168,9 +168,11 @@ struct smc_buf_desc {struct {/* SMC-R */ struct sg_table sgt[SMC_LINKS_PER_LGR_MAX ];/* virtual buffer */ -struct ib_mr *mr_rx[SMC_LINKS_PER_LGR_MAX ]; -/* for rmb only: memory region +struct ib_mr *mr[SMC_LINKS_PER_LGR_MAX ]; +/* memory region: for rmb and +* vzalloced sndbuf * incl. rkey provided to peer +* and lkey provided to local */ u32 order;/* allocation order */
@@ -183,6 +185,8 @@ struct smc_buf_desc {u8 is_dma_need_sync;u8 is_reg_err;/* buffer registration err */ +u8 is_vm; +/* virtually contiguous */ };struct {/* SMC-D */ unsigned short sba_idx;
@@ -543,7 +547,7 @@ void smc_switch_link_and_count(struct smc_connection *conn,void smcr_lgr_set_type (struct smc_link_group *lgr,enum smc_lgr_type new_type);void smcr_lgr_set_type_asym (struct smc_link_group *lgr,enum smc_lgr_type new_type,int asym_lnk_idx); -int smcr_link_reg_rmb (struct smc_link *link,struct smc_buf_desc *rmb_desc); +int smcr_link_reg_buf (struct smc_link *link,struct smc_buf_desc *rmb_desc);struct smc_link *smc_switch_conns (struct smc_link_group *lgr,struct smc_link *from_lnk,bool is_dev_err);void smcr_link_down_cond (struct smc_link *lnk);
net/smc/smc_ib.c +8 -7
@@ -698,7 +698,7 @@ static int smc_ib_map_mr_sg(struct smc_buf_desc *buf_slot, u8 link_idx)int sg_num;/* map the largest prefix of a dma mapped SG list */ - sg_num =ib_map_mr_sg (buf_slot->mr_rx[link_idx], + sg_num =ib_map_mr_sg (buf_slot->mr[link_idx], buf_slot->sgt[link_idx].sgl, buf_slot->sgt[link_idx].orig_nents, &offset,PAGE_SIZE );
@@ -710,20 +710,21 @@ static int smc_ib_map_mr_sg(struct smc_buf_desc *buf_slot, u8 link_idx)int smc_ib_get_memory_region (struct ib_pd *pd,int access_flags,struct smc_buf_desc *buf_slot,u8 link_idx) { -if (buf_slot->mr_rx[link_idx]) +if (buf_slot->mr[link_idx])return 0 ;/* already done */ - buf_slot->mr_rx[link_idx] = + buf_slot->mr[link_idx] =ib_alloc_mr (pd,IB_MR_TYPE_MEM_REG ,1 << buf_slot->order); -if (IS_ERR (buf_slot->mr_rx[link_idx])) { +if (IS_ERR (buf_slot->mr[link_idx])) {int rc; - rc =PTR_ERR (buf_slot->mr_rx[link_idx]); - buf_slot->mr_rx[link_idx] =NULL ; + rc =PTR_ERR (buf_slot->mr[link_idx]); + buf_slot->mr[link_idx] =NULL ;return rc; } -if (smc_ib_map_mr_sg (buf_slot, link_idx) !=1 ) +if (smc_ib_map_mr_sg (buf_slot, link_idx) != + buf_slot->sgt[link_idx].orig_nents)return -EINVAL ;return 0 ;
net/smc/smc_llc.c +19 -14
@@ -505,19 +505,22 @@ static int smc_llc_send_confirm_rkey(struct smc_link *send_link,if (smc_link_active (link) && link != send_link) { rkeyllc->rtoken[rtok_ix].link_id = link->link_id; rkeyllc->rtoken[rtok_ix].rmb_key = -htonl (rmb_desc->mr_rx[link->link_idx]->rkey); - rkeyllc->rtoken[rtok_ix].rmb_vaddr =cpu_to_be64 ( - (u64 )sg_dma_address ( - rmb_desc->sgt[link->link_idx].sgl)); +htonl (rmb_desc->mr[link->link_idx]->rkey); + rkeyllc->rtoken[rtok_ix].rmb_vaddr = rmb_desc->is_vm ? +cpu_to_be64 ((uintptr_t )rmb_desc->cpu_addr) : +cpu_to_be64 ((u64 )sg_dma_address + (rmb_desc->sgt[link->link_idx].sgl)); rtok_ix++; } }/* rkey of send_link is in rtoken[0] */ rkeyllc->rtoken[0 ].num_rkeys = rtok_ix -1 ; rkeyllc->rtoken[0 ].rmb_key = -htonl (rmb_desc->mr_rx[send_link->link_idx]->rkey); - rkeyllc->rtoken[0 ].rmb_vaddr =cpu_to_be64 ( - (u64 )sg_dma_address (rmb_desc->sgt[send_link->link_idx].sgl)); +htonl (rmb_desc->mr[send_link->link_idx]->rkey); + rkeyllc->rtoken[0 ].rmb_vaddr = rmb_desc->is_vm ? +cpu_to_be64 ((uintptr_t )rmb_desc->cpu_addr) : +cpu_to_be64 ((u64 )sg_dma_address + (rmb_desc->sgt[send_link->link_idx].sgl));/* send llc message */ rc =smc_wr_tx_send (send_link, pend); put_out:
@@ -544,7 +547,7 @@ static int smc_llc_send_delete_rkey(struct smc_link *link, rkeyllc->hd.common.llc_type =SMC_LLC_DELETE_RKEY ;smc_llc_init_msg_hdr (&rkeyllc->hd, link->lgr,sizeof (*rkeyllc)); rkeyllc->num_rkeys =1 ; - rkeyllc->rkey[0 ] =htonl (rmb_desc->mr_rx[link->link_idx]->rkey); + rkeyllc->rkey[0 ] =htonl (rmb_desc->mr[link->link_idx]->rkey);/* send llc message */ rc =smc_wr_tx_send (link, pend); put_out:
@@ -614,9 +617,10 @@ static int smc_llc_fill_ext_v2(struct smc_llc_msg_add_link_v2_ext *ext,if (!buf_pos)break ; rmb = buf_pos; - ext->rt[i].rmb_key =htonl (rmb->mr_rx[prim_lnk_idx]->rkey); - ext->rt[i].rmb_key_new =htonl (rmb->mr_rx[lnk_idx]->rkey); - ext->rt[i].rmb_vaddr_new = + ext->rt[i].rmb_key =htonl (rmb->mr[prim_lnk_idx]->rkey); + ext->rt[i].rmb_key_new =htonl (rmb->mr[lnk_idx]->rkey); + ext->rt[i].rmb_vaddr_new = rmb->is_vm ? +cpu_to_be64 ((uintptr_t )rmb->cpu_addr) :cpu_to_be64 ((u64 )sg_dma_address (rmb->sgt[lnk_idx].sgl)); buf_pos =smc_llc_get_next_rmb (lgr, &buf_lst, buf_pos);while (buf_pos && !(buf_pos)->used)
@@ -852,9 +856,10 @@ static int smc_llc_add_link_cont(struct smc_link *link, } rmb = *buf_pos; - addc_llc->rt[i].rmb_key =htonl (rmb->mr_rx[prim_lnk_idx]->rkey); - addc_llc->rt[i].rmb_key_new =htonl (rmb->mr_rx[lnk_idx]->rkey); - addc_llc->rt[i].rmb_vaddr_new = + addc_llc->rt[i].rmb_key =htonl (rmb->mr[prim_lnk_idx]->rkey); + addc_llc->rt[i].rmb_key_new =htonl (rmb->mr[lnk_idx]->rkey); + addc_llc->rt[i].rmb_vaddr_new = rmb->is_vm ? +cpu_to_be64 ((uintptr_t )rmb->cpu_addr) :cpu_to_be64 ((u64 )sg_dma_address (rmb->sgt[lnk_idx].sgl)); (*num_rkeys_todo)--;
net/smc/smc_rx.c +74 -16
109 lines not on this page · raw message
net/smc/smc_tx.c +7 -2
@@ -383,6 +383,7 @@ static int smcr_tx_rdma_writes(struct smc_connection *conn, size_t len,dma_addr_t dma_addr =sg_dma_address (conn->sndbuf_desc->sgt[link->link_idx].sgl); +u64 virt_addr = (uintptr_t )conn->sndbuf_desc->cpu_addr;int src_len_sum = src_len, dst_len_sum = dst_len;int sent_count = src_off;int srcchunk, dstchunk;
@@ -395,7 +396,7 @@ static int smcr_tx_rdma_writes(struct smc_connection *conn, size_t len,u64 base_addr = dma_addr;if (dst_len < link->qp_attr.cap.max_inline_data) { - base_addr = (uintptr_t )conn->sndbuf_desc->cpu_addr; + base_addr = virt_addr; wr->wr.send_flags |=IB_SEND_INLINE ; }else { wr->wr.send_flags &= ~IB_SEND_INLINE ;
@@ -403,8 +404,12 @@ static int smcr_tx_rdma_writes(struct smc_connection *conn, size_t len, num_sges =0 ;for (srcchunk =0 ; srcchunk <2 ; srcchunk++) { - sge[srcchunk].addr = base_addr + src_off; + sge[srcchunk].addr = conn->sndbuf_desc->is_vm ? + (virt_addr + src_off) : (base_addr + src_off); sge[srcchunk].length = src_len; +if (conn->sndbuf_desc->is_vm) + sge[srcchunk].lkey = + conn->sndbuf_desc->mr[link->link_idx]->lkey; num_sges++; src_off += src_len;
Signature · 1 line
1.8.3.1
Wen Gu
reviewerPATCH v2 6/6 net/smc: Extend SMC-R link group netlink attribute
In reply to Wen GuExtend SMC-R link group netlink attribute SMC_GEN_LGR_SMCR. Introduce SMC_NLA_LGR_R_BUF_TYPE to show the buffer type of SMC-R link group.
--- include/uapi/linux/smc.h | 1 + net/smc/smc_core.c | 2 ++ 2 files changed, 3 insertions(+)
include/uapi/linux/smc.h +1 -0
@@ -124,6 +124,7 @@ enum {SMC_NLA_LGR_R_V2 ,/* nest */ SMC_NLA_LGR_R_NET_COOKIE ,/* u64 */ SMC_NLA_LGR_R_PAD ,/* flag */ +SMC_NLA_LGR_R_BUF_TYPE ,/* u8 */ __SMC_NLA_LGR_R_MAX, SMC_NLA_LGR_R_MAX = __SMC_NLA_LGR_R_MAX - 1 };
net/smc/smc_core.c +2 -0
@@ -347,6 +347,8 @@ static int smc_nl_fill_lgr(struct smc_link_group *lgr, goto errattr;if (nla_put_u8 (skb,SMC_NLA_LGR_R_TYPE , lgr->type)) goto errattr; +if (nla_put_u8 (skb,SMC_NLA_LGR_R_BUF_TYPE , lgr->buf_type)) + goto errattr;if (nla_put_u8 (skb,SMC_NLA_LGR_R_VLAN_ID , lgr->vlan_id)) goto errattr; if (nla_put_u64_64bit(skb, SMC_NLA_LGR_R_NET_COOKIE,
Signature · 1 line
1.8.3.1
Quoted 53 lines · Wen Gu
On long-running enterprise production servers, high-order contiguous memory pages are usually very rare and in most cases we can only get fragmented pages.
When replacing TCP with SMC-R in such production scenarios, attempting to allocate high-order physically contiguous sndbufs and RMBs may result in frequent memory compaction, which will cause unexpected hung issue and further stability risks.
So this patch set is aimed to allow SMC-R link group to use virtually contiguous sndbufs and RMBs to avoid potential issues mentioned above. Whether to use physically or virtually contiguous buffers can be set by sysctl
smcr_buf_type.Note that using virtually contiguous buffers will bring an acceptable performance regression, which can be mainly divided into two parts:
1) regression in data path, which is brought by additional address translation of sndbuf by RNIC in Tx. But in general, translating address through MTT is fast. According to qperf test, this part regression is basically less than 10% in latency and bandwidth. (see patch 5/6 for details)
2) regression in buffer initialization and destruction path, which is brought by additional MR operations of sndbufs. But thanks to link group buffer reuse mechanism, the impact of this kind of regression decreases as times of buffer reuse increases.
Patch set overview:
- Patch 1/6 and 2/6 mainly about simplifying and optimizing DMA sync operation, which will reduce overhead on the data path, especially when using virtually contiguous buffers;
- Patch 3/6 and 4/6 introduce a sysctlsmcr_buf_typeto set the type of buffers in new created link group;
- Patch 5/6 allows SMC-R to use virtually contiguous sndbufs and RMBs, including buffer creation, destruction, MR operation and access;
- patch 6/6 extends netlink attribute for buffer type of SMC-R link group;
v1->v2:
- Patch 5/6 fixes build issue on 32bit;
- Patch 3/6 adds description of new sysctl insmc-sysctl.rst;Guangguan Wang (2):
net/smc: remove redundant dma sync ops net/smc: optimize forsmc_sndbuf_sync_sg_for_deviceand
smc_rmb_sync_sg_for_cpuWen Gu (4):
net/smc: Introduce a sysctl for setting SMC-R buffer type net/smc: Use sysctl-specified types of buffers in new link group net/smc: Allow virtually contiguous sndbufs or RMBs for SMC-R net/smc: Extend SMC-R link group netlink attribute
Quoted 16 lines
Documentation/networking/smc-sysctl.rst | 13 ++ include/net/netns/smc.h | 1 + include/uapi/linux/smc.h | 1 + net/smc/af_smc.c | 68 +++++++-- net/smc/smc_clc.c | 8 +- net/smc/smc_clc.h | 2 +- net/smc/smc_core.c | 246 +++++++++++++++++++++----------- net/smc/smc_core.h | 20 ++- net/smc/smc_ib.c | 44 +++++- net/smc/smc_ib.h | 2 + net/smc/smc_llc.c | 33 +++-- net/smc/smc_rx.c | 92 +++++++++--- net/smc/smc_sysctl.c | 11 ++ net/smc/smc_tx.c | 10 +- 14 files changed, 404 insertions(+), 147 deletions(-)
This idea is very cool! Thank you for your effort! But we still need to verify if this solution can run well on our system. I'll come to you soon.
Tony Lu
reviewerQuoted 72 lines · Wenjia Zhang
Quoted 53 lines · Wen Gu
On long-running enterprise production servers, high-order contiguous memory pages are usually very rare and in most cases we can only get fragmented pages.
When replacing TCP with SMC-R in such production scenarios, attempting to allocate high-order physically contiguous sndbufs and RMBs may result in frequent memory compaction, which will cause unexpected hung issue and further stability risks.
So this patch set is aimed to allow SMC-R link group to use virtually contiguous sndbufs and RMBs to avoid potential issues mentioned above. Whether to use physically or virtually contiguous buffers can be set by sysctl
smcr_buf_type.Note that using virtually contiguous buffers will bring an acceptable performance regression, which can be mainly divided into two parts:
1) regression in data path, which is brought by additional address translation of sndbuf by RNIC in Tx. But in general, translating address through MTT is fast. According to qperf test, this part regression is basically less than 10% in latency and bandwidth. (see patch 5/6 for details)
2) regression in buffer initialization and destruction path, which is brought by additional MR operations of sndbufs. But thanks to link group buffer reuse mechanism, the impact of this kind of regression decreases as times of buffer reuse increases.
Patch set overview:
- Patch 1/6 and 2/6 mainly about simplifying and optimizing DMA sync operation, which will reduce overhead on the data path, especially when using virtually contiguous buffers;
- Patch 3/6 and 4/6 introduce a sysctlsmcr_buf_typeto set the type of buffers in new created link group;
- Patch 5/6 allows SMC-R to use virtually contiguous sndbufs and RMBs, including buffer creation, destruction, MR operation and access;
- patch 6/6 extends netlink attribute for buffer type of SMC-R link group;
v1->v2:
- Patch 5/6 fixes build issue on 32bit;
- Patch 3/6 adds description of new sysctl insmc-sysctl.rst;Guangguan Wang (2):
net/smc: remove redundant dma sync ops net/smc: optimize forsmc_sndbuf_sync_sg_for_deviceand
smc_rmb_sync_sg_for_cpuWen Gu (4):
net/smc: Introduce a sysctl for setting SMC-R buffer type net/smc: Use sysctl-specified types of buffers in new link group net/smc: Allow virtually contiguous sndbufs or RMBs for SMC-R net/smc: Extend SMC-R link group netlink attributeQuoted 16 lines
Documentation/networking/smc-sysctl.rst | 13 ++ include/net/netns/smc.h | 1 + include/uapi/linux/smc.h | 1 + net/smc/af_smc.c | 68 +++++++-- net/smc/smc_clc.c | 8 +- net/smc/smc_clc.h | 2 +- net/smc/smc_core.c | 246 +++++++++++++++++++++----------- net/smc/smc_core.h | 20 ++- net/smc/smc_ib.c | 44 +++++- net/smc/smc_ib.h | 2 + net/smc/smc_llc.c | 33 +++-- net/smc/smc_rx.c | 92 +++++++++--- net/smc/smc_sysctl.c | 11 ++ net/smc/smc_tx.c | 10 +- 14 files changed, 404 insertions(+), 147 deletions(-)
Quoted 2 lines
This idea is very cool! Thank you for your effort! But we still need to verify if this solution can run well on our system. I'll come to you soon.
Hi Wenjia,
We have noticed that SMC community is becoming more active recently. More and more companies have shown their interests in SMC. Correspondingly, patches are also increasing. We (Alibaba) are trying to apply SMC into cloud production environment, extending its abilities and enhancing the performance. We also contributed some work to community in the past period of time. So we are more than happy to help review SMC patches together. If you need, we are very glad to be reviewers to share the review work.
Hope to hear from you, thank you.
Best wishes,
Tony Lu
Quoted 87 lines · Tony Lu
Quoted 72 lines · Wenjia Zhang
Quoted 53 lines · Wen Gu
On long-running enterprise production servers, high-order contiguous memory pages are usually very rare and in most cases we can only get fragmented pages.
When replacing TCP with SMC-R in such production scenarios, attempting to allocate high-order physically contiguous sndbufs and RMBs may result in frequent memory compaction, which will cause unexpected hung issue and further stability risks.
So this patch set is aimed to allow SMC-R link group to use virtually contiguous sndbufs and RMBs to avoid potential issues mentioned above. Whether to use physically or virtually contiguous buffers can be set by sysctl
smcr_buf_type.Note that using virtually contiguous buffers will bring an acceptable performance regression, which can be mainly divided into two parts:
1) regression in data path, which is brought by additional address translation of sndbuf by RNIC in Tx. But in general, translating address through MTT is fast. According to qperf test, this part regression is basically less than 10% in latency and bandwidth. (see patch 5/6 for details)
2) regression in buffer initialization and destruction path, which is brought by additional MR operations of sndbufs. But thanks to link group buffer reuse mechanism, the impact of this kind of regression decreases as times of buffer reuse increases.
Patch set overview:
- Patch 1/6 and 2/6 mainly about simplifying and optimizing DMA sync operation, which will reduce overhead on the data path, especially when using virtually contiguous buffers;
- Patch 3/6 and 4/6 introduce a sysctlsmcr_buf_typeto set the typeof buffers in new created link group; - Patch 5/6 allows SMC-R to use virtually contiguous sndbufs and RMBs, including buffer creation, destruction, MR operation and access;- patch 6/6 extends netlink attribute for buffer type of SMC-R link group;
v1->v2:
- Patch 5/6 fixes build issue on 32bit;
- Patch 3/6 adds description of new sysctl insmc-sysctl.rst;Guangguan Wang (2):
net/smc: remove redundant dma sync ops net/smc: optimize forsmc_sndbuf_sync_sg_for_deviceand
smc_rmb_sync_sg_for_cpuWen Gu (4):
net/smc: Introduce a sysctl for setting SMC-R buffer type net/smc: Use sysctl-specified types of buffers in new link group net/smc: Allow virtually contiguous sndbufs or RMBs for SMC-R net/smc: Extend SMC-R link group netlink attributeQuoted 16 lines
Documentation/networking/smc-sysctl.rst | 13 ++ include/net/netns/smc.h | 1 + include/uapi/linux/smc.h | 1 + net/smc/af_smc.c | 68 +++++++-- net/smc/smc_clc.c | 8 +- net/smc/smc_clc.h | 2 +- net/smc/smc_core.c | 246 +++++++++++++++++++++----------- net/smc/smc_core.h | 20 ++- net/smc/smc_ib.c | 44 +++++- net/smc/smc_ib.h | 2 + net/smc/smc_llc.c | 33 +++-- net/smc/smc_rx.c | 92 +++++++++--- net/smc/smc_sysctl.c | 11 ++ net/smc/smc_tx.c | 10 +- 14 files changed, 404 insertions(+), 147 deletions(-)Quoted 2 lines
This idea is very cool! Thank you for your effort! But we still need to verify if this solution can run well on our system. I'll come to you soon.
Hi Wenjia,
We have noticed that SMC community is becoming more active recently. More and more companies have shown their interests in SMC. Correspondingly, patches are also increasing. We (Alibaba) are trying to apply SMC into cloud production environment, extending its abilities and enhancing the performance. We also contributed some work to community in the past period of time. So we are more than happy to help review SMC patches together. If you need, we are very glad to be reviewers to share the review work.
Quoted 4 lines
Hope to hear from you, thank you.
Best wishes,
Tony Lu
Hi Tony,
That is very nice to hear that from you. It would be great for us. If you like, feel free to add your sign after the review. Thank you!
Best regards
Wenjia Zhang
This series was applied to netdev/net-next.git (master) by David S. Miller <[email protected]>:
Hello:
This series was applied to netdev/net-next.git (master) by David S. Miller <[email protected]>:
Quoted 10 lines · On Thu, 14 Jul 2022 17:43:59 +0800 you wrote:
On long-running enterprise production servers, high-order contiguous memory pages are usually very rare and in most cases we can only get fragmented pages.
When replacing TCP with SMC-R in such production scenarios, attempting to allocate high-order physically contiguous sndbufs and RMBs may result in frequent memory compaction, which will cause unexpected hung issue and further stability risks.
[...]
Here is the summary with links:
- [net-next,v2,1/6] net/smc: remove redundant dma sync ops
https://git.kernel.org/netdev/net-next/c/6d52e2de6415 - [net-next,v2,2/6] net/smc: optimize for smc_sndbuf_sync_sg_for_device and smc_rmb_sync_sg_for_cpu https://git.kernel.org/netdev/net-next/c/0ef69e788411 - [net-next,v2,3/6] net/smc: Introduce a sysctl for setting SMC-R buffer type https://git.kernel.org/netdev/net-next/c/4bc5008e4387 - [net-next,v2,4/6] net/smc: Use sysctl-specified types of buffers in new link group https://git.kernel.org/netdev/net-next/c/b984f370ed51 - [net-next,v2,5/6] net/smc: Allow virtually contiguous sndbufs or RMBs for SMC-R https://git.kernel.org/netdev/net-next/c/b8d199451c99 - [net-next,v2,6/6] net/smc: Extend SMC-R link group netlink attribute https://git.kernel.org/netdev/net-next/c/ddefb2d20553
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html
Quoted 53 lines · Wen Gu
On long-running enterprise production servers, high-order contiguous memory pages are usually very rare and in most cases we can only get fragmented pages.
When replacing TCP with SMC-R in such production scenarios, attempting to allocate high-order physically contiguous sndbufs and RMBs may result in frequent memory compaction, which will cause unexpected hung issue and further stability risks.
So this patch set is aimed to allow SMC-R link group to use virtually contiguous sndbufs and RMBs to avoid potential issues mentioned above. Whether to use physically or virtually contiguous buffers can be set by sysctl
smcr_buf_type.Note that using virtually contiguous buffers will bring an acceptable performance regression, which can be mainly divided into two parts:
1) regression in data path, which is brought by additional address translation of sndbuf by RNIC in Tx. But in general, translating address through MTT is fast. According to qperf test, this part regression is basically less than 10% in latency and bandwidth. (see patch 5/6 for details)
2) regression in buffer initialization and destruction path, which is brought by additional MR operations of sndbufs. But thanks to link group buffer reuse mechanism, the impact of this kind of regression decreases as times of buffer reuse increases.
Patch set overview:
- Patch 1/6 and 2/6 mainly about simplifying and optimizing DMA sync operation, which will reduce overhead on the data path, especially when using virtually contiguous buffers;
- Patch 3/6 and 4/6 introduce a sysctlsmcr_buf_typeto set the type of buffers in new created link group;
- Patch 5/6 allows SMC-R to use virtually contiguous sndbufs and RMBs, including buffer creation, destruction, MR operation and access;
- patch 6/6 extends netlink attribute for buffer type of SMC-R link group;
v1->v2:
- Patch 5/6 fixes build issue on 32bit;
- Patch 3/6 adds description of new sysctl insmc-sysctl.rst;Guangguan Wang (2):
net/smc: remove redundant dma sync ops net/smc: optimize forsmc_sndbuf_sync_sg_for_deviceand
smc_rmb_sync_sg_for_cpuWen Gu (4):
net/smc: Introduce a sysctl for setting SMC-R buffer type net/smc: Use sysctl-specified types of buffers in new link group net/smc: Allow virtually contiguous sndbufs or RMBs for SMC-R net/smc: Extend SMC-R link group netlink attribute
Quoted 16 lines
Documentation/networking/smc-sysctl.rst | 13 ++ include/net/netns/smc.h | 1 + include/uapi/linux/smc.h | 1 + net/smc/af_smc.c | 68 +++++++-- net/smc/smc_clc.c | 8 +- net/smc/smc_clc.h | 2 +- net/smc/smc_core.c | 246 +++++++++++++++++++++----------- net/smc/smc_core.h | 20 ++- net/smc/smc_ib.c | 44 +++++- net/smc/smc_ib.h | 2 + net/smc/smc_llc.c | 33 +++-- net/smc/smc_rx.c | 92 +++++++++--- net/smc/smc_sysctl.c | 11 ++ net/smc/smc_tx.c | 10 +- 14 files changed, 404 insertions(+), 147 deletions(-)
It looks good for us. Thank you!