xprtrdma: Reduce the number of hardway buffer allocations (65866f82) · Commits · 戴 / test

While marshaling an RPC/RDMA request, the inline_{rsize,wsize} settings determine whether an inline request is used, or whether read or write chunks lists are built. The current default value of these settings is 1024. Any RPC request smaller than 1024 bytes is sent to the NFS server completely inline. rpcrdma_buffer_create() allocates and pre-registers a set of RPC buffers for each transport instance, also based on the inline rsize and wsize settings. RPC/RDMA requests and replies are built in these buffers. However, if an RPC/RDMA request is expected to be larger than 1024, a buffer has to be allocated and registered for that RPC, and deregistered and released when the RPC is complete. This is known has a "hardway allocation." Since the introduction of NFSv4, the size of RPC requests has become larger, and hardway allocations are thus more frequent. Hardway allocations are significant overhead, and they waste the existing RPC buffers pre-allocated by rpcrdma_buffer_create(). We'd like fewer hardway allocations. Increasing the size of the pre-registered buffers is the most direct way to do this. However, a blanket increase of the inline thresholds has interoperability consequences. On my 64-bit system, rpcrdma_buffer_create() requests roughly 7000 bytes for each RPC request buffer, using kmalloc(). Due to internal fragmentation, this wastes nearly 1200 bytes because kmalloc() already returns an 8192-byte piece of memory for a 7000-byte allocation request, though the extra space remains unused. So let's round up the size of the pre-allocated buffers, and make use of the unused space in the kmalloc'd memory. This change reduces the amount of hardway allocated memory for an NFSv4 general connectathon run from 1322092 to 9472 bytes (99%). Signed-off-by:

Chuck Lever <chuck.lever@oracle.com> Tested-by:

Steve Wise <swise@opengridcomputing.com> Signed-off-by:

Anna Schumaker <Anna.Schumaker@Netapp.com>

net/sunrpc/xprtrdma/verbs.c

+13 −12

Original line number	Diff line number	Diff line
		@@ -50,6 +50,7 @@
		#include <linux/interrupt.h>
		#include <linux/pci.h> /* for Tavor hack below */
		#include <linux/slab.h>
		#include <asm/bitops.h>

		#include "xprt_rdma.h"

		@@ -1005,7 +1006,7 @@ rpcrdma_buffer_create(struct rpcrdma_buffer buf, struct rpcrdma_ep ep,
		struct rpcrdma_ia ia, struct rpcrdma_create_data_internal cdata)
		{
		char *p;
		size_t len;
		size_t len, rlen, wlen;
		int i, rc;
		struct rpcrdma_mw *r;

		@@ -1120,16 +1121,16 @@ rpcrdma_buffer_create(struct rpcrdma_buffer buf, struct rpcrdma_ep ep,
		* Allocate/init the request/reply buffers. Doing this
		* using kmalloc for now -- one for each buf.
		*/
		wlen = 1 << fls(cdata->inline_wsize + sizeof(struct rpcrdma_req));
		rlen = 1 << fls(cdata->inline_rsize + sizeof(struct rpcrdma_rep));
		dprintk("RPC: %s: wlen = %zu, rlen = %zu\n",
		__func__, wlen, rlen);

		for (i = 0; i < buf->rb_max_requests; i++) {
		struct rpcrdma_req *req;
		struct rpcrdma_rep *rep;

		len = cdata->inline_wsize + sizeof(struct rpcrdma_req);
		/* RPC layer requests double size + 1K RPC_SLACK_SPACE! */
		/* Typical ~2400b, so rounding up saves work later */
		if (len < 4096)
		len = 4096;
		req = kmalloc(len, GFP_KERNEL);
		req = kmalloc(wlen, GFP_KERNEL);
		if (req == NULL) {
		dprintk("RPC: %s: request buffer %d alloc"
		" failed\n", __func__, i);
		@@ -1141,16 +1142,16 @@ rpcrdma_buffer_create(struct rpcrdma_buffer buf, struct rpcrdma_ep ep,
		buf->rb_send_bufs[i]->rl_buffer = buf;

		rc = rpcrdma_register_internal(ia, req->rl_base,
		len - offsetof(struct rpcrdma_req, rl_base),
		wlen - offsetof(struct rpcrdma_req, rl_base),
		&buf->rb_send_bufs[i]->rl_handle,
		&buf->rb_send_bufs[i]->rl_iov);
		if (rc)
		goto out;

		buf->rb_send_bufs[i]->rl_size = len-sizeof(struct rpcrdma_req);
		buf->rb_send_bufs[i]->rl_size = wlen -
		sizeof(struct rpcrdma_req);

		len = cdata->inline_rsize + sizeof(struct rpcrdma_rep);
		rep = kmalloc(len, GFP_KERNEL);
		rep = kmalloc(rlen, GFP_KERNEL);
		if (rep == NULL) {
		dprintk("RPC: %s: reply buffer %d alloc failed\n",
		__func__, i);
		@@ -1162,7 +1163,7 @@ rpcrdma_buffer_create(struct rpcrdma_buffer buf, struct rpcrdma_ep ep,
		buf->rb_recv_bufs[i]->rr_buffer = buf;

		rc = rpcrdma_register_internal(ia, rep->rr_base,
		len - offsetof(struct rpcrdma_rep, rr_base),
		rlen - offsetof(struct rpcrdma_rep, rr_base),
		&buf->rb_recv_bufs[i]->rr_handle,
		&buf->rb_recv_bufs[i]->rr_iov);
		if (rc)

Admin message