code cleanup for -i-1 and -T params

dsa_perf_micros can run in 3 modes, iteration count, a time period
and an infinite loop, this patch consolidates BW/latency measurement
into the do_results() function.

Reviewed-by: Nirav N Shah <[email protected]>
Signed-off-by: Nikhil Rao <[email protected]>

Author: nikhilprao

scripts/test_basic.sh

@@ -32,6 +32,8 @@ test_params_loop() {
 	$bin -o3 -q16 -n32 -cf
 # test offset
 	$bin -o3 -O32,40 -cf
+# test -T
+	$bin -o3 -T2
 }
 
 test_all_cfg() {

src/common.h

@@ -19,6 +19,7 @@
 #define ARRAY_SIZE(x)	(sizeof((x))/sizeof((x)[0]))
 #define MAX_COMP_RETRY	2000000000
 #define PTR_ADD(p, a)	{ p = (void *)((uintptr_t)(p) + (uintptr_t)a); }
+#define TIME_DELAY_SEC	4
 
 /* max number of operands e.g., dual cast - src1, dst1, dst2 */
 #define NUM_ADDR_MAX	3
@@ -246,7 +247,7 @@ struct tcfg {
 	uint64_t retry;				/* completion polling retries */
 	uint64_t mwait_cycles;			/* cycles spent in mwait */
 	float cpu_util;				/* cpu utilization needed to prep/submit descriptors */
-	int ops_rate;				/* operation rate - descriptors/sec */
+	int kops_rate;				/* operation rate - kilo operations/sec */
 	float latency;				/* latency for n descriptors */
 	float bw;				/* operation BW */
 	uint64_t retries_per_sec;		/* pollling retries the CPU can do per sec  */
@@ -286,6 +287,13 @@ extern struct log_ctx log_ctx;
 
 void init_buffers(struct tcfg_cpu *tcpu);
 
+static inline bool
+is_work_rate_sub_test(struct tcfg *tcfg)
+{
+	return tcfg->op == DSA_OPCODE_NOOP &&
+		tcfg->misc_flags & (TEST_M64 | TEST_DB | TEST_M64MEM | TEST_ENQ | TEST_ENQMEM);
+}
+
 static inline void
 cldemote(volatile void *p)
 {

src/cpu.c

@@ -145,7 +145,10 @@ test_memcpy(struct tcfg_cpu *tcpu)
 	tcpu->cycles = 0;
 	test_barrier(tcfg, 0);
 
-	for (i = 0; i < tcfg->iter; i++) {
+	/* notify main thread that the test has started */
+	tcpu->tstart = rdtsc();
+
+	for (i = 0; i < tcfg->iter || (tcfg->tval_secs && !tcfg->stop); i++) {
 		uint64_t c;
 
 		src = tcpu->src;
@@ -155,12 +158,9 @@ test_memcpy(struct tcfg_cpu *tcpu)
 		src2 = tcpu->src2;
 
 		/*
-		 * If cpus > 1, then you can either measure the BW for a
-                 * single buffer for a single iteration or if the number
-		 * iterations is > 1 then use a working set such that for a single threaded
-		 * config nb_bufs * blen exceeds the L2 size for LLC BW measurement or
-		 * nb_cpus * nb_bufs * blen exceeds total L2 + LLC size for memory BW
-		 * measurement. Halve the sizes for MT.
+		 * when using > 1 CPU, data placement operations & data
+		 * movement will happen concurrenty across CPUs, hence
+		 * data placement is used only when using a single CPU
 		 */
 		if (tcfg->nb_cpus == 1)
 			do_cache_ops(tcpu);
@@ -210,7 +210,5 @@ test_memcpy(struct tcfg_cpu *tcpu)
 		tcpu->curr_stat.iter++;
 	}
 
-	if (tcfg->iter)
-		tcpu->cycles /= tcfg->iter;
 	tcpu->err = 0;
 }

src/main.c

@@ -493,7 +493,6 @@ submit_test_desc(struct tcfg_cpu *tcpu)
 	uint32_t i;
 	int d;
 	struct tcfg *tcfg;
-	bool inf;
 	int nb_desc;
 
 	tcfg = tcpu->tcfg;
@@ -534,16 +533,14 @@ submit_test_desc(struct tcfg_cpu *tcpu)
 	else
 		INFO_CPU(tcpu, "Running BW test\n");
 
-	inf = tcfg->iter == ~0U;
-
 	if (do_single_iter(tcpu, nb_desc)) {
 		ERR("Failed initial descriptor submission\n");
 		goto error2;
 	}
 
 	tcpu->curr_stat.iter = 0;
 	tcpu->tstart = rdtsc();
-	for (i = 0; !tcfg->stop && (inf || i < tcfg->iter) ; i++) {
+	for (i = 0; !tcfg->stop && (tcfg->tval_secs || i < tcfg->iter) ; i++) {
 		if (do_single_iter(tcpu, nb_desc)) {
 			ERR("Error iteration: %d\n", i);
 			goto error2;
@@ -553,7 +550,6 @@ submit_test_desc(struct tcfg_cpu *tcpu)
 	tcpu->tend = rdtsc();
 
 	tcpu->cycles = tcpu->tend - tcpu->tstart;
-	tcpu->cycles /= tcfg->iter;
 
 	d = 0;
 	while (d < tcpu->qd) {
@@ -622,7 +618,6 @@ test_run_fn(void *arg)
 {
 	struct tcfg_cpu *tcpu = arg;
 	struct tcfg *tcfg = tcpu->tcfg;
-	bool do_sub_rate;
 
 	cpu_pin(tcpu->cpu_num);
 
@@ -631,49 +626,14 @@ test_run_fn(void *arg)
 		return 0;
 	}
 
-	do_sub_rate = tcfg->misc_flags &
-			(TEST_M64 | TEST_DB | TEST_M64MEM |
-			TEST_ENQ | TEST_ENQMEM);
-
-	if (tcfg->op == DSA_OPCODE_NOOP && do_sub_rate)
+	if (is_work_rate_sub_test(tcfg))
 		work_sub_rate_test(tcpu);
 	else
 		do_desc_work(tcpu);
 
 	return 0;
 }
 
-static void
-iter_count_stat(uint64_t *stat, uint64_t *prev, uint64_t *curr)
-{
-	*stat += *curr - *prev;
-	*prev = *curr;
-}
-
-static void
-count_stat(struct iter_stat *is, struct tcfg_cpu *tcpu)
-{
-	int i;
-
-	for (i = 0; i < ARRAY_SIZE(is->stat); i++)
-		iter_count_stat(&is->stat[i], &tcpu->prev_stat.stat[i],
-				&tcpu->curr_stat.stat[i]);
-}
-
-static void
-iter_count(struct tcfg *tcfg, struct iter_stat *iter_stat)
-{
-	unsigned int i;
-	struct iter_stat is = {};
-
-	for (i = 0; i < tcfg->nb_cpus; i++) {
-		struct tcfg_cpu *tcpu = &tcfg->tcpu[i];
-
-		count_stat(&is, tcpu);
-	}
-
-	*iter_stat = is;
-}
 
 static void *
 test_fn(void *arg)
@@ -702,10 +662,36 @@ test_fn(void *arg)
 	return NULL;
 }
 
+static void
+print_results(struct tcfg *tcfg)
+{
+	if (is_work_rate_sub_test(tcfg)) {
+		printf("kopsrate = %d", tcfg->kops_rate);
+		if (tcfg->misc_flags & (TEST_ENQ | TEST_ENQMEM))
+			printf(" latency = %d ns", (1000 * 1000) / tcfg->kops_rate);
+		printf("\n");
+		return;
+	}
+
+	printf("GB per sec = %f", tcfg->bw);
+	if (tcfg->qd == 1 || tcfg->nb_bufs == 1)
+		printf(" latency(cycles) = %f, %f ns, cycles/sec =%ld",
+		tcfg->latency, (tcfg->latency * 1E9)/tcfg->cycles_per_sec,
+		tcfg->cycles_per_sec);
+	printf(" cpu %f kopsrate = %d\n", tcfg->cpu_util, tcfg->kops_rate);
+
+	if (tcfg->drain_desc) {
+		double drain_usec = ((1.0 * tcfg->drain_lat)/tcfg->cycles_per_sec) * 1000000;
+
+		printf("Drain desc latency = %lu cycles | %f uSec\n", tcfg->drain_lat, drain_usec);
+	}
+}
+
 static int
 test_run(struct tcfg *tcfg)
 {
 	int i, err = 0;
+	bool inf = tcfg->iter == -1;
 
 	for (i = 0; i < tcfg->nb_cpus; i++) {
 
@@ -728,19 +714,16 @@ test_run(struct tcfg *tcfg)
 		}
 	}
 
-	if (tcfg->iter == ~0U) {
-		uint64_t iter_bytes = data_size_per_iter(tcfg);
+	if (tcfg->tval_secs) {
 
 		err = false;
-		while (!err) {
-			float bw;
-			struct iter_stat is;
+		while (!tcfg->stop) {
 
-			sleep(tcfg->tval_secs);
-			iter_count(tcfg, &is);
+			while (tcfg->tcpu[0].tstart == 0)
+				__builtin_ia32_pause();
 
-			bw = (is.iter * iter_bytes)/(1E9 * tcfg->tval_secs);
-			bw = bw/tcfg->nb_cpus;
+			sleep(tcfg->tval_secs);
+			do_results(tcfg);
 
 			for (i = 0, err = false; i < tcfg->nb_cpus; i++) {
 				struct tcfg_cpu *tcpu = &tcfg->tcpu[i];
@@ -757,11 +740,8 @@ test_run(struct tcfg *tcfg)
 				continue;
 			}
 
-			tcfg->retry = is.retry / tcfg->nb_cpus;
-			tcfg->mwait_cycles = is.mwait_cycles / tcfg->nb_cpus;
-			calc_cpu_for_sec(tcfg, tcfg->tval_secs);
-
-			fprintf(stdout, "BW %f GB cpu util %f\n", bw, tcfg->cpu_util);
+			print_results(tcfg);
+			tcfg->stop = !inf;
 		}
 	}
 
@@ -803,7 +783,7 @@ main(int argc, char **argv)
 		.flags_nth_desc = 1,
 		.flags_cmask = -1,
 		.flags_smask = 0,
-		.tval_secs = 4,
+		.tval_secs = 0,
 		.numa_node_default = { -1, -1, -1 },
 		.place_op = { OP_FLUSH, OP_FLUSH, OP_FLUSH },
 		.access_op = { OP_WRITE, OP_WRITE, OP_WRITE },
@@ -838,20 +818,8 @@ main(int argc, char **argv)
 
 	do_results(&tcfg);
 
-	printf("GB per sec = %f", tcfg.bw);
-	if (tcfg.qd == 1 || tcfg.nb_bufs == 1)
-		printf(" latency(cycles) = %f, %f ns,"
-		" cycles/sec =%ld",
-		tcfg.latency, (tcfg.latency * 1E9)/tcfg.cycles_per_sec,
-		tcfg.cycles_per_sec);
-	printf(" cpu %f kopsrate = %d\n", tcfg.cpu_util, tcfg.ops_rate);
-
-
-	if (tcfg.drain_desc) {
-		double drain_usec = ((1.0 * tcfg.drain_lat)/tcfg.cycles_per_sec) * 1000000;
-
-		printf("Drain desc latency = %lu cycles | %f uSec\n", tcfg.drain_lat, drain_usec);
-	}
+	if (!tcfg.tval_secs)
+		print_results(&tcfg);
 
 err_ret:
 	test_free(&tcfg);

src/options.c

@@ -96,7 +96,7 @@ void print_usage(void)
 	"\t-F <flag_bits_to_clear:flag_bits_to_set:every_nth_desc>\n"
 	"\t                       e.g., -F 0xFFFFF7:0x8:4 to clear Addr2_TC flag and set RCR=1 on every 4th descriptor\n"
 	"\t-h                   ; Print this message\n"
-	"\t-i <iterations>      ; The number of iterations to run the test for\n"
+	"\t-i <iterations>      ; The number of iterations to run the test for, use i-1 for continuous run (periodic BW/Latency output)\n"
 	"\t-j                   ; deprecated parameter - default behavior\n"
 	"\t-k <CPU list>        ; List of CPUs (e.g., -k0, -k0,1,2,3, -k0-2, -k0-2,3)\n"
 	"\t-K <CPU/WQ list>     ; List of CPUs and associated WQ (e.g., [0,1]@dsa0,0,[2-3]@dsa0,1)\n"
@@ -601,6 +601,8 @@ fixup_options(struct tcfg *tc, struct parse_info *pi)
 		break;
 	}
 
+	if (tc->iter == -1 && tc->tval_secs == 0)
+		tc->tval_secs = TIME_DELAY_SEC;
 }
 
 static void