Commit 00f1443e authored by Shuhei Matsumoto's avatar Shuhei Matsumoto Committed by Tomasz Zawadzki
Browse files

bdevperf: Move down help command / usage functions in a file 



Signed-off-by: default avatarShuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Change-Id: I326b3c7e60a7aacce9a692c41dcfd0fc19825444
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/513


Reviewed-by: default avatarDarek Stojaczyk <dariusz.stojaczyk@intel.com>
Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
Reviewed-by: default avatarPaul Luse <paul.e.luse@intel.com>
Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
parent f7f504cf

test/bdev/bdevperf/bdevperf.c

+195 −195
Original line number Diff line number Diff line
@@ -949,25 +949,6 @@ bdevperf_submit_on_group(struct spdk_io_channel_iter *i) 
	spdk_for_each_channel_continue(i, 0);

}



static void

bdevperf_usage(void)

{

	printf(" -q <depth>                io depth\n");

	printf(" -o <size>                 io size in bytes\n");

	printf(" -w <type>                 io pattern type, must be one of (read, write, randread, randwrite, rw, randrw, verify, reset, unmap, flush)\n");

	printf(" -t <time>                 time in seconds\n");

	printf(" -M <percent>              rwmixread (100 for reads, 0 for writes)\n");

	printf(" -P <num>                  number of moving average period\n");

	printf("\t\t(If set to n, show weighted mean of the previous n IO/s in real time)\n");

	printf("\t\t(Formula: M = 2 / (n + 1), EMA[i+1] = IO/s * M + (1 - M) * EMA[i])\n");

	printf("\t\t(only valid with -S)\n");

	printf(" -S <period>               show performance result in real time every <period> seconds\n");

	printf(" -T <target>               target bdev\n");

	printf(" -f                        continue processing I/O even after failures\n");

	printf(" -z                        start bdevperf, but wait for RPC to start tests\n");

	printf(" -C                        enable every core to send I/Os to each bdev\n");

}



/*

 * Cumulative Moving Average (CMA): average of all data up to current

 * Exponential Moving Average (EMA): weighted mean of the previous n data and more weight is given to recent
@@ -1110,148 +1091,6 @@ ret: 
	return -1;

}



static int

verify_test_params(struct spdk_app_opts *opts)

{

	/* When RPC is used for starting tests and

	 * no rpc_addr was configured for the app,

	 * use the default address. */

	if (g_wait_for_tests && opts->rpc_addr == NULL) {

		opts->rpc_addr = SPDK_DEFAULT_RPC_ADDR;

	}



	if (g_queue_depth <= 0) {

		spdk_app_usage();

		bdevperf_usage();

		return 1;

	}

	if (g_io_size <= 0) {

		spdk_app_usage();

		bdevperf_usage();

		return 1;

	}

	if (!g_workload_type) {

		spdk_app_usage();

		bdevperf_usage();

		return 1;

	}

	if (g_time_in_sec <= 0) {

		spdk_app_usage();

		bdevperf_usage();

		return 1;

	}

	g_time_in_usec = g_time_in_sec * 1000000LL;



	if (g_show_performance_ema_period > 0 &&

	    g_show_performance_real_time == 0) {

		fprintf(stderr, "-P option must be specified with -S option\n");

		return 1;

	}



	if (strcmp(g_workload_type, "read") &&

	    strcmp(g_workload_type, "write") &&

	    strcmp(g_workload_type, "randread") &&

	    strcmp(g_workload_type, "randwrite") &&

	    strcmp(g_workload_type, "rw") &&

	    strcmp(g_workload_type, "randrw") &&

	    strcmp(g_workload_type, "verify") &&

	    strcmp(g_workload_type, "reset") &&

	    strcmp(g_workload_type, "unmap") &&

	    strcmp(g_workload_type, "write_zeroes") &&

	    strcmp(g_workload_type, "flush")) {

		fprintf(stderr,

			"io pattern type must be one of\n"

			"(read, write, randread, randwrite, rw, randrw, verify, reset, unmap, flush)\n");

		return 1;

	}



	if (!strcmp(g_workload_type, "read") ||

	    !strcmp(g_workload_type, "randread")) {

		g_rw_percentage = 100;

	}



	if (!strcmp(g_workload_type, "write") ||

	    !strcmp(g_workload_type, "randwrite")) {

		g_rw_percentage = 0;

	}



	if (!strcmp(g_workload_type, "unmap")) {

		g_unmap = true;

	}



	if (!strcmp(g_workload_type, "write_zeroes")) {

		g_write_zeroes = true;

	}



	if (!strcmp(g_workload_type, "flush")) {

		g_flush = true;

	}



	if (!strcmp(g_workload_type, "verify") ||

	    !strcmp(g_workload_type, "reset")) {

		g_rw_percentage = 50;

		if (g_io_size > SPDK_BDEV_LARGE_BUF_MAX_SIZE) {

			fprintf(stderr, "Unable to exceed max I/O size of %d for verify. (%d provided).\n",

				SPDK_BDEV_LARGE_BUF_MAX_SIZE, g_io_size);

			return 1;

		}

		if (opts->reactor_mask) {

			fprintf(stderr, "Ignoring -m option. Verify can only run with a single core.\n");

			opts->reactor_mask = NULL;

		}

		g_verify = true;

		if (!strcmp(g_workload_type, "reset")) {

			g_reset = true;

		}

	}



	if (!strcmp(g_workload_type, "read") ||

	    !strcmp(g_workload_type, "randread") ||

	    !strcmp(g_workload_type, "write") ||

	    !strcmp(g_workload_type, "randwrite") ||

	    !strcmp(g_workload_type, "verify") ||

	    !strcmp(g_workload_type, "reset") ||

	    !strcmp(g_workload_type, "unmap") ||

	    !strcmp(g_workload_type, "write_zeroes") ||

	    !strcmp(g_workload_type, "flush")) {

		if (g_mix_specified) {

			fprintf(stderr, "Ignoring -M option... Please use -M option"

				" only when using rw or randrw.\n");

		}

	}



	if (!strcmp(g_workload_type, "rw") ||

	    !strcmp(g_workload_type, "randrw")) {

		if (g_rw_percentage < 0 || g_rw_percentage > 100) {

			fprintf(stderr,

				"-M must be specified to value from 0 to 100 "

				"for rw or randrw.\n");

			return 1;

		}

	}



	if (!strcmp(g_workload_type, "read") ||

	    !strcmp(g_workload_type, "write") ||

	    !strcmp(g_workload_type, "rw") ||

	    !strcmp(g_workload_type, "verify") ||

	    !strcmp(g_workload_type, "reset") ||

	    !strcmp(g_workload_type, "unmap") ||

	    !strcmp(g_workload_type, "write_zeroes")) {

		g_is_random = 0;

	} else {

		g_is_random = 1;

	}



	if (g_io_size > SPDK_BDEV_LARGE_BUF_MAX_SIZE) {

		printf("I/O size of %d is greater than zero copy threshold (%d).\n",

		       g_io_size, SPDK_BDEV_LARGE_BUF_MAX_SIZE);

		printf("Zero copy mechanism will not be used.\n");

		g_zcopy = false;

	}



	return 0;

}



static int

bdevperf_test(void)

{
@@ -1382,6 +1221,55 @@ spdk_bdevperf_shutdown_cb(void) 
	spdk_for_each_channel(&g_bdevperf, bdevperf_stop_io_on_group, NULL, NULL);

}



static void

rpc_perform_tests_cb(void)

{

	struct spdk_json_write_ctx *w;

	struct spdk_jsonrpc_request *request = g_request;



	g_request = NULL;



	if (g_run_rc == 0) {

		w = spdk_jsonrpc_begin_result(request);

		spdk_json_write_uint32(w, g_run_rc);

		spdk_jsonrpc_end_result(request, w);

	} else {

		spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,

						     "bdevperf failed with error %s", spdk_strerror(-g_run_rc));

	}



	/* Reset g_run_rc to 0 for the next test run. */

	g_run_rc = 0;

}



static void

rpc_perform_tests(struct spdk_jsonrpc_request *request, const struct spdk_json_val *params)

{

	int rc;



	if (params != NULL) {

		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,

						 "perform_tests method requires no parameters");

		return;

	}

	if (g_request != NULL) {

		fprintf(stderr, "Another test is already in progress.\n");

		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,

						 spdk_strerror(-EINPROGRESS));

		return;

	}

	g_request = request;



	bdevperf_construct_targets();



	rc = bdevperf_test();

	if (rc) {

		g_run_rc = rc;

		bdevperf_test_done();

	}

}

SPDK_RPC_REGISTER("perform_tests", rpc_perform_tests, SPDK_RPC_RUNTIME)



static int

bdevperf_parse_arg(int ch, char *arg)

{
@@ -1436,53 +1324,165 @@ bdevperf_parse_arg(int ch, char *arg) 
}



static void

rpc_perform_tests_cb(void)

bdevperf_usage(void)

{

	struct spdk_json_write_ctx *w;

	struct spdk_jsonrpc_request *request = g_request;

	printf(" -q <depth>                io depth\n");

	printf(" -o <size>                 io size in bytes\n");

	printf(" -w <type>                 io pattern type, must be one of (read, write, randread, randwrite, rw, randrw, verify, reset, unmap, flush)\n");

	printf(" -t <time>                 time in seconds\n");

	printf(" -M <percent>              rwmixread (100 for reads, 0 for writes)\n");

	printf(" -P <num>                  number of moving average period\n");

	printf("\t\t(If set to n, show weighted mean of the previous n IO/s in real time)\n");

	printf("\t\t(Formula: M = 2 / (n + 1), EMA[i+1] = IO/s * M + (1 - M) * EMA[i])\n");

	printf("\t\t(only valid with -S)\n");

	printf(" -S <period>               show performance result in real time every <period> seconds\n");

	printf(" -T <target>               target bdev\n");

	printf(" -f                        continue processing I/O even after failures\n");

	printf(" -z                        start bdevperf, but wait for RPC to start tests\n");

	printf(" -C                        enable every core to send I/Os to each bdev\n");

}



	g_request = NULL;

static int

verify_test_params(struct spdk_app_opts *opts)

{

	/* When RPC is used for starting tests and

	 * no rpc_addr was configured for the app,

	 * use the default address. */

	if (g_wait_for_tests && opts->rpc_addr == NULL) {

		opts->rpc_addr = SPDK_DEFAULT_RPC_ADDR;

	}



	if (g_run_rc == 0) {

		w = spdk_jsonrpc_begin_result(request);

		spdk_json_write_uint32(w, g_run_rc);

		spdk_jsonrpc_end_result(request, w);

	} else {

		spdk_jsonrpc_send_error_response_fmt(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,

						     "bdevperf failed with error %s", spdk_strerror(-g_run_rc));

	if (g_queue_depth <= 0) {

		spdk_app_usage();

		bdevperf_usage();

		return 1;

	}

	if (g_io_size <= 0) {

		spdk_app_usage();

		bdevperf_usage();

		return 1;

	}

	if (!g_workload_type) {

		spdk_app_usage();

		bdevperf_usage();

		return 1;

	}

	if (g_time_in_sec <= 0) {

		spdk_app_usage();

		bdevperf_usage();

		return 1;

	}

	g_time_in_usec = g_time_in_sec * 1000000LL;



	/* Reset g_run_rc to 0 for the next test run. */

	g_run_rc = 0;

	if (g_show_performance_ema_period > 0 &&

	    g_show_performance_real_time == 0) {

		fprintf(stderr, "-P option must be specified with -S option\n");

		return 1;

	}



static void

rpc_perform_tests(struct spdk_jsonrpc_request *request, const struct spdk_json_val *params)

{

	int rc;

	if (strcmp(g_workload_type, "read") &&

	    strcmp(g_workload_type, "write") &&

	    strcmp(g_workload_type, "randread") &&

	    strcmp(g_workload_type, "randwrite") &&

	    strcmp(g_workload_type, "rw") &&

	    strcmp(g_workload_type, "randrw") &&

	    strcmp(g_workload_type, "verify") &&

	    strcmp(g_workload_type, "reset") &&

	    strcmp(g_workload_type, "unmap") &&

	    strcmp(g_workload_type, "write_zeroes") &&

	    strcmp(g_workload_type, "flush")) {

		fprintf(stderr,

			"io pattern type must be one of\n"

			"(read, write, randread, randwrite, rw, randrw, verify, reset, unmap, flush)\n");

		return 1;

	}



	if (params != NULL) {

		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,

						 "perform_tests method requires no parameters");

		return;

	if (!strcmp(g_workload_type, "read") ||

	    !strcmp(g_workload_type, "randread")) {

		g_rw_percentage = 100;

	}

	if (g_request != NULL) {

		fprintf(stderr, "Another test is already in progress.\n");

		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,

						 spdk_strerror(-EINPROGRESS));

		return;



	if (!strcmp(g_workload_type, "write") ||

	    !strcmp(g_workload_type, "randwrite")) {

		g_rw_percentage = 0;

	}

	g_request = request;



	bdevperf_construct_targets();

	if (!strcmp(g_workload_type, "unmap")) {

		g_unmap = true;

	}



	rc = bdevperf_test();

	if (rc) {

		g_run_rc = rc;

		bdevperf_test_done();

	if (!strcmp(g_workload_type, "write_zeroes")) {

		g_write_zeroes = true;

	}



	if (!strcmp(g_workload_type, "flush")) {

		g_flush = true;

	}



	if (!strcmp(g_workload_type, "verify") ||

	    !strcmp(g_workload_type, "reset")) {

		g_rw_percentage = 50;

		if (g_io_size > SPDK_BDEV_LARGE_BUF_MAX_SIZE) {

			fprintf(stderr, "Unable to exceed max I/O size of %d for verify. (%d provided).\n",

				SPDK_BDEV_LARGE_BUF_MAX_SIZE, g_io_size);

			return 1;

		}

		if (opts->reactor_mask) {

			fprintf(stderr, "Ignoring -m option. Verify can only run with a single core.\n");

			opts->reactor_mask = NULL;

		}

		g_verify = true;

		if (!strcmp(g_workload_type, "reset")) {

			g_reset = true;

		}

	}



	if (!strcmp(g_workload_type, "read") ||

	    !strcmp(g_workload_type, "randread") ||

	    !strcmp(g_workload_type, "write") ||

	    !strcmp(g_workload_type, "randwrite") ||

	    !strcmp(g_workload_type, "verify") ||

	    !strcmp(g_workload_type, "reset") ||

	    !strcmp(g_workload_type, "unmap") ||

	    !strcmp(g_workload_type, "write_zeroes") ||

	    !strcmp(g_workload_type, "flush")) {

		if (g_mix_specified) {

			fprintf(stderr, "Ignoring -M option... Please use -M option"

				" only when using rw or randrw.\n");

		}

	}



	if (!strcmp(g_workload_type, "rw") ||

	    !strcmp(g_workload_type, "randrw")) {

		if (g_rw_percentage < 0 || g_rw_percentage > 100) {

			fprintf(stderr,

				"-M must be specified to value from 0 to 100 "

				"for rw or randrw.\n");

			return 1;

		}

	}



	if (!strcmp(g_workload_type, "read") ||

	    !strcmp(g_workload_type, "write") ||

	    !strcmp(g_workload_type, "rw") ||

	    !strcmp(g_workload_type, "verify") ||

	    !strcmp(g_workload_type, "reset") ||

	    !strcmp(g_workload_type, "unmap") ||

	    !strcmp(g_workload_type, "write_zeroes")) {

		g_is_random = 0;

	} else {

		g_is_random = 1;

	}



	if (g_io_size > SPDK_BDEV_LARGE_BUF_MAX_SIZE) {

		printf("I/O size of %d is greater than zero copy threshold (%d).\n",

		       g_io_size, SPDK_BDEV_LARGE_BUF_MAX_SIZE);

		printf("Zero copy mechanism will not be used.\n");

		g_zcopy = false;

	}



	return 0;

}

SPDK_RPC_REGISTER("perform_tests", rpc_perform_tests, SPDK_RPC_RUNTIME)



int

main(int argc, char **argv)