tests: drivers: disk: disk_performance: Use sector size reported by disk

Use sector size reported by disk driver instead of assuming a fixed
512 bytes sector size.

Signed-off-by: Tim Pambor <tim.pambor@codewrights.de>

Author: tpambor

tests/drivers/disk/disk_performance/src/main.c

@@ -22,31 +22,32 @@
 #error "No disk device defined, is your board supported?"
 #endif
 
-/* Assume the largest sector we will encounter is 512 bytes */
-#define SECTOR_SIZE 512
 #if CONFIG_SRAM_SIZE >= 512
 /* Cap buffer size at 128 KiB */
-#define SEQ_BLOCK_COUNT 256
+#define MAX_TOTAL_BUF_SIZE 128
 #elif CONFIG_SOC_POSIX
 /* Posix does not define SRAM size */
-#define SEQ_BLOCK_COUNT 256
+#define MAX_TOTAL_BUF_SIZE 128
 #else
-/* Two buffers with 512 byte blocks will use half of all SRAM */
-#define SEQ_BLOCK_COUNT (CONFIG_SRAM_SIZE / 2)
+/* Use half of all SRAM */
+#define MAX_TOTAL_BUF_SIZE (CONFIG_SRAM_SIZE / 2)
 #endif
-#define BUF_SIZE (SECTOR_SIZE * SEQ_BLOCK_COUNT)
+
+#define BUF_SIZE ((MAX_TOTAL_BUF_SIZE * 1024) / 2)
+
 /* Number of sequential reads to get an average speed */
 #define SEQ_ITERATIONS 10
-/* Number of random reads to get an IOPS calculation */
-#define RANDOM_ITERATIONS SEQ_BLOCK_COUNT
+/* Maximum number of random reads to get an IOPS calculation */
+#define MAX_RANDOM_ITERATIONS 10
 
-static uint32_t chosen_sectors[RANDOM_ITERATIONS];
+static uint32_t chosen_sectors[MAX_RANDOM_ITERATIONS];
 
 
 static const char *disk_pdrv = DISK_NAME;
 static uint32_t disk_sector_count;
 static uint32_t disk_sector_size;
 
+static uint32_t buf_sector_count;
 static uint8_t test_buf[BUF_SIZE] __aligned(32);
 static uint8_t backup_buf[BUF_SIZE] __aligned(32);
 
@@ -75,9 +76,11 @@ static void test_setup(void)
 	TC_PRINT("Disk reports sector size %u\n", cmd_buf);
 	disk_sector_size = cmd_buf;
 
-	/* Assume sector size is 512 bytes, it will speed up calculations later */
-	zassert_true(cmd_buf == SECTOR_SIZE,
-		"Test will fail, SECTOR_SIZE definition must be changed");
+	buf_sector_count = BUF_SIZE / disk_sector_size;
+
+	/* Verify that the buffer can hold at least one sector */
+	zassert_true(buf_sector_count >= 1,
+		"Test will fail, sector does not fit in buffer, buffer size must be increased");
 
 	disk_init_done = true;
 }
@@ -125,14 +128,14 @@ ZTEST(disk_performance, test_sequential_read)
 	time_ns = read_helper(1);
 
 	TC_PRINT("Average read speed over one sector: %"PRIu64" KiB/s\n",
-		((SECTOR_SIZE * (NSEC_PER_SEC / time_ns))) / 1024);
+		((disk_sector_size * (NSEC_PER_SEC / time_ns))) / 1024);
 
 	/* Now time long sequential read */
-	time_ns = read_helper(SEQ_BLOCK_COUNT);
+	time_ns = read_helper(buf_sector_count);
 
 	TC_PRINT("Average read speed over %d sectors: %"PRIu64" KiB/s\n",
-		SEQ_BLOCK_COUNT,
-		((BUF_SIZE) * (NSEC_PER_SEC / time_ns)) / 1024);
+		buf_sector_count,
+		((disk_sector_size * buf_sector_count) * (NSEC_PER_SEC / time_ns)) / 1024);
 }
 
 /* Helper function to time multiple sequential writes. Returns average time. */
@@ -151,7 +154,7 @@ static uint64_t write_helper(uint32_t num_blocks)
 	zassert_equal(rc, 0, "disk read failed");
 
 	/* Initialize write buffer with data */
-	sys_rand_get(test_buf, num_blocks * SECTOR_SIZE);
+	sys_rand_get(test_buf, num_blocks * disk_sector_size);
 
 	total_ns = 0;
 	for (int i = 0; i < SEQ_ITERATIONS; i++) {
@@ -188,29 +191,30 @@ ZTEST(disk_performance, test_sequential_write)
 	time_ns = write_helper(1);
 
 	TC_PRINT("Average write speed over one sector: %"PRIu64" KiB/s\n",
-		((SECTOR_SIZE * (NSEC_PER_SEC / time_ns))) / 1024);
+		((disk_sector_size * (NSEC_PER_SEC / time_ns))) / 1024);
 
 	/* Now time long sequential write */
-	time_ns = write_helper(SEQ_BLOCK_COUNT);
+	time_ns = write_helper(buf_sector_count);
 
 	TC_PRINT("Average write speed over %d sectors: %"PRIu64" KiB/s\n",
-		SEQ_BLOCK_COUNT,
-		((BUF_SIZE) * (NSEC_PER_SEC / time_ns)) / 1024);
+		buf_sector_count,
+		((disk_sector_size * buf_sector_count) * (NSEC_PER_SEC / time_ns)) / 1024);
 }
 
 ZTEST(disk_performance, test_random_read)
 {
 	timing_t start_time, end_time;
 	uint64_t cycles, total_ns;
 	uint32_t sector;
-	int rc;
+	int rc = 0;
+	uint32_t random_iterations = MIN(MAX_RANDOM_ITERATIONS, buf_sector_count);
 
 	if (!disk_init_done) {
 		zassert_unreachable("Disk is not initialized");
 	}
 
 	/* Build list of sectors to read from. */
-	for (int i = 0; i < RANDOM_ITERATIONS; i++) {
+	for (int i = 0; i < random_iterations; i++) {
 		/* Get random num until we select a value within sector count */
 		sector = sys_rand32_get() / ((UINT32_MAX / disk_sector_count) + 1);
 		chosen_sectors[i] = sector;
@@ -221,7 +225,7 @@ ZTEST(disk_performance, test_random_read)
 	timing_start();
 
 	start_time = timing_counter_get();
-	for (int i = 0; i < RANDOM_ITERATIONS; i++) {
+	for (int i = 0; i < random_iterations; i++) {
 		/*
 		 * Note: we don't check return code here,
 		 * we want to do I/O as fast as possible
@@ -235,9 +239,10 @@ ZTEST(disk_performance, test_random_read)
 	/* Stop timing system */
 	timing_stop();
 
-	TC_PRINT("512 Byte IOPS over %d random reads: %"PRIu64" IOPS\n",
-		RANDOM_ITERATIONS,
-		((uint64_t)(((uint64_t)RANDOM_ITERATIONS)*
+	TC_PRINT("%d Byte IOPS over %d random reads: %"PRIu64" IOPS\n",
+		disk_sector_size,
+		random_iterations,
+		((uint64_t)(((uint64_t)random_iterations)*
 		((uint64_t)NSEC_PER_SEC)))
 		/ total_ns);
 }
@@ -247,19 +252,20 @@ ZTEST(disk_performance, test_random_write)
 	timing_t start_time, end_time;
 	uint64_t cycles, total_ns;
 	uint32_t sector;
-	int rc;
+	int rc = 0;
+	uint32_t random_iterations = MIN(MAX_RANDOM_ITERATIONS, buf_sector_count);
 
 	if (!disk_init_done) {
 		zassert_unreachable("Disk is not initialized");
 	}
 
 	/* Build list of sectors to read from. */
-	for (int i = 0; i < RANDOM_ITERATIONS; i++) {
+	for (int i = 0; i < random_iterations; i++) {
 		/* Get random num until we select a value within sector count */
 		sector = sys_rand32_get() / ((UINT32_MAX / disk_sector_count) + 1);
 		chosen_sectors[i] = sector;
 		/* Backup this sector */
-		rc = disk_access_read(disk_pdrv, &backup_buf[i * SECTOR_SIZE],
+		rc = disk_access_read(disk_pdrv, &backup_buf[i * disk_sector_size],
 			sector, 1);
 		zassert_equal(rc, 0, "disk read failed for random write backup");
 	}
@@ -272,12 +278,12 @@ ZTEST(disk_performance, test_random_write)
 	timing_start();
 
 	start_time = timing_counter_get();
-	for (int i = 0; i < RANDOM_ITERATIONS; i++) {
+	for (int i = 0; i < random_iterations; i++) {
 		/*
 		 * Note: we don't check return code here,
 		 * we want to do I/O as fast as possible
 		 */
-		rc = disk_access_write(disk_pdrv, &test_buf[i * SECTOR_SIZE],
+		rc = disk_access_write(disk_pdrv, &test_buf[i * disk_sector_size],
 			chosen_sectors[i], 1);
 	}
 	end_time = timing_counter_get();
@@ -287,14 +293,15 @@ ZTEST(disk_performance, test_random_write)
 	/* Stop timing system */
 	timing_stop();
 
-	TC_PRINT("512 Byte IOPS over %d random writes: %"PRIu64" IOPS\n",
-		RANDOM_ITERATIONS,
-		((uint64_t)(((uint64_t)RANDOM_ITERATIONS)*
+	TC_PRINT("%d Byte IOPS over %d random writes: %"PRIu64" IOPS\n",
+		disk_sector_size,
+		random_iterations,
+		((uint64_t)(((uint64_t)random_iterations)*
 		((uint64_t)NSEC_PER_SEC)))
 		/ total_ns);
 	/* Restore backed up sectors */
-	for (int i = 0; i < RANDOM_ITERATIONS; i++) {
-		disk_access_write(disk_pdrv, &backup_buf[i * SECTOR_SIZE],
+	for (int i = 0; i < random_iterations; i++) {
+		disk_access_write(disk_pdrv, &backup_buf[i * disk_sector_size],
 			chosen_sectors[i], 1);
 		zassert_equal(rc, 0, "failed to write backup sector to disk");
 	}