Commit 2edc6529 authored by Jim Harris's avatar Jim Harris
Browse files

reduce: save num_io_units and chunk_is_compressed to req object 



When a chunk cannot be compressed enough to save one I/O
unit, we will just write the uncompressed data to disk.  In
this case, we want the helper routine to use the decomp_buf
instead of the comp_buf.

To facilitate that, save some information in the request
object on the number of io_units to be read from or written
to disk, and whether the data is compressed or not.  We
could easily deduce if the data is compressed based on the
number of io_units but saving it in the structure will
save a few instructions and simplify the code a bit.

Signed-off-by: default avatarJim Harris <james.r.harris@intel.com>
Change-Id: I1537130577943e19fe4dfcee58eac453eca3c29b

Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/449259


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarChangpeng Liu <changpeng.liu@intel.com>
Reviewed-by: default avatarPaul Luse <paul.e.luse@intel.com>
Reviewed-by: default avatarShuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
parent 309f7791

lib/reduce/reduce.c

+41 −11
Original line number Diff line number Diff line
@@ -112,6 +112,8 @@ struct spdk_reduce_vol_request { 
	int					reduce_errno;

	int					iovcnt;

	int					num_backing_ops;

	uint32_t				num_io_units;

	bool					chunk_is_compressed;

	uint64_t				offset;

	uint64_t				logical_map_index;

	uint64_t				length;
@@ -944,20 +946,30 @@ static void 
_issue_backing_ops(struct spdk_reduce_vol_request *req, struct spdk_reduce_vol *vol,

		   reduce_request_fn next_fn, bool is_write)

{

	struct iovec *iov;

	uint8_t *buf;

	uint32_t i;



	req->num_backing_ops = vol->backing_io_units_per_chunk;

	if (req->chunk_is_compressed) {

		iov = req->comp_buf_iov;

		buf = req->comp_buf;

	} else {

		iov = req->decomp_buf_iov;

		buf = req->decomp_buf;

	}



	req->num_backing_ops = req->num_io_units;

	req->backing_cb_args.cb_fn = next_fn;

	req->backing_cb_args.cb_arg = req;

	for (i = 0; i < vol->backing_io_units_per_chunk; i++) {

		req->comp_buf_iov[i].iov_base = req->comp_buf + i * vol->params.backing_io_unit_size;

		req->comp_buf_iov[i].iov_len = vol->params.backing_io_unit_size;

	for (i = 0; i < req->num_io_units; i++) {

		iov[i].iov_base = buf + i * vol->params.backing_io_unit_size;

		iov[i].iov_len = vol->params.backing_io_unit_size;

		if (is_write) {

			vol->backing_dev->writev(vol->backing_dev, &req->comp_buf_iov[i], 1,

			vol->backing_dev->writev(vol->backing_dev, &iov[i], 1,

						 req->chunk->io_unit_index[i] * vol->backing_lba_per_io_unit,

						 vol->backing_lba_per_io_unit, &req->backing_cb_args);

		} else {

			vol->backing_dev->readv(vol->backing_dev, &req->comp_buf_iov[i], 1,

			vol->backing_dev->readv(vol->backing_dev, &iov[i], 1,

						req->chunk->io_unit_index[i] * vol->backing_lba_per_io_unit,

						vol->backing_lba_per_io_unit, &req->backing_cb_args);

		}
@@ -980,9 +992,13 @@ _reduce_vol_write_chunk(struct spdk_reduce_vol_request *req, reduce_request_fn n 
	spdk_bit_array_set(vol->allocated_chunk_maps, req->chunk_map_index);



	req->chunk = _reduce_vol_get_chunk_map(vol, req->chunk_map_index);

	req->chunk->compressed_size = compressed_size;

	req->num_io_units = spdk_divide_round_up(compressed_size,

			    vol->params.backing_io_unit_size);

	req->chunk_is_compressed = (req->num_io_units == vol->backing_io_units_per_chunk);

	req->chunk->compressed_size =

		req->chunk_is_compressed ? compressed_size : vol->params.chunk_size;



	for (i = 0; i < vol->backing_io_units_per_chunk; i++) {

	for (i = 0; i < req->num_io_units; i++) {

		req->chunk->io_unit_index[i] = spdk_bit_array_find_first_clear(vol->allocated_backing_io_units, 0);

		/* TODO: fail if no backing block found - but really this should also not

		 * happen (see comment above).
@@ -990,11 +1006,13 @@ _reduce_vol_write_chunk(struct spdk_reduce_vol_request *req, reduce_request_fn n 
		assert(req->chunk->io_unit_index[i] != UINT32_MAX);

		spdk_bit_array_set(vol->allocated_backing_io_units, req->chunk->io_unit_index[i]);

	}

	while (i < vol->backing_io_units_per_chunk) {

		req->chunk->io_unit_index[i++] = REDUCE_EMPTY_MAP_ENTRY;

	}



	_issue_backing_ops(req, vol, next_fn, true /* write */);

}





static void

_write_compress_done(void *_req, int reduce_errno)

{
@@ -1095,7 +1113,11 @@ _write_read_done(void *_req, int reduce_errno) 
		return;

	}



	if (req->chunk_is_compressed) {

		_reduce_vol_decompress_chunk(req, _write_decompress_done);

	} else {

		_write_decompress_done(req, req->chunk->compressed_size);

	}

}



static void
@@ -1150,7 +1172,11 @@ _read_read_done(void *_req, int reduce_errno) 
		return;

	}



	if (req->chunk_is_compressed) {

		_reduce_vol_decompress_chunk(req, _read_decompress_done);

	} else {

		_read_decompress_done(req, req->chunk->compressed_size);

	}

}



static void
@@ -1163,6 +1189,10 @@ _reduce_vol_read_chunk(struct spdk_reduce_vol_request *req, reduce_request_fn ne 


	req->chunk = _reduce_vol_get_chunk_map(vol, req->chunk_map_index);

	assert(req->chunk->compressed_size == vol->params.chunk_size);

	req->num_io_units = spdk_divide_round_up(req->chunk->compressed_size,

			    vol->params.backing_io_unit_size);

	req->chunk_is_compressed = (req->num_io_units == vol->backing_io_units_per_chunk);



	_issue_backing_ops(req, vol, next_fn, false /* read */);

}