Make tests file complete up to 64 byte shifts and 1.5 K chunks

1 files changed, 133 insertions, 137 deletions

diff --git a/src/systemcmds/tests/tests_file.c b/src/systemcmds/tests/tests_file.c
index 3c0c48cfe..a41d26bda 100644
--- a/src/systemcmds/tests/tests_file.c
+++ b/src/systemcmds/tests/tests_file.c
@@ -54,7 +54,8 @@
 int
 test_file(int argc, char *argv[])
 {
-	const iterations = 200;
+	const unsigned iterations = 100;
+	const unsigned alignments = 65;
 
 	/* check if microSD card is mounted */
 	struct stat buffer;
@@ -63,194 +64,189 @@ test_file(int argc, char *argv[])
 		return 1;
 	}
 
-	uint8_t write_buf[512 + 64] __attribute__((aligned(64)));
+	/* perform tests for a range of chunk sizes */
+	unsigned chunk_sizes[] = {1, 5, 8, 16, 32, 33, 64, 70, 128, 133, 256, 300, 512, 555, 1024, 1500};
 
-	/* fill write buffer with known values */
-	for (int i = 0; i < sizeof(write_buf); i++) {
-		/* this will wrap, but we just need a known value with spacing */
-		write_buf[i] = i+11;
-	}
+	for (unsigned c = 0; c < (sizeof(chunk_sizes) / sizeof(chunk_sizes[0])); c++) {
 
-	uint8_t read_buf[512 + 64] __attribute__((aligned(64)));
-	hrt_abstime start, end;
-	perf_counter_t wperf = perf_alloc(PC_ELAPSED, "SD writes (aligned)");
+		printf("\n====== FILE TEST: %u bytes chunks ======", chunk_sizes[c]);
 
-	int fd = open("/fs/microsd/testfile", O_TRUNC | O_WRONLY | O_CREAT);
+		for (unsigned a = 0; a < alignments; a++) {
 
-	warnx("testing unaligned writes - please wait..");
+			warnx("----- alignment test: %u bytes -----", a);
 
-	start = hrt_absolute_time();
-	for (unsigned i = 0; i < iterations; i++) {
-		perf_begin(wperf);
-		int wret = write(fd, write_buf + 1/*+ (i % 64)*/, 512);
+			uint8_t write_buf[chunk_sizes[c] + alignments] __attribute__((aligned(64)));
 
-		if (wret != 512) {
-			warn("WRITE ERROR!");
+			/* fill write buffer with known values */
+			for (int i = 0; i < sizeof(write_buf); i++) {
+				/* this will wrap, but we just need a known value with spacing */
+				write_buf[i] = i+11;
+			}
 
-			if ((0x3 & (uintptr_t)(write_buf + 1 /* (i % 64)*/)))
-				warnx("memory is unaligned, align shift: %d", 1/*(i % 64)*/);
+			uint8_t read_buf[chunk_sizes[c] + alignments] __attribute__((aligned(64)));
+			hrt_abstime start, end;
+			//perf_counter_t wperf = perf_alloc(PC_ELAPSED, "SD writes (aligned)");
 
-		}
+			int fd = open("/fs/microsd/testfile", O_TRUNC | O_WRONLY | O_CREAT);
 
-		fsync(fd);
-		perf_end(wperf);
+			warnx("testing unaligned writes - please wait..");
 
-	}
-	end = hrt_absolute_time();
+			start = hrt_absolute_time();
+			for (unsigned i = 0; i < iterations; i++) {
+				//perf_begin(wperf);
+				int wret = write(fd, write_buf + a, chunk_sizes[c]);
 
-	warnx("%dKiB in %llu microseconds", iterations / 2, end - start);
+				if (wret != chunk_sizes[c]) {
+					warn("WRITE ERROR!");
 
-	perf_print_counter(wperf);
-	perf_free(wperf);
+					if ((0x3 & (uintptr_t)(write_buf + a)))
+						errx(1, "memory is unaligned, align shift: %d", a);
 
-	close(fd);
-	fd = open("/fs/microsd/testfile", O_RDONLY);
+				}
 
-	/* read back data for validation */
-	for (unsigned i = 0; i < iterations; i++) {
-		int rret = read(fd, read_buf, 512);
+				fsync(fd);
+				//perf_end(wperf);
 
-		if (rret != 512) {
-			warn("READ ERROR!");
-			break;
-		}
-		
-		/* compare value */
-		bool compare_ok = true;
-
-		for (int j = 0; j < 512; j++) {
-			if (read_buf[j] != write_buf[j + 1/*+ (i % 64)*/]) {
-				warnx("COMPARISON ERROR: byte %d, align shift: %d", j, 1/*(i % 64)*/);
-				compare_ok = false;
-				break;
 			}
-		}
+			end = hrt_absolute_time();
 
-		if (!compare_ok) {
-			warnx("ABORTING FURTHER COMPARISON DUE TO ERROR");
-			break;
-		}
-
-	}
+			//warnx("%dKiB in %llu microseconds", iterations / 2, end - start);
 
-	/*
-	 * ALIGNED WRITES AND UNALIGNED READS
-	 */
+			//perf_print_counter(wperf);
+			//perf_free(wperf);
 
-	int ret = unlink("/fs/microsd/testfile");
-	fd = open("/fs/microsd/testfile", O_TRUNC | O_WRONLY | O_CREAT);
+			close(fd);
+			fd = open("/fs/microsd/testfile", O_RDONLY);
 
-	warnx("testing aligned writes - please wait..");
+			/* read back data for validation */
+			for (unsigned i = 0; i < iterations; i++) {
+				int rret = read(fd, read_buf, chunk_sizes[c]);
 
-	start = hrt_absolute_time();
-	for (unsigned i = 0; i < iterations; i++) {
-		perf_begin(wperf);
-		int wret = write(fd, write_buf, 512);
+				if (rret != chunk_sizes[c]) {
+					errx(1, "READ ERROR!");
+				}
+				
+				/* compare value */
+				bool compare_ok = true;
 
-		if (wret != 512) {
-			warn("WRITE ERROR!");
-		}
+				for (int j = 0; j < chunk_sizes[c]; j++) {
+					if (read_buf[j] != write_buf[j + a]) {
+						warnx("COMPARISON ERROR: byte %d, align shift: %d", j, a);
+						compare_ok = false;
+						break;
+					}
+				}
 
-		perf_end(wperf);
+				if (!compare_ok) {
+					errx(1, "ABORTING FURTHER COMPARISON DUE TO ERROR");
+				}
 
-	}
+			}
 
-	fsync(fd);
+			/*
+			 * ALIGNED WRITES AND UNALIGNED READS
+			 */
 
-	warnx("reading data aligned..");
+			close(fd);
+			int ret = unlink("/fs/microsd/testfile");
+			fd = open("/fs/microsd/testfile", O_TRUNC | O_WRONLY | O_CREAT);
 
-	close(fd);
-	fd = open("/fs/microsd/testfile", O_RDONLY);
+			warnx("testing aligned writes - please wait..");
 
-	bool align_read_ok = true;
+			start = hrt_absolute_time();
+			for (unsigned i = 0; i < iterations; i++) {
+				int wret = write(fd, write_buf, chunk_sizes[c]);
 
-	/* read back data unaligned */
-	for (unsigned i = 0; i < iterations; i++) {
-		int rret = read(fd, read_buf, 512);
+				if (wret != chunk_sizes[c]) {
+					err(1, "WRITE ERROR!");
+				}
 
-		if (rret != 512) {
-			warn("READ ERROR!");
-			break;
-		}
-		
-		/* compare value */
-		bool compare_ok = true;
-
-		for (int j = 0; j < 512; j++) {
-			if (read_buf[j] != write_buf[j]) {
-				warnx("COMPARISON ERROR: byte %d: %u != %u", j, (unsigned int)read_buf[j], (unsigned int)write_buf[j]);
-				align_read_ok = false;
-				break;
 			}
-		}
 
-		if (!align_read_ok) {
-			warnx("ABORTING FURTHER COMPARISON DUE TO ERROR");
-			break;
-		}
+			fsync(fd);
 
-	}
+			warnx("reading data aligned..");
 
-	warnx("align read result: %s\n", (align_read_ok) ? "OK" : "ERROR");
+			close(fd);
+			fd = open("/fs/microsd/testfile", O_RDONLY);
 
-	warnx("reading data unaligned..");
+			bool align_read_ok = true;
 
-	close(fd);
-	fd = open("/fs/microsd/testfile", O_RDONLY);
+			/* read back data unaligned */
+			for (unsigned i = 0; i < iterations; i++) {
+				int rret = read(fd, read_buf, chunk_sizes[c]);
 
-	bool unalign_read_ok = true;
-	int unalign_read_err_count = 0;
+				if (rret != chunk_sizes[c]) {
+					err(1, "READ ERROR!");
+				}
+				
+				/* compare value */
+				bool compare_ok = true;
 
-	memset(read_buf, 0, sizeof(read_buf));
-	read_buf[0] = 0;
+				for (int j = 0; j < chunk_sizes[c]; j++) {
+					if (read_buf[j] != write_buf[j]) {
+						warnx("COMPARISON ERROR: byte %d: %u != %u", j, (unsigned int)read_buf[j], (unsigned int)write_buf[j]);
+						align_read_ok = false;
+						break;
+					}
+				}
 
-	warnx("printing first 10 pairs:");
+				if (!align_read_ok) {
+					errx(1, "ABORTING FURTHER COMPARISON DUE TO ERROR");
+				}
 
-	uint8_t *read_ptr = &read_buf[1];
+			}
 
-	/* read back data unaligned */
-	for (unsigned i = 0; i < iterations; i++) {
-		int rret = read(fd, read_ptr, 512);
+			warnx("align read result: %s\n", (align_read_ok) ? "OK" : "ERROR");
 
-		warnx("first byte: %u (should be zero)", (unsigned int)read_buf[0]);
+			warnx("reading data unaligned..");
 
-		if (rret != 512) {
-			warn("READ ERROR!");
-			break;
-		}
+			close(fd);
+			fd = open("/fs/microsd/testfile", O_RDONLY);
 
-		for (int j = 0; j < 512; j++) {
+			bool unalign_read_ok = true;
+			int unalign_read_err_count = 0;
 
-			if (i == 0 && j < 10) {
-				warnx("read: %u, expect: %u", (unsigned int)(read_buf + 1)[j], (unsigned int)write_buf[j]);
-			}
+			memset(read_buf, 0, sizeof(read_buf));
 
-			if ((read_buf + 1)[j] != write_buf[j]) {
-				warnx("COMPARISON ERROR: byte %d, align shift: %d: %u != %u", j, 1/*(i % 64)*/, (unsigned int)read_ptr[j], (unsigned int)write_buf[j]);
-				unalign_read_ok = false;
-				unalign_read_err_count++;
-				
-				if (unalign_read_err_count > 10)
-					break;
-			}
-		}
+			/* read back data unaligned */
+			for (unsigned i = 0; i < iterations; i++) {
+				int rret = read(fd, read_buf + a, chunk_sizes[c]);
 
-		if (!unalign_read_ok) {
-			warnx("ABORTING FURTHER COMPARISON DUE TO ERROR");
-			break;
-		}
+				if (rret != chunk_sizes[c]) {
+					err(1, "READ ERROR!");
+				}
 
-	}
+				for (int j = 0; j < chunk_sizes[c]; j++) {
 
-	ret = unlink("/fs/microsd/testfile");
-	close(fd);
+					if ((read_buf + a)[j] != write_buf[j]) {
+						warnx("COMPARISON ERROR: byte %d, align shift: %d: %u != %u", j, a, (unsigned int)read_buf[j + a], (unsigned int)write_buf[j]);
+						unalign_read_ok = false;
+						unalign_read_err_count++;
+						
+						if (unalign_read_err_count > 10)
+							break;
+					}
+				}
+
+				if (!unalign_read_ok) {
+					errx(1, "ABORTING FURTHER COMPARISON DUE TO ERROR");
+				}
 
-	if (ret)
-		err(1, "UNLINKING FILE FAILED");
+			}
+
+			ret = unlink("/fs/microsd/testfile");
+			close(fd);
+
+			if (ret)
+				err(1, "UNLINKING FILE FAILED");
+
+		}
+	}
 
 	/* list directory */
-	DIR           *d;
-	struct dirent *dir;
+	DIR		*d;
+	struct dirent	*dir;
 	d = opendir("/fs/microsd");
 	if (d) {