[PATCH v1] commands: Add dhrystone

[Daniel Schultz <d.schultz@phytec.de>]

This tool will help to measure the system performance.

Some SoCs haven't the possibility to route their clocks to the output pins.
So you can use dhrystone to get a feedback about the clock speed.

Signed-off-by: Daniel Schultz <d.schultz@phytec.de>
---

Changes:
	v1:
	applied RFC suggestions:
		-removed 'default n' in Kconfig
		-refactored time defines with default time units
		-only print variable values when values are wrong
		-added units to printf
		-the iteration parameter is now optional. The programm starts
		with 10000 iterations and adjust higher, when execution time
		is too short.
		-changed variable name (microseconds -> nanoseconds)
		-corrected the command description

 commands/Kconfig     |   6 +
 commands/Makefile    |   1 +
 commands/dhrystone.c | 466 +++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 473 insertions(+)
 create mode 100644 commands/dhrystone.c

diff --git a/commands/Kconfig b/commands/Kconfig
index bb6674e..30485c0 100644
--- a/commands/Kconfig
+++ b/commands/Kconfig
@@ -2102,6 +2102,12 @@ config CMD_STATE
 	depends on STATE
 	prompt "state"
 
+config CMD_DHRYSTONE
+	bool
+	prompt "dhrystone"
+	help
+	  CPU benchmark tool
+
 # end Miscellaneous commands
 endmenu
 
diff --git a/commands/Makefile b/commands/Makefile
index 3698347..879caec 100644
--- a/commands/Makefile
+++ b/commands/Makefile
@@ -112,3 +112,4 @@ obj-$(CONFIG_CMD_NV)		+= nv.o
 obj-$(CONFIG_CMD_DEFAULTENV)	+= defaultenv.o
 obj-$(CONFIG_CMD_STATE)		+= state.o
 obj-$(CONFIG_CMD_DHCP)		+= dhcp.o
+obj-$(CONFIG_CMD_DHRYSTONE)	+= dhrystone.o
diff --git a/commands/dhrystone.c b/commands/dhrystone.c
new file mode 100644
index 0000000..e965011
--- /dev/null
+++ b/commands/dhrystone.c
@@ -0,0 +1,466 @@
+/*
+ * (C) Copyright 2014 - 2015 Phytec Messtechnik GmbH
+ * Author: Stefan Müller-Klieser <s.mueller-klieser@phytec.de>
+ * Author: Daniel Schultz <d.schultz@phytec.de>
+ *
+ * based on "DHRYSTONE" Benchmark Program
+ * Version:    C, Version 2.1
+ * Date:       May 25, 1988
+ * Author:     Reinhold P. Weicker
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <common.h>
+#include <command.h>
+#include <errno.h>
+#include <clock.h>
+#include <asm-generic/div64.h>
+#include <malloc.h>
+#include <stdbool.h>
+#include <stdio.h> /* for strcpy, strcmp */
+
+enum idents {ident_1, ident_2, ident_3, ident_4, ident_5};
+
+/* General definitions: */
+
+struct record {
+		struct record	*ptr_comp;
+		enum idents	discr;
+		union {
+			struct {
+				enum idents	enum_comp;
+				int		int_comp;
+				char		str_comp[31];
+			} var_1;
+			struct {
+				enum idents	enum_comp_2;
+				char		str_2_comp[31];
+			} var_2;
+			struct {
+				char char_1_Comp;
+				char char_2_Comp;
+			} var_3;
+		} variant;
+};
+
+/* Global Variables: */
+
+struct record	*record_glob;
+struct record	*next_record_glob;
+int		int_glob;
+bool		bool_glob;
+char		char_1_glob;
+char		char_2_glob;
+int		arr_1_glob[50];
+int		arr_2_glob[50][50];
+
+/* variables for time measurement: */
+
+#define TOO_SMALL_TIME (50 * MSECOND)
+/* Measurements should last at least 50mseconds */
+#define TOO_LARGE_TIME (2 * SECOND)
+
+u64	 begin_time;
+u64	 end_time;
+u64	 user_time;
+u64	 nanoseconds;
+u64	 dhrystones_per_second;
+/* end of variables for time measurement */
+
+enum idents compare_chars(char char_1, char char_2)
+{
+	if (char_1 != char_2) {
+		return ident_1;
+	} else { /* should not executed */
+		char_1_glob = char_1;
+		return ident_2;
+	}
+}
+
+bool compare_strs(char str_1[31], char str_2[31])
+{
+	int offset;
+
+	offset = 2;
+	while (offset <= 2)
+		if (compare_chars(str_1[offset], str_2[offset+1]) == ident_1)
+			++offset;
+	if (strcmp(str_1, str_2) > 0) {
+		int_glob = offset + 7;
+		return true;
+	} else {
+		return false;
+	}
+
+}
+
+bool check_ident(enum idents ident)
+{
+	if (ident == ident_3)
+		return true;
+	else
+		return false;
+}
+
+void proc_7(int input_1, int input_2, int *out)
+{
+	*out = input_2 + input_1 + 2;
+}
+
+void proc_6(enum idents ident, enum idents *ident_out)
+{
+	*ident_out = ident;
+	if (!check_ident(ident))
+		*ident_out = ident_4;
+	switch (ident) {
+	case ident_1:
+		*ident_out = ident_1;
+		break;
+	case ident_2:
+		if (int_glob > 100)
+			*ident_out = ident_1;
+		else
+			*ident_out = ident_4;
+		break;
+	case ident_3:
+		*ident_out = ident_2;
+		break;
+	case ident_4:
+		break;
+	case ident_5:
+		*ident_out = ident_3;
+		break;
+	}
+}
+
+void fill_record(struct record *record)
+{
+	struct record *next_record = record->ptr_comp;
+
+	*record->ptr_comp = *record_glob;
+	record->variant.var_1.int_comp = 5;
+	next_record->variant.var_1.int_comp = record->variant.var_1.int_comp;
+	next_record->ptr_comp = record->ptr_comp;
+	proc_7(10, int_glob, &record_glob->variant.var_1.int_comp);
+	/* Ptr_Val_Par->ptr_comp->ptr_comp == record_glob->ptr_comp */
+	if (next_record->discr == ident_1) { /* then, executed */
+		next_record->variant.var_1.int_comp = 6;
+		proc_6(record->variant.var_1.enum_comp,
+			&next_record->variant.var_1.enum_comp);
+		next_record->ptr_comp = record_glob->ptr_comp;
+		proc_7(next_record->variant.var_1.int_comp, 10,
+			&next_record->variant.var_1.int_comp);
+	} else { /* not executed */
+		*record = *record->ptr_comp;
+	}
+}
+
+void proc_2(int *out)
+{
+	if (char_1_glob == 'A')
+		*out = *out + 9 - int_glob;
+}
+
+void proc_4(void)
+{
+	bool_glob = (char_1_glob == 'A') | bool_glob;
+	char_2_glob = 'B';
+}
+
+void proc_5(void)
+{
+	char_1_glob = 'A';
+	bool_glob = false;
+}
+
+/* dhry_2.c */
+
+void fill_array(int arr_1[50], int arr_2[50][50], int val_1, int val_2)
+{
+	int i;
+	int offset;
+
+	offset = val_1 + 5;
+	arr_1[offset] = val_2;
+	arr_1[offset+1] = arr_1[offset];
+	arr_1[offset+30] = offset;
+	for (i = offset; i <= offset+1; ++i)
+		arr_2[offset][i] = offset;
+	arr_2[offset][offset-1] += 1;
+	arr_2[offset+20][offset] = arr_1[offset];
+	int_glob = 5;
+}
+
+static int do_dhrystone(int argc, char *argv[])
+{
+	/* main program, corresponds to procedures        */
+	/* Main and Proc_0 in the Ada version             */
+	int		int_1;
+	int		int_2;
+	int		int_3;
+	char		char_i;
+	enum idents	ident;
+	char		str_1[31];
+	char		str_2[31];
+	int		i;
+	int		number_of_runs;
+	char		*new_argv[2];
+	char		tmp_str[10];
+
+	/* barebox cmd */
+	if (argc == 2)
+		number_of_runs = simple_strtoul(argv[1], NULL, 10);
+	else
+		number_of_runs = 10000;
+
+	/* Initializations */
+	ident = ident_2; /* prevent compiler warning */
+	int_2 = 0; /* prevent compiler warning */
+	int_3 = 0; /* prevent compiler warning */
+
+	next_record_glob = malloc(sizeof(struct record));
+	record_glob = malloc(sizeof(struct record));
+
+	record_glob->ptr_comp			= next_record_glob;
+	record_glob->discr			= ident_1;
+	record_glob->variant.var_1.enum_comp	= ident_3;
+	record_glob->variant.var_1.int_comp	= 40;
+	strcpy(record_glob->variant.var_1.str_comp,
+		"DHRYSTONE PROGRAM, SOME STRING");
+	strcpy(str_1, "DHRYSTONE PROGRAM, 1'ST STRING");
+
+	arr_2_glob[8][7] = 10;
+	/* Was missing in published program. Without this statement,    */
+	/* arr_2_glob [8][7] would have an undefined value.             */
+	/* Warning: With 16-Bit processors and number_of_runs > 32000,  */
+	/* overflow may occur for this array element.                   */
+
+	printf("\n");
+	printf("Dhrystone Benchmark, Version 2.1 (Language: C)\n");
+	printf("\n");
+	printf("Program compiled without 'register' attribute\n");
+	printf("\n");
+	printf("Execution starts, %d runs through Dhrystone\n", number_of_runs);
+
+	/***************/
+	/* Start timer */
+	/***************/
+	begin_time = get_time_ns();
+
+	for (i = 1; i <= number_of_runs; ++i) {
+		proc_5();
+		proc_4();
+		/* char_1_glob == 'A', char_2_glob == 'B', bool_glob == true */
+		int_1 = 2;
+		int_2 = 3;
+		strcpy(str_2, "DHRYSTONE PROGRAM, 2'ND STRING");
+		ident = ident_2;
+		bool_glob = !compare_strs(str_1, str_2);
+		/* bool_glob == 1 */
+		while (int_1 < int_2) {
+			int_3 = 5 * int_1 - int_2;
+			/* int_3 == 7 */
+			proc_7(int_1, int_2, &int_3);
+			/* int_3 == 7 */
+			int_1 += 1;
+		}
+		/* int_1 == 3, int_2 == 3, int_3 == 7 */
+		fill_array(arr_1_glob, arr_2_glob, int_1, int_3);
+		/* int_glob == 5 */
+		fill_record(record_glob);
+		for (char_i = 'A'; char_i <= char_2_glob; ++char_i) {
+			if (ident == compare_chars(char_i, 'C')) {
+				proc_6(ident_1, &ident);
+				strcpy(str_2,
+					"DHRYSTONE PROGRAM, 3'RD STRING");
+				int_2 = i;
+				int_glob = i;
+			}
+		}
+		/* int_1 == 3, int_2 == 3, int_3 == 7 */
+		int_2 = int_2 * int_1;
+		int_1 = int_2 / int_3;
+		int_2 = 7 * (int_2 - int_3) - int_1;
+		/* int_1 == 1, int_2 == 13, int_3 == 7 */
+		proc_2(&int_1);
+		/* int_1 == 5 */
+	}
+
+	/**************/
+	/* Stop timer */
+	/**************/
+	end_time = get_time_ns();
+
+	printf("Execution ends\n");
+	printf("\n");
+	printf("Failed variables:\n");
+	if (int_glob != 5) {
+		printf("int_glob:            %d\n", int_glob);
+		printf("        should be:   %d\n", 5);
+	}
+	if (bool_glob != 1) {
+		printf("bool_glob:           %d\n", bool_glob);
+		printf("        should be:   %d\n", 1);
+	}
+	if (char_1_glob != 'A') {
+		printf("char_1_glob:         %c\n", char_1_glob);
+		printf("        should be:   %c\n", 'A');
+	}
+	if (char_2_glob != 'B') {
+		printf("char_2_glob:         %c\n", char_2_glob);
+		printf("        should be:   %c\n", 'B');
+	}
+	if (arr_1_glob[8] != 7) {
+		printf("arr_1_glob[8]:       %d\n", arr_1_glob[8]);
+		printf("        should be:   %d\n", 7);
+	}
+	if (arr_2_glob[8][7] != (number_of_runs + 10)) {
+		printf("arr_2_glob[8][7]:    %d\n", arr_2_glob[8][7]);
+		printf("        should be:   %d\n", number_of_runs + 10);
+	}
+
+	if (record_glob->ptr_comp != next_record_glob) {
+		printf("record_glob->ptr_comp:    0x%p\n",
+			record_glob->ptr_comp);
+		printf("        should be:        0x%p\n", next_record_glob);
+	}
+	if (record_glob->discr != 0) {
+		printf("record_glob->discr:       %d\n", record_glob->discr);
+		printf("        should be:        %d\n", 0);
+	}
+	if (record_glob->variant.var_1.enum_comp != 2) {
+		printf("record_glob->enum_comp:   %d\n",
+			record_glob->variant.var_1.enum_comp);
+		printf("        should be:        %d\n", 2);
+	}
+	if (record_glob->variant.var_1.int_comp != 17) {
+		printf("record_glob->int_comp:    %d\n",
+			record_glob->variant.var_1.int_comp);
+		printf("        should be:        %d\n", 17);
+	}
+	if (strcmp(record_glob->variant.var_1.str_comp,
+		"DHRYSTONE PROGRAM, SOME STRING") != 0) {
+		printf("record_glob->str_comp:    %s\n",
+			record_glob->variant.var_1.str_comp);
+		printf("        should be:        DHRYSTONE PROGRAM, SOME STRING\n");
+	}
+
+	if (next_record_glob->ptr_comp != next_record_glob) {
+		printf("next_record_glob->ptr_comp:    0x%p\n",
+			next_record_glob->ptr_comp);
+		printf("        should be:             0x%p\n",
+			next_record_glob);
+	}
+	if (next_record_glob->discr != 0) {
+		printf(" next_record_glob->discr:      %d\n",
+			next_record_glob->discr);
+		printf("        should be:             %d\n", 0);
+	}
+	if (next_record_glob->variant.var_1.enum_comp != 1) {
+		printf("next_record_glob->enum_comp:   %d\n",
+			next_record_glob->variant.var_1.enum_comp);
+		printf("        should be:             %d\n", 1);
+	}
+	if (next_record_glob->variant.var_1.int_comp != 18) {
+		printf("next_record_glob->int_comp:    %d\n",
+			next_record_glob->variant.var_1.int_comp);
+		printf("        should be:             %d\n", 18);
+	}
+	if (strcmp(next_record_glob->variant.var_1.str_comp,
+		"DHRYSTONE PROGRAM, SOME STRING") != 0) {
+		printf("next_record_glob->str_comp:    %s\n",
+			next_record_glob->variant.var_1.str_comp);
+		printf("        should be:             DHRYSTONE PROGRAM, SOME STRING\n");
+	}
+	if (int_1 != 5) {
+		printf("int_1:               %d\n", int_1);
+		printf("        should be:   %d\n", 5);
+	}
+	if (int_2 != 13) {
+		printf("int_2:               %d\n", int_2);
+		printf("        should be:   %d\n", 13);
+	}
+	if (int_3 != 7) {
+		printf("int_3:               %d\n", int_3);
+		printf("        should be:   %d\n", 7);
+	}
+	if (ident != 1) {
+		printf("ident:               %d\n", ident);
+		printf("        should be:   %d\n", 1);
+	}
+	if (strcmp(str_1, "DHRYSTONE PROGRAM, 1'ST STRING") != 0) {
+		printf("str_1:               %s\n", str_1);
+		printf("        should be:   DHRYSTONE PROGRAM, 1'ST STRING\n");
+	}
+	if (strcmp(str_2, "DHRYSTONE PROGRAM, 2'ND STRING") != 0) {
+		printf("str_2:               %s\n", str_2);
+		printf("        should be:   DHRYSTONE PROGRAM, 2'ND STRING\n");
+	}
+	printf("\n");
+
+	user_time = end_time - begin_time;
+
+	if (user_time < TOO_SMALL_TIME) {
+		number_of_runs = number_of_runs * 10;
+		new_argv[0] = argv[0];
+		sprintf(tmp_str, "%i", number_of_runs);
+		new_argv[1] = tmp_str;
+		printf("Measured time too small to obtain meaningful results\n");
+		printf("or a timer wrap happend. I will increase the number\n");
+		printf("of runs by *10 to %d\n", number_of_runs);
+		printf("user_time: %llu ns\n", user_time);
+		do_dhrystone(2, new_argv);
+	} else if (user_time > TOO_LARGE_TIME) {
+		number_of_runs = number_of_runs / 10;
+		new_argv[0] = argv[0];
+		sprintf(tmp_str, "%i", number_of_runs);
+		new_argv[1] = tmp_str;
+		printf("Measured time too large to obtain meaningful results\n");
+		printf("or a timer wrap happend. I will decrease the number\n");
+		printf("of runs by *10 to %d\n", number_of_runs);
+		printf("Timer overflow could occured.\n");
+		printf("user_time: %llu ns\n", user_time);
+		do_dhrystone(2, new_argv);
+	} else if (end_time < begin_time) {
+		printf("Timer overflow occured.\n");
+		printf("Please restart the command.\n");
+	} else {
+		printf("user_time: %llu ns\n", user_time);
+
+		nanoseconds = user_time;
+		do_div(nanoseconds, number_of_runs);
+
+		printf("Nanoseconds for one run through Dhrystone: %llu\n",
+			nanoseconds);
+		printf("Dhrystones per Second:\n ");
+		printf("(%d / %llu) * 10^9\n", number_of_runs, user_time);
+		printf("DMIPS:\n ");
+		printf("((%d / %llu) * 10^9) / 1757\n", number_of_runs,
+							user_time);
+		printf("\n");
+	}
+
+	return 0;
+}
+
+BAREBOX_CMD_HELP_START(dhrystone)
+BAREBOX_CMD_HELP_TEXT(
+"this command runs the dhrystone benchmark to get an estimation of the CPU freq")
+BAREBOX_CMD_HELP_END
+
+BAREBOX_CMD_START(dhrystone)
+	.cmd		= do_dhrystone,
+	BAREBOX_CMD_DESC("run dhrystone test, specify number of runs")
+	BAREBOX_CMD_OPTS("number_of_runs")
+	BAREBOX_CMD_GROUP(CMD_GRP_INFO)
+	BAREBOX_CMD_HELP(cmd_dhrystone_help)
+BAREBOX_CMD_END
-- 
1.9.1


_______________________________________________
barebox mailing list
barebox@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/barebox