tests/sdcard/sdcard_perf_test.cpp - platform/system/extras - Git at Google

 /*
  * Copyright (C) 2009 The Android Open Source Project
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *  * Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *  * Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */

 #include <cstdio>
 #include <cstdlib>
 #include <ctime>
 #include <errno.h>
 #include <fcntl.h>
 #include <getopt.h>
 #include <limits.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <linux/fadvise.h>
 #include <unistd.h>
 #include <fts.h>

 #include "stopwatch.h"
 #include "sysutil.h"
 #include "testcase.h"

 // Stress test for the sdcard. Use this to generate some load on the
 // sdcard and collect performance statistics. The output is either a
 // human readable report or the raw timing samples that can be
 // processed using another tool.
 //
 // Needs debugfs:
 //   adb root;
 //   adb shell mount -t debugfs none /sys/kernel/debug
 //
 // The following tests are defined (value of the --test flag):
 //  write:       Open a file write some random data and close.
 //  read:        Open a file read it and close.
 //  read_write:  Combine readers and writers.
 //  open_create: Open|create an non existing file.
 //
 // For each run you can control how many processes will run the test in
 // parallel to simulate a real load (--procnb flag)
 //
 // For each process, the test selected will be executed many time to
 // get a meaningful average/min/max (--iterations flag)
 //
 // Use --dump to also get the raw data.
 //
 // For read/write tests, size is the number of Kbytes to use.
 //
 // To build: mmm system/extras/tests/sdcard/Android.mk SDCARD_TESTS=1
 //
 // Examples:
 // adb shell /system/bin/sdcard_perf_test --test=read --size=1000 --chunk-size=100 --procnb=1 --iterations=10 --dump > /tmp/data.txt
 // adb shell /system/bin/sdcard_perf_test --test=write --size=1000 --chunk-size=100 --procnb=1 --iterations=100 --dump > /tmp/data.txt
 //
 // To watch the memory: cat /proc/meminfo
 // If the phone crashes, look at /proc/last_kmsg on reboot.
 //
 // TODO: It would be cool if we could play with various fadvise()
 // strategies in here to see how tweaking read-ahead changes things.
 //

 extern char *optarg;
 extern int optind, opterr, optopt;

 // TODO: No clue where fadvise is. Disabled for now.
 #define FADVISE(fd, off, len, advice) (void)0

 #ifndef min
 #define min(a,b) (((a)>(b))?(b):(a))
 #endif

 namespace  {
 using android::kernelVersion;
 using android::kMinKernelVersionBufferSize;
 using android::schedFeatures;
 using android::kMinSchedFeaturesBufferSize;
 using android_test::StopWatch;
 using android::writePidAndWaitForReply;
 using android::waitForChildrenAndSignal;
 using android::waitForChildrenOrExit;
 using android_test::TestCase;

 const char *kAppName = "sdcard_perf_test";
 const char *kTestDir = "/sdcard/perf";
 const bool kVerbose = false;

 // Used by getopt to parse the command line.
 struct option long_options[] = {
     {"size", required_argument, 0, 's'},
     {"chunk-size", required_argument, 0, 'S'},
     {"depth", required_argument, 0, 'D'},
     {"iterations",  required_argument, 0, 'i'},
     {"procnb",  required_argument, 0, 'p'},
     {"test",  required_argument, 0, 't'},
     {"dump",  no_argument, 0, 'd'},
     {"cpu-scaling",  no_argument, 0, 'c'},
     {"sync",  required_argument, 0, 'f'},
     {"truncate", no_argument, 0, 'e'},
     {"no-new-fair-sleepers", no_argument, 0, 'z'},
     {"no-normalized-sleepers", no_argument, 0, 'Z'},
     {"fadvise", required_argument, 0, 'a'},
     {"help", no_argument, 0, 'h'},
     {0, 0, 0, 0},
 };

 void usage()
 {
     printf("sdcard_perf_test --test=write|read|read_write|open_create|traverse [options]\n\n"
            "  -t --test:        Select the test.\n"
            "  -s --size:        Size in kbytes of the data.\n"
            "  -S --chunk-size:  Size of a chunk. Default to size ie 1 chunk.\n"
            "                    Data will be written/read using that chunk size.\n"
            "  -D --depth:       Depth of directory tree to create for traversal.\n",
            "  -i --iterations:  Number of time a process should carry its task.\n"
            "  -p --procnb:      Number of processes to use.\n"
            "  -d --dump:        Print the raw timing on stdout.\n"
            "  -c --cpu-scaling: Enable cpu scaling.\n"
            "  -s --sync: fsync|sync Use fsync or sync in write test. Default: no sync call.\n"
            "  -e --truncate:    Truncate to size the file on creation.\n"
            "  -z --no-new-fair-sleepers: Turn them off. You need to mount debugfs.\n"
            "  -Z --no-normalized-sleepers: Turn them off. You need to mount debugfs.\n"
            "  -a --fadvise:     Specify an fadvise policy (not supported).\n"
            );
 }

 // Print command line, pid, kernel version, OOM adj and scheduler.
 void printHeader(int argc, char **argv, const TestCase& testCase)
 {
     printf("# Command: ");
     for (int i = 0; i < argc; ++i)
     {
         printf("%s ", argv[i]);
     }
     printf("\n");

     printf("# Pid: %d\n", getpid());

     {
         char buffer[kMinKernelVersionBufferSize] = {0, };
         if (kernelVersion(buffer, sizeof(buffer)) > 0)
         {
             printf("# Kernel: %s", buffer);
         }
     }

     // Earlier on, running this test was crashing the phone. It turned
     // out that it was using too much memory but its oom_adj value was
     // -17 which means disabled. -16 is the system_server and 0 is
     // typically what applications run at. The issue is that adb runs
     // at -17 and so is this test. We force oom_adj to 0 unless the
     // oom_adj option has been used.
     // TODO: We talked about adding an option to control oom_adj, not
     // sure if we still need that.
     int oomAdj = android::pidOutOfMemoryAdj();

     printf("# Oom_adj: %d ", oomAdj);
     if (oomAdj < 0)
     {
         android::setPidOutOfMemoryAdj(0);
         printf("adjuted to %d", android::pidOutOfMemoryAdj());
     }
     printf("\n");

     {
         char buffer[kMinSchedFeaturesBufferSize] = {0, };
         if (schedFeatures(buffer, sizeof(buffer)) > 0)
         {
             printf("# Sched features: %s", buffer);
         }
     }
     printf("# Fadvise: %s\n", testCase.fadviseAsStr());
 }

 // Remove all the files under kTestDir and clear the caches.
 void cleanup() {
     android::resetDirectory(kTestDir);
     android::syncAndDropCaches();  // don't pollute runs.
 }

 // @param argc, argv have a wild guess.
 // @param[out] testCase Structure built from the cmd line args.
 void parseCmdLine(int argc, char **argv, TestCase *testCase)\
 {
     int c;

     while(true)
     {
         // getopt_long stores the option index here.
         int option_index = 0;

         c = getopt_long (argc, argv,
                          "hS:s:D:i:p:t:dcf:ezZa:",
                          long_options,
                          &option_index);
         // Detect the end of the options.
         if (c == -1) break;

         switch (c)
         {
             case 's':
                 testCase->setDataSize(atoi(optarg) * 1024);
                 break;
             case 'S':
                 testCase->setChunkSize(atoi(optarg) * 1024);
                 break;
             case 'D': // tree depth
                 testCase->setTreeDepth(atoi(optarg));
                 break;
             case 'i':
                 testCase->setIter(atoi(optarg));
                 printf("# Iterations: %d\n", testCase->iter());
                 break;
             case 'p':
                 testCase->setNproc(atoi(optarg));
                 printf("# Proc nb: %d\n", testCase->nproc());
                 break;
             case 't':
                 testCase->setTypeFromName(optarg);
                 printf("# Test name %s\n", testCase->name());
                 break;
             case 'd':
                 testCase->setDump();
                 break;
             case 'c':
                 printf("# Cpu scaling is on\n");
                 testCase->setCpuScaling();
                 break;
             case 'f':
                 if (strcmp("sync", optarg) == 0) {
                     testCase->setSync(TestCase::SYNC);
                 } else if (strcmp("fsync", optarg) == 0) {
                     testCase->setSync(TestCase::FSYNC);
                 }
                 break;
             case 'e':  // e for empty
                 printf("# Will truncate to size\n");
                 testCase->setTruncateToSize();
                 break;
             case 'z':  // no new fair sleepers
                 testCase->setNewFairSleepers(false);
                 break;
             case 'Z':  // no normalized sleepers
                 testCase->setNormalizedSleepers(false);
                 break;
             case 'a':  // fadvise
                 testCase->setFadvise(optarg);
                 break;
             case 'h':
                 usage();
                 exit(0);
             default:
                 fprintf(stderr, "Unknown option %s\n", optarg);
                 exit(EXIT_FAILURE);
         }
     }
 }

 // ----------------------------------------------------------------------
 // READ TEST

 // Read a file.  We use a new file each time to avoid any caching
 // effect that would happen if we were reading the same file each
 // time.
 // @param chunk buffer large enough where the chunk read are written.
 // @param idx iteration number.
 // @param testCase has all the timers and paramters to run the test.

 bool readData(char *const chunk, const int idx, TestCase *testCase)
 {
     char filename[80] = {'\0',};

     sprintf(filename, "%s/file-%d-%d", kTestDir, idx, getpid());

     testCase->openTimer()->start();
     int fd = open(filename, O_RDONLY);
     testCase->openTimer()->stop();

     if (fd < 0)
     {
         fprintf(stderr, "Open read only failed.");
         return false;
     }
     FADVISE(fd, 0, 0, testCase->fadvise());

     size_t left = testCase->dataSize();
     pid_t *pid = (pid_t*)chunk;
     while (left > 0)
     {
         char *dest = chunk;
         size_t chunk_size = testCase->chunkSize();

         if (chunk_size > left)
         {
             chunk_size = left;
             left = 0;
         }
         else
         {
             left -= chunk_size;
         }

         testCase->readTimer()->start();
         while (chunk_size > 0)
         {
             ssize_t s = read(fd, dest, chunk_size);
             if (s < 0)
             {
                 fprintf(stderr, "Failed to read.\n");
                 close(fd);
                 return false;
             }
             chunk_size -= s;
             dest += s;
         }
         testCase->readTimer()->stop();
     }
     close(fd);
     if (testCase->pid() != *pid)
     {
         fprintf(stderr, "Wrong pid found @ read block %x != %x\n", testCase->pid(), *pid);
         return false;
     }
     else
     {
         return true;
     }
 }


 bool testRead(TestCase *testCase) {
     // Setup the testcase by writting some dummy files.
     const size_t size = testCase->dataSize();
     size_t chunk_size = testCase->chunkSize();
     char *const chunk = new char[chunk_size];

     memset(chunk, 0xaa, chunk_size);
     *((pid_t *)chunk) = testCase->pid(); // write our pid at the beginning of each chunk

     size_t iter = testCase->iter();

     // since readers are much faster we increase the number of
     // iteration to last longer and have concurrent read/write
     // thoughout the whole test.
     if (testCase->type() == TestCase::READ_WRITE)
     {
         iter *= TestCase::kReadWriteFactor;
     }

     for (size_t i = 0; i < iter; ++i)
     {
         char filename[80] = {'\0',};

         sprintf(filename, "%s/file-%d-%d", kTestDir, i, testCase->pid());
         int fd = open(filename, O_RDWR | O_CREAT, S_IRWXU);

         size_t left = size;
         while (left > 0)
         {
             if (chunk_size > left)
             {
                 chunk_size = left;
             }
             ssize_t written = write(fd, chunk, chunk_size);
             if (written < 0)
             {
                 fprintf(stderr, "Write failed %d %s.", errno, strerror(errno));
                 return false;
             }
             left -= written;
         }
         close(fd);
     }
     if (kVerbose) printf("Child %d all chunk written\n", testCase->pid());

     android::syncAndDropCaches();
     testCase->signalParentAndWait();

     // Start the read test.
     testCase->testTimer()->start();
     for (size_t i = 0; i < iter; ++i)
     {
         if (!readData(chunk, i, testCase))
         {
             return false;
         }
     }
     testCase->testTimer()->stop();

     delete [] chunk;
     return true;
 }

 // ----------------------------------------------------------------------
 // WRITE TEST

 bool writeData(const char *const chunk, const int idx, TestCase *testCase) {
     char filename[80] = {'\0',};

     sprintf(filename, "%s/file-%d-%d", kTestDir, idx, getpid());
     testCase->openTimer()->start();
     int fd = open(filename, O_RDWR | O_CREAT, S_IRWXU);  // no O_TRUNC, see header comment
     testCase->openTimer()->stop();

     if (fd < 0)
     {
         fprintf(stderr, "Open write failed.");
         return false;
     }
     FADVISE(fd, 0, 0, testCase->fadvise());

     if (testCase->truncateToSize())
     {
         testCase->truncateTimer()->start();
         ftruncate(fd, testCase->dataSize());
         testCase->truncateTimer()->stop();
     }

     size_t left = testCase->dataSize();
     while (left > 0)
     {
         const char *dest = chunk;
         size_t chunk_size = testCase->chunkSize();

         if (chunk_size > left)
         {
             chunk_size = left;
             left = 0;
         }
         else
         {
             left -= chunk_size;
         }


         testCase->writeTimer()->start();
         while (chunk_size > 0)
         {
             ssize_t s = write(fd, dest, chunk_size);
             if (s < 0)
             {
                 fprintf(stderr, "Failed to write.\n");
                 close(fd);
                 return false;
             }
             chunk_size -= s;
             dest += s;
         }
         testCase->writeTimer()->stop();
     }

     if (TestCase::FSYNC == testCase->sync())
     {
         testCase->syncTimer()->start();
         fsync(fd);
         testCase->syncTimer()->stop();
     }
     else if (TestCase::SYNC == testCase->sync())
     {
         testCase->syncTimer()->start();
         sync();
         testCase->syncTimer()->stop();
     }
     close(fd);
     return true;
 }

 bool testWrite(TestCase *testCase)
 {
     const size_t size = testCase->dataSize();
     size_t chunk_size = testCase->chunkSize();
     char *data = new char[chunk_size];

     memset(data, 0xaa, chunk_size);
     // TODO: write the pid at the beginning like in the write
     // test. Have a mode where we check the write was correct.
     testCase->signalParentAndWait();

     testCase->testTimer()->start();
     for (size_t i = 0; i < testCase->iter(); ++i)
     {
         if (!writeData(data, i, testCase))
         {
             return false;
         }
     }
     testCase->testTimer()->stop();
     delete [] data;
     return true;
 }


 // ----------------------------------------------------------------------
 // READ WRITE

 // Mix of read and write test. Even PID run the write test. Odd PID
 // the read test. Not fool proof but work most of the time.
 bool testReadWrite(TestCase *testCase)
 {
     if (getpid() & 0x1) {
         return testRead(testCase);
     } else {
         return testWrite(testCase);
     }
 }

 // ----------------------------------------------------------------------
 // OPEN CREATE TEST

 bool testOpenCreate(TestCase *testCase)
 {
     char filename[80] = {'\0',};

     testCase->signalParentAndWait();
     testCase->testTimer()->start();

     for (size_t i = 0; i < testCase->iter(); ++i)
     {
         sprintf(filename, "%s/file-%d-%d", kTestDir, i, testCase->pid());

         int fd = open(filename, O_RDWR | O_CREAT, S_IRWXU);
         FADVISE(fd, 0, 0, testCase->fadvise());

         if (testCase->truncateToSize())
         {
             ftruncate(fd, testCase->dataSize());
         }
         if (fd < 0)
         {
             return false;
         }
         close(fd);
     }
     testCase->testTimer()->stop();
     return true;
 }

 bool writeTestFile(TestCase *testCase, const char* filename) {
     int fd = open(filename, O_RDWR | O_CREAT, S_IRWXU);
     if (fd < 0) {
         fprintf(stderr, "open() failed: %s\n", strerror(errno));
         return false;
     }

     bool res = false;

     char * const chunk = new char[testCase->chunkSize()];
     memset(chunk, 0xaa, testCase->chunkSize());

     size_t left = testCase->dataSize();
     while (left > 0) {
         char *dest = chunk;
         size_t chunk_size = testCase->chunkSize();

         if (chunk_size > left) {
             chunk_size = left;
             left = 0;
         } else {
             left -= chunk_size;
         }

         while (chunk_size > 0) {
             ssize_t s = write(fd, dest, chunk_size);
             if (s < 0) {
                 fprintf(stderr, "write() failed: %s\n", strerror(errno));
                 goto fail;
             }
             chunk_size -= s;
             dest += s;
         }
     }

     res = true;
 fail:
     close(fd);
     delete[] chunk;
     return res;
 }

 // ----------------------------------------------------------------------
 // TRAVERSE

 #define MAX_PATH 512

 // Creates a directory tree that is both deep and wide, and times
 // traversal using fts_open().
 bool testTraverse(TestCase *testCase) {
     char path[MAX_PATH];
     char filepath[MAX_PATH];
     strcpy(path, kTestDir);

     // Generate a deep directory hierarchy
     size_t depth = testCase->treeDepth();
     for (size_t i = 0; i < depth; i++) {
         // Go deeper by appending onto current path
         snprintf(path + strlen(path), MAX_PATH - strlen(path), "/dir%d", i);
         mkdir(path, S_IRWXU);

         // Create some files at this depth
         strcpy(filepath, path);
         int pathlen = strlen(path);
         char* nameStart = filepath + pathlen;
         for (size_t j = 0; j < depth; j++) {
             snprintf(nameStart, MAX_PATH - pathlen, "/file%d", j);
             writeTestFile(testCase, filepath);
         }
     }

     testCase->signalParentAndWait();
     testCase->testTimer()->start();

     // Now traverse structure
     size_t iter = testCase->iter();
     for (size_t i = 0; i < iter; i++) {
         testCase->traverseTimer()->start();

         FTS *ftsp;
         if ((ftsp = fts_open((char **) &kTestDir, FTS_LOGICAL | FTS_XDEV, NULL)) == NULL) {
             fprintf(stderr, "fts_open() failed: %s\n", strerror(errno));
             return false;
         }

         // Count discovered files
         int dirs = 0, files = 0;

         FTSENT *curr;
         while ((curr = fts_read(ftsp)) != NULL) {
             switch (curr->fts_info) {
             case FTS_D:
                 dirs++;
                 break;
             case FTS_F:
                 files++;
                 break;
             }
         }

         fts_close(ftsp);

         testCase->traverseTimer()->stop();

         int expectedDirs = depth + 1;
         if (expectedDirs != dirs) {
             fprintf(stderr, "expected %d dirs, but found %d\n", expectedDirs, dirs);
             return false;
         }

         int expectedFiles = depth * depth;
         if (expectedFiles != files) {
             fprintf(stderr, "expected %d files, but found %d\n", expectedFiles, files);
             return false;
         }
     }

     testCase->testTimer()->stop();
     return true;
 }

 }  // anonymous namespace

 int main(int argc, char **argv)
 {
     android_test::TestCase testCase(kAppName);

     cleanup();

     parseCmdLine(argc, argv, &testCase);
     printHeader(argc, argv, testCase);

     printf("# File size %d kbytes\n", testCase.dataSize() / 1024);
     printf("# Chunk size %d kbytes\n", testCase.chunkSize() / 1024);
     printf("# Sync: %s\n", testCase.syncAsStr());

     if (!testCase.cpuScaling())
     {
         android::disableCpuScaling();
     }

     switch(testCase.type()) {
         case TestCase::WRITE:
             testCase.mTestBody = testWrite;
             break;
         case TestCase::READ:
             testCase.mTestBody = testRead;
             break;
         case TestCase::OPEN_CREATE:
             testCase.mTestBody = testOpenCreate;
             break;
         case TestCase::READ_WRITE:
             testCase.mTestBody = testReadWrite;
             break;
         case TestCase::TRAVERSE:
             testCase.mTestBody = testTraverse;
             break;
         default:
             fprintf(stderr, "Unknown test type %s", testCase.name());
             exit(EXIT_FAILURE);
     }

     testCase.createTimers();

     bool ok;

     ok = testCase.runTest();

     cleanup();
     if (!ok)
     {
         printf("error %d %s", errno, strerror(errno));
         exit(EXIT_FAILURE);
     }
     else
     {
         exit(EXIT_SUCCESS);
     }
 }
	/*
	* Copyright (C) 2009 The Android Open Source Project
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* * Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in
	* the documentation and/or other materials provided with the
	* distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	* SUCH DAMAGE.
	*/

	#include <cstdio>
	#include <cstdlib>
	#include <ctime>
	#include <errno.h>
	#include <fcntl.h>
	#include <getopt.h>
	#include <limits.h>
	#include <string.h>
	#include <sys/stat.h>
	#include <linux/fadvise.h>
	#include <unistd.h>
	#include <fts.h>

	#include "stopwatch.h"
	#include "sysutil.h"
	#include "testcase.h"

	// Stress test for the sdcard. Use this to generate some load on the
	// sdcard and collect performance statistics. The output is either a
	// human readable report or the raw timing samples that can be
	// processed using another tool.
	//
	// Needs debugfs:
	// adb root;
	// adb shell mount -t debugfs none /sys/kernel/debug
	//
	// The following tests are defined (value of the --test flag):
	// write: Open a file write some random data and close.
	// read: Open a file read it and close.
	// read_write: Combine readers and writers.
	// open_create: Open\|create an non existing file.
	//
	// For each run you can control how many processes will run the test in
	// parallel to simulate a real load (--procnb flag)
	//
	// For each process, the test selected will be executed many time to
	// get a meaningful average/min/max (--iterations flag)
	//
	// Use --dump to also get the raw data.
	//
	// For read/write tests, size is the number of Kbytes to use.
	//
	// To build: mmm system/extras/tests/sdcard/Android.mk SDCARD_TESTS=1
	//
	// Examples:
	// adb shell /system/bin/sdcard_perf_test --test=read --size=1000 --chunk-size=100 --procnb=1 --iterations=10 --dump > /tmp/data.txt
	// adb shell /system/bin/sdcard_perf_test --test=write --size=1000 --chunk-size=100 --procnb=1 --iterations=100 --dump > /tmp/data.txt
	//
	// To watch the memory: cat /proc/meminfo
	// If the phone crashes, look at /proc/last_kmsg on reboot.
	//
	// TODO: It would be cool if we could play with various fadvise()
	// strategies in here to see how tweaking read-ahead changes things.
	//

	extern char *optarg;
	extern int optind, opterr, optopt;

	// TODO: No clue where fadvise is. Disabled for now.
	#define FADVISE(fd, off, len, advice) (void)0

	#ifndef min
	#define min(a,b) (((a)>(b))?(b):(a))
	#endif

	namespace {
	using android::kernelVersion;
	using android::kMinKernelVersionBufferSize;
	using android::schedFeatures;
	using android::kMinSchedFeaturesBufferSize;
	using android_test::StopWatch;
	using android::writePidAndWaitForReply;
	using android::waitForChildrenAndSignal;
	using android::waitForChildrenOrExit;
	using android_test::TestCase;

	const char *kAppName = "sdcard_perf_test";
	const char *kTestDir = "/sdcard/perf";
	const bool kVerbose = false;

	// Used by getopt to parse the command line.
	struct option long_options[] = {
	{"size", required_argument, 0, 's'},
	{"chunk-size", required_argument, 0, 'S'},
	{"depth", required_argument, 0, 'D'},
	{"iterations", required_argument, 0, 'i'},
	{"procnb", required_argument, 0, 'p'},
	{"test", required_argument, 0, 't'},
	{"dump", no_argument, 0, 'd'},
	{"cpu-scaling", no_argument, 0, 'c'},
	{"sync", required_argument, 0, 'f'},
	{"truncate", no_argument, 0, 'e'},
	{"no-new-fair-sleepers", no_argument, 0, 'z'},
	{"no-normalized-sleepers", no_argument, 0, 'Z'},
	{"fadvise", required_argument, 0, 'a'},
	{"help", no_argument, 0, 'h'},
	{0, 0, 0, 0},
	};

	void usage()
	{
	printf("sdcard_perf_test --test=write\|read\|read_write\|open_create\|traverse [options]\n\n"
	" -t --test: Select the test.\n"
	" -s --size: Size in kbytes of the data.\n"
	" -S --chunk-size: Size of a chunk. Default to size ie 1 chunk.\n"
	" Data will be written/read using that chunk size.\n"
	" -D --depth: Depth of directory tree to create for traversal.\n",
	" -i --iterations: Number of time a process should carry its task.\n"
	" -p --procnb: Number of processes to use.\n"
	" -d --dump: Print the raw timing on stdout.\n"
	" -c --cpu-scaling: Enable cpu scaling.\n"
	" -s --sync: fsync\|sync Use fsync or sync in write test. Default: no sync call.\n"
	" -e --truncate: Truncate to size the file on creation.\n"
	" -z --no-new-fair-sleepers: Turn them off. You need to mount debugfs.\n"
	" -Z --no-normalized-sleepers: Turn them off. You need to mount debugfs.\n"
	" -a --fadvise: Specify an fadvise policy (not supported).\n"
	);
	}

	// Print command line, pid, kernel version, OOM adj and scheduler.
	void printHeader(int argc, char **argv, const TestCase& testCase)
	{
	printf("# Command: ");
	for (int i = 0; i < argc; ++i)
	{
	printf("%s ", argv[i]);
	}
	printf("\n");

	printf("# Pid: %d\n", getpid());

	{
	char buffer[kMinKernelVersionBufferSize] = {0, };
	if (kernelVersion(buffer, sizeof(buffer)) > 0)
	{
	printf("# Kernel: %s", buffer);
	}
	}

	// Earlier on, running this test was crashing the phone. It turned
	// out that it was using too much memory but its oom_adj value was
	// -17 which means disabled. -16 is the system_server and 0 is
	// typically what applications run at. The issue is that adb runs
	// at -17 and so is this test. We force oom_adj to 0 unless the
	// oom_adj option has been used.
	// TODO: We talked about adding an option to control oom_adj, not
	// sure if we still need that.
	int oomAdj = android::pidOutOfMemoryAdj();

	printf("# Oom_adj: %d ", oomAdj);
	if (oomAdj < 0)
	{
	android::setPidOutOfMemoryAdj(0);
	printf("adjuted to %d", android::pidOutOfMemoryAdj());
	}
	printf("\n");

	{
	char buffer[kMinSchedFeaturesBufferSize] = {0, };
	if (schedFeatures(buffer, sizeof(buffer)) > 0)
	{
	printf("# Sched features: %s", buffer);
	}
	}
	printf("# Fadvise: %s\n", testCase.fadviseAsStr());
	}

	// Remove all the files under kTestDir and clear the caches.
	void cleanup() {
	android::resetDirectory(kTestDir);
	android::syncAndDropCaches(); // don't pollute runs.
	}

	// @param argc, argv have a wild guess.
	// @param[out] testCase Structure built from the cmd line args.
	void parseCmdLine(int argc, char *argv, TestCase testCase)\
	{
	int c;

	while(true)
	{
	// getopt_long stores the option index here.
	int option_index = 0;

	c = getopt_long (argc, argv,
	"hS:s:D:i:p:t:dcf:ezZa:",
	long_options,
	&option_index);
	// Detect the end of the options.
	if (c == -1) break;

	switch (c)
	{
	case 's':
	testCase->setDataSize(atoi(optarg) * 1024);
	break;
	case 'S':
	testCase->setChunkSize(atoi(optarg) * 1024);
	break;
	case 'D': // tree depth
	testCase->setTreeDepth(atoi(optarg));
	break;
	case 'i':
	testCase->setIter(atoi(optarg));
	printf("# Iterations: %d\n", testCase->iter());
	break;
	case 'p':
	testCase->setNproc(atoi(optarg));
	printf("# Proc nb: %d\n", testCase->nproc());
	break;
	case 't':
	testCase->setTypeFromName(optarg);
	printf("# Test name %s\n", testCase->name());
	break;
	case 'd':
	testCase->setDump();
	break;
	case 'c':
	printf("# Cpu scaling is on\n");
	testCase->setCpuScaling();
	break;
	case 'f':
	if (strcmp("sync", optarg) == 0) {
	testCase->setSync(TestCase::SYNC);
	} else if (strcmp("fsync", optarg) == 0) {
	testCase->setSync(TestCase::FSYNC);
	}
	break;
	case 'e': // e for empty
	printf("# Will truncate to size\n");
	testCase->setTruncateToSize();
	break;
	case 'z': // no new fair sleepers
	testCase->setNewFairSleepers(false);
	break;
	case 'Z': // no normalized sleepers
	testCase->setNormalizedSleepers(false);
	break;
	case 'a': // fadvise
	testCase->setFadvise(optarg);
	break;
	case 'h':
	usage();
	exit(0);
	default:
	fprintf(stderr, "Unknown option %s\n", optarg);
	exit(EXIT_FAILURE);
	}
	}
	}

	// ----------------------------------------------------------------------
	// READ TEST

	// Read a file. We use a new file each time to avoid any caching
	// effect that would happen if we were reading the same file each
	// time.
	// @param chunk buffer large enough where the chunk read are written.
	// @param idx iteration number.
	// @param testCase has all the timers and paramters to run the test.

	bool readData(char const chunk, const int idx, TestCase testCase)
	{
	char filename[80] = {'\0',};

	sprintf(filename, "%s/file-%d-%d", kTestDir, idx, getpid());

	testCase->openTimer()->start();
	int fd = open(filename, O_RDONLY);
	testCase->openTimer()->stop();

	if (fd < 0)
	{
	fprintf(stderr, "Open read only failed.");
	return false;
	}
	FADVISE(fd, 0, 0, testCase->fadvise());

	size_t left = testCase->dataSize();
	pid_t pid = (pid_t)chunk;
	while (left > 0)
	{
	char *dest = chunk;
	size_t chunk_size = testCase->chunkSize();

	if (chunk_size > left)
	{
	chunk_size = left;
	left = 0;
	}
	else
	{
	left -= chunk_size;
	}

	testCase->readTimer()->start();
	while (chunk_size > 0)
	{
	ssize_t s = read(fd, dest, chunk_size);
	if (s < 0)
	{
	fprintf(stderr, "Failed to read.\n");
	close(fd);
	return false;
	}
	chunk_size -= s;
	dest += s;
	}
	testCase->readTimer()->stop();
	}
	close(fd);
	if (testCase->pid() != *pid)
	{
	fprintf(stderr, "Wrong pid found @ read block %x != %x\n", testCase->pid(), *pid);
	return false;
	}
	else
	{
	return true;
	}
	}


	bool testRead(TestCase *testCase) {
	// Setup the testcase by writting some dummy files.
	const size_t size = testCase->dataSize();
	size_t chunk_size = testCase->chunkSize();
	char *const chunk = new char[chunk_size];

	memset(chunk, 0xaa, chunk_size);
	((pid_t )chunk) = testCase->pid(); // write our pid at the beginning of each chunk

	size_t iter = testCase->iter();

	// since readers are much faster we increase the number of
	// iteration to last longer and have concurrent read/write
	// thoughout the whole test.
	if (testCase->type() == TestCase::READ_WRITE)
	{
	iter *= TestCase::kReadWriteFactor;
	}

	for (size_t i = 0; i < iter; ++i)
	{
	char filename[80] = {'\0',};

	sprintf(filename, "%s/file-%d-%d", kTestDir, i, testCase->pid());
	int fd = open(filename, O_RDWR \| O_CREAT, S_IRWXU);

	size_t left = size;
	while (left > 0)
	{
	if (chunk_size > left)
	{
	chunk_size = left;
	}
	ssize_t written = write(fd, chunk, chunk_size);
	if (written < 0)
	{
	fprintf(stderr, "Write failed %d %s.", errno, strerror(errno));
	return false;
	}
	left -= written;
	}
	close(fd);
	}
	if (kVerbose) printf("Child %d all chunk written\n", testCase->pid());

	android::syncAndDropCaches();
	testCase->signalParentAndWait();

	// Start the read test.
	testCase->testTimer()->start();
	for (size_t i = 0; i < iter; ++i)
	{
	if (!readData(chunk, i, testCase))
	{
	return false;
	}
	}
	testCase->testTimer()->stop();

	delete [] chunk;
	return true;
	}

	// ----------------------------------------------------------------------
	// WRITE TEST

	bool writeData(const char const chunk, const int idx, TestCase testCase) {
	char filename[80] = {'\0',};

	sprintf(filename, "%s/file-%d-%d", kTestDir, idx, getpid());
	testCase->openTimer()->start();
	int fd = open(filename, O_RDWR \| O_CREAT, S_IRWXU); // no O_TRUNC, see header comment
	testCase->openTimer()->stop();

	if (fd < 0)
	{
	fprintf(stderr, "Open write failed.");
	return false;
	}
	FADVISE(fd, 0, 0, testCase->fadvise());

	if (testCase->truncateToSize())
	{
	testCase->truncateTimer()->start();
	ftruncate(fd, testCase->dataSize());
	testCase->truncateTimer()->stop();
	}

	size_t left = testCase->dataSize();
	while (left > 0)
	{
	const char *dest = chunk;
	size_t chunk_size = testCase->chunkSize();

	if (chunk_size > left)
	{
	chunk_size = left;
	left = 0;
	}
	else
	{
	left -= chunk_size;
	}


	testCase->writeTimer()->start();
	while (chunk_size > 0)
	{
	ssize_t s = write(fd, dest, chunk_size);
	if (s < 0)
	{
	fprintf(stderr, "Failed to write.\n");
	close(fd);
	return false;
	}
	chunk_size -= s;
	dest += s;
	}
	testCase->writeTimer()->stop();
	}

	if (TestCase::FSYNC == testCase->sync())
	{
	testCase->syncTimer()->start();
	fsync(fd);
	testCase->syncTimer()->stop();
	}
	else if (TestCase::SYNC == testCase->sync())
	{
	testCase->syncTimer()->start();
	sync();
	testCase->syncTimer()->stop();
	}
	close(fd);
	return true;
	}

	bool testWrite(TestCase *testCase)
	{
	const size_t size = testCase->dataSize();
	size_t chunk_size = testCase->chunkSize();
	char *data = new char[chunk_size];

	memset(data, 0xaa, chunk_size);
	// TODO: write the pid at the beginning like in the write
	// test. Have a mode where we check the write was correct.
	testCase->signalParentAndWait();

	testCase->testTimer()->start();
	for (size_t i = 0; i < testCase->iter(); ++i)
	{
	if (!writeData(data, i, testCase))
	{
	return false;
	}
	}
	testCase->testTimer()->stop();
	delete [] data;
	return true;
	}


	// ----------------------------------------------------------------------
	// READ WRITE

	// Mix of read and write test. Even PID run the write test. Odd PID
	// the read test. Not fool proof but work most of the time.
	bool testReadWrite(TestCase *testCase)
	{
	if (getpid() & 0x1) {
	return testRead(testCase);
	} else {
	return testWrite(testCase);
	}
	}

	// ----------------------------------------------------------------------
	// OPEN CREATE TEST

	bool testOpenCreate(TestCase *testCase)
	{
	char filename[80] = {'\0',};

	testCase->signalParentAndWait();
	testCase->testTimer()->start();

	for (size_t i = 0; i < testCase->iter(); ++i)
	{
	sprintf(filename, "%s/file-%d-%d", kTestDir, i, testCase->pid());

	int fd = open(filename, O_RDWR \| O_CREAT, S_IRWXU);
	FADVISE(fd, 0, 0, testCase->fadvise());

	if (testCase->truncateToSize())
	{
	ftruncate(fd, testCase->dataSize());
	}
	if (fd < 0)
	{
	return false;
	}
	close(fd);
	}
	testCase->testTimer()->stop();
	return true;
	}

	bool writeTestFile(TestCase testCase, const char filename) {
	int fd = open(filename, O_RDWR \| O_CREAT, S_IRWXU);
	if (fd < 0) {
	fprintf(stderr, "open() failed: %s\n", strerror(errno));
	return false;
	}

	bool res = false;

	char * const chunk = new char[testCase->chunkSize()];
	memset(chunk, 0xaa, testCase->chunkSize());

	size_t left = testCase->dataSize();
	while (left > 0) {
	char *dest = chunk;
	size_t chunk_size = testCase->chunkSize();

	if (chunk_size > left) {
	chunk_size = left;
	left = 0;
	} else {
	left -= chunk_size;
	}

	while (chunk_size > 0) {
	ssize_t s = write(fd, dest, chunk_size);
	if (s < 0) {
	fprintf(stderr, "write() failed: %s\n", strerror(errno));
	goto fail;
	}
	chunk_size -= s;
	dest += s;
	}
	}

	res = true;
	fail:
	close(fd);
	delete[] chunk;
	return res;
	}

	// ----------------------------------------------------------------------
	// TRAVERSE

	#define MAX_PATH 512

	// Creates a directory tree that is both deep and wide, and times
	// traversal using fts_open().
	bool testTraverse(TestCase *testCase) {
	char path[MAX_PATH];
	char filepath[MAX_PATH];
	strcpy(path, kTestDir);

	// Generate a deep directory hierarchy
	size_t depth = testCase->treeDepth();
	for (size_t i = 0; i < depth; i++) {
	// Go deeper by appending onto current path
	snprintf(path + strlen(path), MAX_PATH - strlen(path), "/dir%d", i);
	mkdir(path, S_IRWXU);

	// Create some files at this depth
	strcpy(filepath, path);
	int pathlen = strlen(path);
	char* nameStart = filepath + pathlen;
	for (size_t j = 0; j < depth; j++) {
	snprintf(nameStart, MAX_PATH - pathlen, "/file%d", j);
	writeTestFile(testCase, filepath);
	}
	}

	testCase->signalParentAndWait();
	testCase->testTimer()->start();

	// Now traverse structure
	size_t iter = testCase->iter();
	for (size_t i = 0; i < iter; i++) {
	testCase->traverseTimer()->start();

	FTS *ftsp;
	if ((ftsp = fts_open((char **) &kTestDir, FTS_LOGICAL \| FTS_XDEV, NULL)) == NULL) {
	fprintf(stderr, "fts_open() failed: %s\n", strerror(errno));
	return false;
	}

	// Count discovered files
	int dirs = 0, files = 0;

	FTSENT *curr;
	while ((curr = fts_read(ftsp)) != NULL) {
	switch (curr->fts_info) {
	case FTS_D:
	dirs++;
	break;
	case FTS_F:
	files++;
	break;
	}
	}

	fts_close(ftsp);

	testCase->traverseTimer()->stop();

	int expectedDirs = depth + 1;
	if (expectedDirs != dirs) {
	fprintf(stderr, "expected %d dirs, but found %d\n", expectedDirs, dirs);
	return false;
	}

	int expectedFiles = depth * depth;
	if (expectedFiles != files) {
	fprintf(stderr, "expected %d files, but found %d\n", expectedFiles, files);
	return false;
	}
	}

	testCase->testTimer()->stop();
	return true;
	}

	} // anonymous namespace

	int main(int argc, char **argv)
	{
	android_test::TestCase testCase(kAppName);

	cleanup();

	parseCmdLine(argc, argv, &testCase);
	printHeader(argc, argv, testCase);

	printf("# File size %d kbytes\n", testCase.dataSize() / 1024);
	printf("# Chunk size %d kbytes\n", testCase.chunkSize() / 1024);
	printf("# Sync: %s\n", testCase.syncAsStr());

	if (!testCase.cpuScaling())
	{
	android::disableCpuScaling();
	}

	switch(testCase.type()) {
	case TestCase::WRITE:
	testCase.mTestBody = testWrite;
	break;
	case TestCase::READ:
	testCase.mTestBody = testRead;
	break;
	case TestCase::OPEN_CREATE:
	testCase.mTestBody = testOpenCreate;
	break;
	case TestCase::READ_WRITE:
	testCase.mTestBody = testReadWrite;
	break;
	case TestCase::TRAVERSE:
	testCase.mTestBody = testTraverse;
	break;
	default:
	fprintf(stderr, "Unknown test type %s", testCase.name());
	exit(EXIT_FAILURE);
	}

	testCase.createTimers();

	bool ok;

	ok = testCase.runTest();

	cleanup();
	if (!ok)
	{
	printf("error %d %s", errno, strerror(errno));
	exit(EXIT_FAILURE);
	}
	else
	{
	exit(EXIT_SUCCESS);
	}
	}