tool/mbed/mbed-sdk/libraries/tests/mbed/sd_perf_fhandle/main.cpp

   1 #include "mbed.h"
   2 #include "SDFileSystem.h"
   3 #include "test_env.h"
   4 #include <algorithm>
   5 #include <stdlib.h>
   6
   7 #if defined(TARGET_KL25Z)
   8 SDFileSystem sd(PTD2, PTD3, PTD1, PTD0, "sd");
   9
  10 #elif defined(TARGET_KL46Z)
  11 SDFileSystem sd(PTD6, PTD7, PTD5, PTD4, "sd");
  12
  13 #elif defined(TARGET_K64F)
  14 SDFileSystem sd(PTE3, PTE1, PTE2, PTE4, "sd");
  15
  16 #elif defined(TARGET_K22F)
  17 SDFileSystem sd(PTD6, PTD7, PTD5, PTD4, "sd");
  18
  19 #elif defined(TARGET_K20D50M)
  20 SDFileSystem sd(PTD2, PTD3, PTD1, PTC2, "sd");
  21
  22 #elif defined(TARGET_nRF51822)
  23 SDFileSystem sd(p12, p13, p15, p14, "sd");
  24
  25 #elif defined(TARGET_NUCLEO_F030R8) || \
  26       defined(TARGET_NUCLEO_F070RB) || \
  27       defined(TARGET_NUCLEO_F072RB) || \
  28       defined(TARGET_NUCLEO_F091RC) || \
  29       defined(TARGET_NUCLEO_F103RB) || \
  30       defined(TARGET_NUCLEO_F302R8) || \
  31       defined(TARGET_NUCLEO_F303RE) || \
  32       defined(TARGET_NUCLEO_F334R8) || \
  33       defined(TARGET_NUCLEO_F401RE) || \
  34       defined(TARGET_NUCLEO_F411RE) || \
  35       defined(TARGET_NUCLEO_L053R8) || \
  36       defined(TARGET_NUCLEO_L073RZ) || \
  37       defined(TARGET_NUCLEO_L152RE)
  38 SDFileSystem sd(D11, D12, D13, D10, "sd");
  39
  40 #elif defined(TARGET_DISCO_F051R8)
  41 SDFileSystem sd(SPI_MOSI, SPI_MISO, SPI_SCK, SPI_CS, "sd");
  42
  43 #elif defined(TARGET_LPC2368)
  44 SDFileSystem sd(p11, p12, p13, p14, "sd");
  45
  46 #elif defined(TARGET_LPC11U68)
  47 SDFileSystem sd(D11, D12, D13, D10, "sd");
  48
  49 #elif defined(TARGET_LPC1549)
  50 SDFileSystem sd(D11, D12, D13, D10, "sd");
  51
  52 #elif defined(TARGET_LPC11U37H_401)
  53 SDFileSystem sd(SDMOSI, SDMISO, SDSCLK, SDSSEL, "sd");
  54
  55 #else
  56 SDFileSystem sd(p11, p12, p13, p14, "sd");
  57 #endif
  58
  59 namespace {
  60 char buffer[1024];
  61 const int KIB_RW = 128;
  62 Timer timer;
  63 const char *bin_filename = "testfile.bin";
  64 }
  65
  66 bool test_sf_file_write_fhandle(const char *filename, const int kib_rw) {
  67     bool result = true;
  68     FileHandle* file = sd.open(filename, O_WRONLY | O_CREAT | O_TRUNC);
  69     if (file != NULL) {
  70         int byte_write = 0;
  71         timer.start();
  72         for (int i = 0; i < kib_rw; i++) {
  73             if (file->write(buffer, sizeof(buffer)) != sizeof(buffer)) {
  74                 result = false;
  75                 file->close();
  76                 printf("Write error!\r\n");
  77                 break;
  78             } else {
  79                 byte_write++;
  80             }
  81         }
  82         timer.stop();
  83         file->close();
  84         double test_time_sec = timer.read_us() / 1000000.0;
  85         double speed = kib_rw / test_time_sec;
  86         printf("%d KiB write in %.3f sec with speed of %.4f KiB/s\r\n", byte_write, test_time_sec, speed);
  87         notify_performance_coefficient("write_kibps", speed);
  88     } else {
  89         printf("File '%s' not opened\r\n", filename);
  90         result = false;
  91     }
  92     timer.reset();
  93     return result;
  94 }
  95
  96 bool test_sf_file_read_fhandle(const char *filename, const int kib_rw) {
  97     bool result = true;
  98     FileHandle* file = sd.open(filename, O_RDONLY);
  99     if (file) {
 100         timer.start();
 101         int byte_read = 0;
 102         while (file->read(buffer, sizeof(buffer)) == sizeof(buffer)) {
 103             byte_read++;
 104         }
 105         timer.stop();
 106         file->close();
 107         double test_time_sec = timer.read_us() / 1000000.0;
 108         double speed = kib_rw / test_time_sec;
 109         printf("%d KiB read in %.3f sec with speed of %.4f KiB/s\r\n", byte_read, test_time_sec, speed);
 110         notify_performance_coefficient("fs_read_kibps", speed);
 111     } else {
 112         printf("File '%s' not opened\r\n", filename);
 113         result = false;
 114     }
 115     timer.reset();
 116     return result;
 117 }
 118
 119 char RandomChar() {
 120     return rand() % 100;
 121 }
 122
 123 int main() {
 124     MBED_HOSTTEST_TIMEOUT(15);
 125     MBED_HOSTTEST_SELECT(default_auto);
 126     MBED_HOSTTEST_DESCRIPTION(SD FileHandle RW Speed);
 127     MBED_HOSTTEST_START("PERF_2");
 128
 129     // Test header
 130     printf("\r\n");
 131     printf("SD Card FileHandle Performance Test\r\n");
 132     printf("File name: %s\r\n", bin_filename);
 133     printf("Buffer size: %d KiB\r\n", (KIB_RW * sizeof(buffer)) / 1024);
 134
 135     // Initialize buffer
 136     srand(testenv_randseed());
 137     char *buffer_end = buffer + sizeof(buffer);
 138     std::generate (buffer, buffer_end, RandomChar);
 139
 140     bool result = true;
 141     for (;;) {
 142         printf("Write test...\r\n");
 143         if (test_sf_file_write_fhandle(bin_filename, KIB_RW) == false) {
 144             result = false;
 145             break;
 146         }
 147
 148         printf("Read test...\r\n");
 149         if (test_sf_file_read_fhandle(bin_filename, KIB_RW) == false) {
 150             result = false;
 151             break;
 152         }
 153         break;
 154     }
 155     MBED_HOSTTEST_RESULT(result);
 156 }