/*
* 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);
}
}