vitalif
/
mdtest
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Extraction of output completed.

master
Julian M. Kunkel 2018-07-08 13:47:55 +01:00
parent 02883d4a63
commit 8525f9734c
6 changed files with 174 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/ior-internal.h
View File

@ -19,6 +19,8 @@ void DisplayFreespace(IOR_param_t * test);
void GetTestFileName(char *, IOR_param_t *); void GetTestFileName(char *, IOR_param_t *);
void PrintRemoveTiming(double start, double finish, int rep); void PrintRemoveTiming(double start, double finish, int rep);
void PrintReducedResult(IOR_test_t *test, int access, double bw, double *diff_subset, double totalTime, int rep); void PrintReducedResult(IOR_test_t *test, int access, double bw, double *diff_subset, double totalTime, int rep);
void PrintTestEnds();
void PrintTableHeader();
/* End of ior-output */ /* End of ior-output */
struct results { struct results {

313
src/ior-output.c
View File

@ -15,8 +15,19 @@ static struct results *ops_values(int reps, IOR_offset_t *agg_file_size, IOR_off
static double mean_of_array_of_doubles(double *values, int len); static double mean_of_array_of_doubles(double *values, int len);
static void PPDouble(int leftjustify, double number, char *append); static void PPDouble(int leftjustify, double number, char *append);
void PrintTableHeader(){
fprintf(out_resultfile, "\n");
fprintf(out_resultfile, "access bw(MiB/s) block(KiB) xfer(KiB) open(s) wr/rd(s) close(s) total(s) iter\n");
fprintf(out_resultfile, "------ --------- ---------- --------- -------- -------- -------- -------- ----\n");
}
void PrintTestEnds(){
fprintf(out_resultfile, "\n");
fprintf(out_resultfile, "Finished: %s", CurrentTimeString());
}
void PrintReducedResult(IOR_test_t *test, int access, double bw, double *diff_subset, double totalTime, int rep){ void PrintReducedResult(IOR_test_t *test, int access, double bw, double *diff_subset, double totalTime, int rep){
fprintf(out_logfile, "%-10s", access == WRITE ? "write" : "read"); fprintf(out_resultfile, "%-10s", access == WRITE ? "write" : "read");
PPDouble(1, bw / MEBIBYTE, " "); PPDouble(1, bw / MEBIBYTE, " ");
PPDouble(1, (double)test->params.blockSize / KIBIBYTE, " "); PPDouble(1, (double)test->params.blockSize / KIBIBYTE, " ");
PPDouble(1, (double)test->params.transferSize / KIBIBYTE, " "); PPDouble(1, (double)test->params.transferSize / KIBIBYTE, " ");
@ -24,8 +35,8 @@ void PrintReducedResult(IOR_test_t *test, int access, double bw, double *diff_su
PPDouble(1, diff_subset[1], " "); PPDouble(1, diff_subset[1], " ");
PPDouble(1, diff_subset[2], " "); PPDouble(1, diff_subset[2], " ");
PPDouble(1, totalTime, " "); PPDouble(1, totalTime, " ");
fprintf(out_logfile, "%-4d\n", rep); fprintf(out_resultfile, "%-4d\n", rep);
fflush(out_logfile); fflush(out_resultfile);
} }
@ -38,8 +49,8 @@ void PrintEarlyHeader()
if (rank != 0) if (rank != 0)
return; return;
fprintf(out_logfile, "IOR-" META_VERSION ": MPI Coordinated Test of Parallel I/O\n"); fprintf(out_resultfile, "IOR-" META_VERSION ": MPI Coordinated Test of Parallel I/O\n");
fflush(out_logfile); fflush(out_resultfile);
} }
void PrintHeader(int argc, char **argv) void PrintHeader(int argc, char **argv)
@ -50,48 +61,48 @@ void PrintHeader(int argc, char **argv)
if (rank != 0) if (rank != 0)
return; return;
fprintf(out_logfile, "Began: %s", CurrentTimeString()); fprintf(out_resultfile, "Began: %s", CurrentTimeString());
fprintf(out_logfile, "Command line used: %s", argv[0]); fprintf(out_resultfile, "Command line used: %s", argv[0]);
for (i = 1; i < argc; i++) { for (i = 1; i < argc; i++) {
fprintf(out_logfile, " \"%s\"", argv[i]); fprintf(out_resultfile, " \"%s\"", argv[i]);
} }
fprintf(out_logfile, "\n"); fprintf(out_resultfile, "\n");
if (uname(&unamebuf) != 0) { if (uname(&unamebuf) != 0) {
EWARN("uname failed"); EWARN("uname failed");
fprintf(out_logfile, "Machine: Unknown"); fprintf(out_resultfile, "Machine: Unknown");
} else { } else {
fprintf(out_logfile, "Machine: %s %s", unamebuf.sysname, fprintf(out_resultfile, "Machine: %s %s", unamebuf.sysname,
unamebuf.nodename); unamebuf.nodename);
if (verbose >= VERBOSE_2) { if (verbose >= VERBOSE_2) {
fprintf(out_logfile, " %s %s %s", unamebuf.release, fprintf(out_resultfile, " %s %s %s", unamebuf.release,
unamebuf.version, unamebuf.machine); unamebuf.version, unamebuf.machine);
} }
} }
fprintf(out_logfile, "\n"); fprintf(out_resultfile, "\n");
#ifdef _NO_MPI_TIMER #ifdef _NO_MPI_TIMER
if (verbose >= VERBOSE_2) if (verbose >= VERBOSE_2)
fprintf(out_logfile, "Using unsynchronized POSIX timer\n"); fprintf(out_resultfile, "Using unsynchronized POSIX timer\n");
#else /* not _NO_MPI_TIMER */ #else /* not _NO_MPI_TIMER */
if (MPI_WTIME_IS_GLOBAL) { if (MPI_WTIME_IS_GLOBAL) {
if (verbose >= VERBOSE_2) if (verbose >= VERBOSE_2)
fprintf(out_logfile, "Using synchronized MPI timer\n"); fprintf(out_resultfile, "Using synchronized MPI timer\n");
} else { } else {
if (verbose >= VERBOSE_2) if (verbose >= VERBOSE_2)
fprintf(out_logfile, "Using unsynchronized MPI timer\n"); fprintf(out_resultfile, "Using unsynchronized MPI timer\n");
} }
#endif /* _NO_MPI_TIMER */ #endif /* _NO_MPI_TIMER */
if (verbose >= VERBOSE_1) { if (verbose >= VERBOSE_1) {
fprintf(out_logfile, "Start time skew across all tasks: %.02f sec\n", fprintf(out_resultfile, "Start time skew across all tasks: %.02f sec\n",
wall_clock_deviation); wall_clock_deviation);
} }
if (verbose >= VERBOSE_3) { /* show env */ if (verbose >= VERBOSE_3) { /* show env */
fprintf(out_logfile, "STARTING ENVIRON LOOP\n"); fprintf(out_resultfile, "STARTING ENVIRON LOOP\n");
for (i = 0; environ[i] != NULL; i++) { for (i = 0; environ[i] != NULL; i++) {
fprintf(out_logfile, "%s\n", environ[i]); fprintf(out_resultfile, "%s\n", environ[i]);
} }
fprintf(out_logfile, "ENDING ENVIRON LOOP\n"); fprintf(out_resultfile, "ENDING ENVIRON LOOP\n");
} }
fflush(out_logfile); fflush(out_resultfile);
} }
/* /*
@ -99,15 +110,15 @@ void PrintHeader(int argc, char **argv)
*/ */
void ShowTestInfo(IOR_param_t *params) void ShowTestInfo(IOR_param_t *params)
{ {
fprintf(out_logfile, "\n"); fprintf(out_resultfile, "\n");
fprintf(out_logfile, "Test %d started: %s", params->id, CurrentTimeString()); fprintf(out_resultfile, "Test %d started: %s", params->id, CurrentTimeString());
if (verbose >= VERBOSE_1) { if (verbose >= VERBOSE_1) {
/* if pvfs2:, then skip */ /* if pvfs2:, then skip */
if (Regex(params->testFileName, "^[a-z][a-z].*:") == 0) { if (Regex(params->testFileName, "^[a-z][a-z].*:") == 0) {
DisplayFreespace(params); DisplayFreespace(params);
} }
} }
fflush(out_logfile); fflush(out_resultfile);
} }
/* /*
@ -117,79 +128,79 @@ void ShowSetup(IOR_param_t *params)
{ {
if (strcmp(params->debug, "") != 0) { if (strcmp(params->debug, "") != 0) {
fprintf(out_logfile, "\n*** DEBUG MODE ***\n"); fprintf(out_resultfile, "\n*** DEBUG MODE ***\n");
fprintf(out_logfile, "*** %s ***\n\n", params->debug); fprintf(out_resultfile, "*** %s ***\n\n", params->debug);
} }
fprintf(out_logfile, "Summary:\n"); fprintf(out_resultfile, "Summary:\n");
fprintf(out_logfile, "\tapi = %s\n", params->apiVersion); fprintf(out_resultfile, "\tapi = %s\n", params->apiVersion);
fprintf(out_logfile, "\ttest filename = %s\n", params->testFileName); fprintf(out_resultfile, "\ttest filename = %s\n", params->testFileName);
fprintf(out_logfile, "\taccess = "); fprintf(out_resultfile, "\taccess = ");
fprintf(out_logfile, params->filePerProc ? "file-per-process" : "single-shared-file"); fprintf(out_resultfile, params->filePerProc ? "file-per-process" : "single-shared-file");
if (verbose >= VERBOSE_1 && strcmp(params->api, "POSIX") != 0) { if (verbose >= VERBOSE_1 && strcmp(params->api, "POSIX") != 0) {
fprintf(out_logfile, params->collective == FALSE ? ", independent" : ", collective"); fprintf(out_resultfile, params->collective == FALSE ? ", independent" : ", collective");
} }
fprintf(out_logfile, "\n"); fprintf(out_resultfile, "\n");
if (verbose >= VERBOSE_1) { if (verbose >= VERBOSE_1) {
if (params->segmentCount > 1) { if (params->segmentCount > 1) {
fprintf(out_logfile, fprintf(out_resultfile,
"\tpattern = strided (%d segments)\n", "\tpattern = strided (%d segments)\n",
(int)params->segmentCount); (int)params->segmentCount);
} else { } else {
fprintf(out_logfile, fprintf(out_resultfile,
"\tpattern = segmented (1 segment)\n"); "\tpattern = segmented (1 segment)\n");
} }
} }
fprintf(out_logfile, "\tordering in a file ="); fprintf(out_resultfile, "\tordering in a file =");
if (params->randomOffset == FALSE) { if (params->randomOffset == FALSE) {
fprintf(out_logfile, " sequential offsets\n"); fprintf(out_resultfile, " sequential offsets\n");
} else { } else {
fprintf(out_logfile, " random offsets\n"); fprintf(out_resultfile, " random offsets\n");
} }
fprintf(out_logfile, "\tordering inter file="); fprintf(out_resultfile, "\tordering inter file=");
if (params->reorderTasks == FALSE && params->reorderTasksRandom == FALSE) { if (params->reorderTasks == FALSE && params->reorderTasksRandom == FALSE) {
fprintf(out_logfile, " no tasks offsets\n"); fprintf(out_resultfile, " no tasks offsets\n");
} }
if (params->reorderTasks == TRUE) { if (params->reorderTasks == TRUE) {
fprintf(out_logfile, " constant task offsets = %d\n", fprintf(out_resultfile, " constant task offsets = %d\n",
params->taskPerNodeOffset); params->taskPerNodeOffset);
} }
if (params->reorderTasksRandom == TRUE) { if (params->reorderTasksRandom == TRUE) {
fprintf(out_logfile, " random task offsets >= %d, seed=%d\n", fprintf(out_resultfile, " random task offsets >= %d, seed=%d\n",
params->taskPerNodeOffset, params->reorderTasksRandomSeed); params->taskPerNodeOffset, params->reorderTasksRandomSeed);
} }
fprintf(out_logfile, "\tclients = %d (%d per node)\n", fprintf(out_resultfile, "\tclients = %d (%d per node)\n",
params->numTasks, params->tasksPerNode); params->numTasks, params->tasksPerNode);
if (params->memoryPerTask != 0) if (params->memoryPerTask != 0)
fprintf(out_logfile, "\tmemoryPerTask = %s\n", fprintf(out_resultfile, "\tmemoryPerTask = %s\n",
HumanReadable(params->memoryPerTask, BASE_TWO)); HumanReadable(params->memoryPerTask, BASE_TWO));
if (params->memoryPerNode != 0) if (params->memoryPerNode != 0)
fprintf(out_logfile, "\tmemoryPerNode = %s\n", fprintf(out_resultfile, "\tmemoryPerNode = %s\n",
HumanReadable(params->memoryPerNode, BASE_TWO)); HumanReadable(params->memoryPerNode, BASE_TWO));
fprintf(out_logfile, "\trepetitions = %d\n", params->repetitions); fprintf(out_resultfile, "\trepetitions = %d\n", params->repetitions);
fprintf(out_logfile, "\txfersize = %s\n", fprintf(out_resultfile, "\txfersize = %s\n",
HumanReadable(params->transferSize, BASE_TWO)); HumanReadable(params->transferSize, BASE_TWO));
fprintf(out_logfile, "\tblocksize = %s\n", fprintf(out_resultfile, "\tblocksize = %s\n",
HumanReadable(params->blockSize, BASE_TWO)); HumanReadable(params->blockSize, BASE_TWO));
fprintf(out_logfile, "\taggregate filesize = %s\n", fprintf(out_resultfile, "\taggregate filesize = %s\n",
HumanReadable(params->expectedAggFileSize, BASE_TWO)); HumanReadable(params->expectedAggFileSize, BASE_TWO));
#ifdef HAVE_LUSTRE_LUSTRE_USER_H #ifdef HAVE_LUSTRE_LUSTRE_USER_H
if (params->lustre_set_striping) { if (params->lustre_set_striping) {
fprintf(out_logfile, "\tLustre stripe size = %s\n", fprintf(out_resultfile, "\tLustre stripe size = %s\n",
((params->lustre_stripe_size == 0) ? "Use default" : ((params->lustre_stripe_size == 0) ? "Use default" :
HumanReadable(params->lustre_stripe_size, BASE_TWO))); HumanReadable(params->lustre_stripe_size, BASE_TWO)));
if (params->lustre_stripe_count == 0) { if (params->lustre_stripe_count == 0) {
fprintf(out_logfile, "\t stripe count = %s\n", "Use default"); fprintf(out_resultfile, "\t stripe count = %s\n", "Use default");
} else { } else {
fprintf(out_logfile, "\t stripe count = %d\n", fprintf(out_resultfile, "\t stripe count = %d\n",
params->lustre_stripe_count); params->lustre_stripe_count);
} }
} }
#endif /* HAVE_LUSTRE_LUSTRE_USER_H */ #endif /* HAVE_LUSTRE_LUSTRE_USER_H */
if (params->deadlineForStonewalling > 0) { if (params->deadlineForStonewalling > 0) {
fprintf(out_logfile, "\tUsing stonewalling = %d second(s)%s\n", fprintf(out_resultfile, "\tUsing stonewalling = %d second(s)%s\n",
params->deadlineForStonewalling, params->stoneWallingWearOut ? " with phase out" : ""); params->deadlineForStonewalling, params->stoneWallingWearOut ? " with phase out" : "");
} }
fflush(out_logfile); fflush(out_resultfile);
} }
/* /*
@ -199,77 +210,77 @@ void ShowTest(IOR_param_t * test)
{ {
const char* data_packets[] = {"g", "t","o","i"}; const char* data_packets[] = {"g", "t","o","i"};
fprintf(out_logfile, "TEST:\t%s=%d\n", "id", test->id); fprintf(out_resultfile, "TEST:\t%s=%d\n", "id", test->id);
fprintf(out_logfile, "\t%s=%d\n", "refnum", test->referenceNumber); fprintf(out_resultfile, "\t%s=%d\n", "refnum", test->referenceNumber);
fprintf(out_logfile, "\t%s=%s\n", "api", test->api); fprintf(out_resultfile, "\t%s=%s\n", "api", test->api);
fprintf(out_logfile, "\t%s=%s\n", "platform", test->platform); fprintf(out_resultfile, "\t%s=%s\n", "platform", test->platform);
fprintf(out_logfile, "\t%s=%s\n", "testFileName", test->testFileName); fprintf(out_resultfile, "\t%s=%s\n", "testFileName", test->testFileName);
fprintf(out_logfile, "\t%s=%s\n", "hintsFileName", test->hintsFileName); fprintf(out_resultfile, "\t%s=%s\n", "hintsFileName", test->hintsFileName);
fprintf(out_logfile, "\t%s=%d\n", "deadlineForStonewall", fprintf(out_resultfile, "\t%s=%d\n", "deadlineForStonewall",
test->deadlineForStonewalling); test->deadlineForStonewalling);
fprintf(out_logfile, "\t%s=%d\n", "stoneWallingWearOut", test->stoneWallingWearOut); fprintf(out_resultfile, "\t%s=%d\n", "stoneWallingWearOut", test->stoneWallingWearOut);
fprintf(out_logfile, "\t%s=%d\n", "maxTimeDuration", test->maxTimeDuration); fprintf(out_resultfile, "\t%s=%d\n", "maxTimeDuration", test->maxTimeDuration);
fprintf(out_logfile, "\t%s=%d\n", "outlierThreshold", fprintf(out_resultfile, "\t%s=%d\n", "outlierThreshold",
test->outlierThreshold); test->outlierThreshold);
fprintf(out_logfile, "\t%s=%s\n", "options", test->options); fprintf(out_resultfile, "\t%s=%s\n", "options", test->options);
fprintf(out_logfile, "\t%s=%d\n", "nodes", test->nodes); fprintf(out_resultfile, "\t%s=%d\n", "nodes", test->nodes);
fprintf(out_logfile, "\t%s=%lu\n", "memoryPerTask", (unsigned long) test->memoryPerTask); fprintf(out_resultfile, "\t%s=%lu\n", "memoryPerTask", (unsigned long) test->memoryPerTask);
fprintf(out_logfile, "\t%s=%lu\n", "memoryPerNode", (unsigned long) test->memoryPerNode); fprintf(out_resultfile, "\t%s=%lu\n", "memoryPerNode", (unsigned long) test->memoryPerNode);
fprintf(out_logfile, "\t%s=%d\n", "tasksPerNode", tasksPerNode); fprintf(out_resultfile, "\t%s=%d\n", "tasksPerNode", tasksPerNode);
fprintf(out_logfile, "\t%s=%d\n", "repetitions", test->repetitions); fprintf(out_resultfile, "\t%s=%d\n", "repetitions", test->repetitions);
fprintf(out_logfile, "\t%s=%d\n", "multiFile", test->multiFile); fprintf(out_resultfile, "\t%s=%d\n", "multiFile", test->multiFile);
fprintf(out_logfile, "\t%s=%d\n", "interTestDelay", test->interTestDelay); fprintf(out_resultfile, "\t%s=%d\n", "interTestDelay", test->interTestDelay);
fprintf(out_logfile, "\t%s=%d\n", "fsync", test->fsync); fprintf(out_resultfile, "\t%s=%d\n", "fsync", test->fsync);
fprintf(out_logfile, "\t%s=%d\n", "fsYncperwrite", test->fsyncPerWrite); fprintf(out_resultfile, "\t%s=%d\n", "fsYncperwrite", test->fsyncPerWrite);
fprintf(out_logfile, "\t%s=%d\n", "useExistingTestFile", fprintf(out_resultfile, "\t%s=%d\n", "useExistingTestFile",
test->useExistingTestFile); test->useExistingTestFile);
fprintf(out_logfile, "\t%s=%d\n", "showHints", test->showHints); fprintf(out_resultfile, "\t%s=%d\n", "showHints", test->showHints);
fprintf(out_logfile, "\t%s=%d\n", "uniqueDir", test->uniqueDir); fprintf(out_resultfile, "\t%s=%d\n", "uniqueDir", test->uniqueDir);
fprintf(out_logfile, "\t%s=%d\n", "showHelp", test->showHelp); fprintf(out_resultfile, "\t%s=%d\n", "showHelp", test->showHelp);
fprintf(out_logfile, "\t%s=%d\n", "individualDataSets", fprintf(out_resultfile, "\t%s=%d\n", "individualDataSets",
test->individualDataSets); test->individualDataSets);
fprintf(out_logfile, "\t%s=%d\n", "singleXferAttempt", fprintf(out_resultfile, "\t%s=%d\n", "singleXferAttempt",
test->singleXferAttempt); test->singleXferAttempt);
fprintf(out_logfile, "\t%s=%d\n", "readFile", test->readFile); fprintf(out_resultfile, "\t%s=%d\n", "readFile", test->readFile);
fprintf(out_logfile, "\t%s=%d\n", "writeFile", test->writeFile); fprintf(out_resultfile, "\t%s=%d\n", "writeFile", test->writeFile);
fprintf(out_logfile, "\t%s=%d\n", "filePerProc", test->filePerProc); fprintf(out_resultfile, "\t%s=%d\n", "filePerProc", test->filePerProc);
fprintf(out_logfile, "\t%s=%d\n", "reorderTasks", test->reorderTasks); fprintf(out_resultfile, "\t%s=%d\n", "reorderTasks", test->reorderTasks);
fprintf(out_logfile, "\t%s=%d\n", "reorderTasksRandom", fprintf(out_resultfile, "\t%s=%d\n", "reorderTasksRandom",
test->reorderTasksRandom); test->reorderTasksRandom);
fprintf(out_logfile, "\t%s=%d\n", "reorderTasksRandomSeed", fprintf(out_resultfile, "\t%s=%d\n", "reorderTasksRandomSeed",
test->reorderTasksRandomSeed); test->reorderTasksRandomSeed);
fprintf(out_logfile, "\t%s=%d\n", "randomOffset", test->randomOffset); fprintf(out_resultfile, "\t%s=%d\n", "randomOffset", test->randomOffset);
fprintf(out_logfile, "\t%s=%d\n", "checkWrite", test->checkWrite); fprintf(out_resultfile, "\t%s=%d\n", "checkWrite", test->checkWrite);
fprintf(out_logfile, "\t%s=%d\n", "checkRead", test->checkRead); fprintf(out_resultfile, "\t%s=%d\n", "checkRead", test->checkRead);
fprintf(out_logfile, "\t%s=%d\n", "preallocate", test->preallocate); fprintf(out_resultfile, "\t%s=%d\n", "preallocate", test->preallocate);
fprintf(out_logfile, "\t%s=%d\n", "useFileView", test->useFileView); fprintf(out_resultfile, "\t%s=%d\n", "useFileView", test->useFileView);
fprintf(out_logfile, "\t%s=%lld\n", "setAlignment", test->setAlignment); fprintf(out_resultfile, "\t%s=%lld\n", "setAlignment", test->setAlignment);
fprintf(out_logfile, "\t%s=%d\n", "storeFileOffset", test->storeFileOffset); fprintf(out_resultfile, "\t%s=%d\n", "storeFileOffset", test->storeFileOffset);
fprintf(out_logfile, "\t%s=%d\n", "useSharedFilePointer", fprintf(out_resultfile, "\t%s=%d\n", "useSharedFilePointer",
test->useSharedFilePointer); test->useSharedFilePointer);
fprintf(out_logfile, "\t%s=%d\n", "useO_DIRECT", test->useO_DIRECT); fprintf(out_resultfile, "\t%s=%d\n", "useO_DIRECT", test->useO_DIRECT);
fprintf(out_logfile, "\t%s=%d\n", "useStridedDatatype", fprintf(out_resultfile, "\t%s=%d\n", "useStridedDatatype",
test->useStridedDatatype); test->useStridedDatatype);
fprintf(out_logfile, "\t%s=%d\n", "keepFile", test->keepFile); fprintf(out_resultfile, "\t%s=%d\n", "keepFile", test->keepFile);
fprintf(out_logfile, "\t%s=%d\n", "keepFileWithError", fprintf(out_resultfile, "\t%s=%d\n", "keepFileWithError",
test->keepFileWithError); test->keepFileWithError);
fprintf(out_logfile, "\t%s=%d\n", "quitOnError", test->quitOnError); fprintf(out_resultfile, "\t%s=%d\n", "quitOnError", test->quitOnError);
fprintf(out_logfile, "\t%s=%d\n", "verbose", verbose); fprintf(out_resultfile, "\t%s=%d\n", "verbose", verbose);
fprintf(out_logfile, "\t%s=%s\n", "data packet type", data_packets[test->dataPacketType]); fprintf(out_resultfile, "\t%s=%s\n", "data packet type", data_packets[test->dataPacketType]);
fprintf(out_logfile, "\t%s=%d\n", "setTimeStampSignature/incompressibleSeed", fprintf(out_resultfile, "\t%s=%d\n", "setTimeStampSignature/incompressibleSeed",
test->setTimeStampSignature); /* Seed value was copied into setTimeStampSignature as well */ test->setTimeStampSignature); /* Seed value was copied into setTimeStampSignature as well */
fprintf(out_logfile, "\t%s=%d\n", "collective", test->collective); fprintf(out_resultfile, "\t%s=%d\n", "collective", test->collective);
fprintf(out_logfile, "\t%s=%lld", "segmentCount", test->segmentCount); fprintf(out_resultfile, "\t%s=%lld", "segmentCount", test->segmentCount);
#ifdef HAVE_GPFS_FCNTL_H #ifdef HAVE_GPFS_FCNTL_H
fprintf(out_logfile, "\t%s=%d\n", "gpfsHintAccess", test->gpfs_hint_access); fprintf(out_resultfile, "\t%s=%d\n", "gpfsHintAccess", test->gpfs_hint_access);
fprintf(out_logfile, "\t%s=%d\n", "gpfsReleaseToken", test->gpfs_release_token); fprintf(out_resultfile, "\t%s=%d\n", "gpfsReleaseToken", test->gpfs_release_token);
#endif #endif
if (strcasecmp(test->api, "HDF5") == 0) { if (strcasecmp(test->api, "HDF5") == 0) {
fprintf(out_logfile, " (datasets)"); fprintf(out_resultfile, " (datasets)");
} }
fprintf(out_logfile, "\n"); fprintf(out_resultfile, "\n");
fprintf(out_logfile, "\t%s=%lld\n", "transferSize", test->transferSize); fprintf(out_resultfile, "\t%s=%lld\n", "transferSize", test->transferSize);
fprintf(out_logfile, "\t%s=%lld\n", "blockSize", test->blockSize); fprintf(out_resultfile, "\t%s=%lld\n", "blockSize", test->blockSize);
} }
@ -294,33 +305,33 @@ void PrintLongSummaryOneOperation(IOR_test_t *test, double *times, char *operati
ops = ops_values(reps, results->aggFileSizeForBW, ops = ops_values(reps, results->aggFileSizeForBW,
params->transferSize, times); params->transferSize, times);
fprintf(out_logfile, "%-9s ", operation); fprintf(out_resultfile, "%-9s ", operation);
fprintf(out_logfile, "%10.2f ", bw->max / MEBIBYTE); fprintf(out_resultfile, "%10.2f ", bw->max / MEBIBYTE);
fprintf(out_logfile, "%10.2f ", bw->min / MEBIBYTE); fprintf(out_resultfile, "%10.2f ", bw->min / MEBIBYTE);
fprintf(out_logfile, "%10.2f ", bw->mean / MEBIBYTE); fprintf(out_resultfile, "%10.2f ", bw->mean / MEBIBYTE);
fprintf(out_logfile, "%10.2f ", bw->sd / MEBIBYTE); fprintf(out_resultfile, "%10.2f ", bw->sd / MEBIBYTE);
fprintf(out_logfile, "%10.2f ", ops->max); fprintf(out_resultfile, "%10.2f ", ops->max);
fprintf(out_logfile, "%10.2f ", ops->min); fprintf(out_resultfile, "%10.2f ", ops->min);
fprintf(out_logfile, "%10.2f ", ops->mean); fprintf(out_resultfile, "%10.2f ", ops->mean);
fprintf(out_logfile, "%10.2f ", ops->sd); fprintf(out_resultfile, "%10.2f ", ops->sd);
fprintf(out_logfile, "%10.5f ", mean_of_array_of_doubles(times, reps)); fprintf(out_resultfile, "%10.5f ", mean_of_array_of_doubles(times, reps));
fprintf(out_logfile, "%5d ", params->id); fprintf(out_resultfile, "%5d ", params->id);
fprintf(out_logfile, "%6d ", params->numTasks); fprintf(out_resultfile, "%6d ", params->numTasks);
fprintf(out_logfile, "%3d ", params->tasksPerNode); fprintf(out_resultfile, "%3d ", params->tasksPerNode);
fprintf(out_logfile, "%4d ", params->repetitions); fprintf(out_resultfile, "%4d ", params->repetitions);
fprintf(out_logfile, "%3d ", params->filePerProc); fprintf(out_resultfile, "%3d ", params->filePerProc);
fprintf(out_logfile, "%5d ", params->reorderTasks); fprintf(out_resultfile, "%5d ", params->reorderTasks);
fprintf(out_logfile, "%8d ", params->taskPerNodeOffset); fprintf(out_resultfile, "%8d ", params->taskPerNodeOffset);
fprintf(out_logfile, "%9d ", params->reorderTasksRandom); fprintf(out_resultfile, "%9d ", params->reorderTasksRandom);
fprintf(out_logfile, "%4d ", params->reorderTasksRandomSeed); fprintf(out_resultfile, "%4d ", params->reorderTasksRandomSeed);
fprintf(out_logfile, "%6lld ", params->segmentCount); fprintf(out_resultfile, "%6lld ", params->segmentCount);
fprintf(out_logfile, "%8lld ", params->blockSize); fprintf(out_resultfile, "%8lld ", params->blockSize);
fprintf(out_logfile, "%8lld ", params->transferSize); fprintf(out_resultfile, "%8lld ", params->transferSize);
fprintf(out_logfile, "%9.1f ", (float)results->aggFileSizeForBW[0] / MEBIBYTE); fprintf(out_resultfile, "%9.1f ", (float)results->aggFileSizeForBW[0] / MEBIBYTE);
fprintf(out_logfile, "%3s ", params->api); fprintf(out_resultfile, "%3s ", params->api);
fprintf(out_logfile, "%6d", params->referenceNumber); fprintf(out_resultfile, "%6d", params->referenceNumber);
fprintf(out_logfile, "\n"); fprintf(out_resultfile, "\n");
fflush(out_logfile); fflush(out_resultfile);
free(bw); free(bw);
free(ops); free(ops);
@ -342,15 +353,15 @@ void PrintLongSummaryHeader()
if (rank != 0 || verbose < VERBOSE_0) if (rank != 0 || verbose < VERBOSE_0)
return; return;
fprintf(out_logfile, "\n"); fprintf(out_resultfile, "\n");
fprintf(out_logfile, "%-9s %10s %10s %10s %10s %10s %10s %10s %10s %10s", fprintf(out_resultfile, "%-9s %10s %10s %10s %10s %10s %10s %10s %10s %10s",
"Operation", "Max(MiB)", "Min(MiB)", "Mean(MiB)", "StdDev", "Operation", "Max(MiB)", "Min(MiB)", "Mean(MiB)", "StdDev",
"Max(OPs)", "Min(OPs)", "Mean(OPs)", "StdDev", "Max(OPs)", "Min(OPs)", "Mean(OPs)", "StdDev",
"Mean(s)"); "Mean(s)");
fprintf(out_logfile, " Test# #Tasks tPN reps fPP reord reordoff reordrand seed" fprintf(out_resultfile, " Test# #Tasks tPN reps fPP reord reordoff reordrand seed"
" segcnt "); " segcnt ");
fprintf(out_logfile, "%8s %8s %9s %5s", " blksiz", "xsize","aggs(MiB)", "API"); fprintf(out_resultfile, "%8s %8s %9s %5s", " blksiz", "xsize","aggs(MiB)", "API");
fprintf(out_logfile, " RefNum\n"); fprintf(out_resultfile, " RefNum\n");
} }
void PrintLongSummaryAllTests(IOR_test_t *tests_head) void PrintLongSummaryAllTests(IOR_test_t *tests_head)
@ -359,8 +370,8 @@ void PrintLongSummaryAllTests(IOR_test_t *tests_head)
if (rank != 0 || verbose < VERBOSE_0) if (rank != 0 || verbose < VERBOSE_0)
return; return;
fprintf(out_logfile, "\n"); fprintf(out_resultfile, "\n");
fprintf(out_logfile, "Summary of all tests:"); fprintf(out_resultfile, "Summary of all tests:");
PrintLongSummaryHeader(); PrintLongSummaryHeader();
for (tptr = tests_head; tptr != NULL; tptr = tptr->next) { for (tptr = tests_head; tptr != NULL; tptr = tptr->next) {
@ -392,13 +403,13 @@ void PrintShortSummary(IOR_test_t * test)
max_read = MAX(bw, max_read); max_read = MAX(bw, max_read);
} }
fprintf(out_logfile, "\n"); fprintf(out_resultfile, "\n");
if (params->writeFile) { if (params->writeFile) {
fprintf(out_logfile, "Max Write: %.2f MiB/sec (%.2f MB/sec)\n", fprintf(out_resultfile, "Max Write: %.2f MiB/sec (%.2f MB/sec)\n",
max_write/MEBIBYTE, max_write/MEGABYTE); max_write/MEBIBYTE, max_write/MEGABYTE);
} }
if (params->readFile) { if (params->readFile) {
fprintf(out_logfile, "Max Read: %.2f MiB/sec (%.2f MB/sec)\n", fprintf(out_resultfile, "Max Read: %.2f MiB/sec (%.2f MB/sec)\n",
max_read/MEBIBYTE, max_read/MEGABYTE); max_read/MEBIBYTE, max_read/MEGABYTE);
} }
} }
@ -442,9 +453,9 @@ void PrintRemoveTiming(double start, double finish, int rep)
if (rank != 0 || verbose < VERBOSE_0) if (rank != 0 || verbose < VERBOSE_0)
return; return;
fprintf(out_logfile, "remove - - - - - - "); fprintf(out_resultfile, "remove - - - - - - ");
PPDouble(1, finish-start, " "); PPDouble(1, finish-start, " ");
fprintf(out_logfile, "%-4d\n", rep); fprintf(out_resultfile, "%-4d\n", rep);
} }
@ -460,7 +471,7 @@ static void PPDouble(int leftjustify, double number, char *append)
int precision; int precision;
if (number < 0) { if (number < 0) {
fprintf(out_logfile, " - %s", append); fprintf(out_resultfile, " - %s", append);
return; return;
} }
@ -475,7 +486,7 @@ static void PPDouble(int leftjustify, double number, char *append)
leftjustify ? "-" : "", leftjustify ? "-" : "",
width, precision); width, precision);
fprintf(out_logfile, format, number, append); fprintf(out_resultfile, format, number, append);
} }

11
src/ior.c
View File

@ -56,6 +56,7 @@ IOR_test_t * ior_run(int argc, char **argv, MPI_Comm world_com, FILE * world_out
IOR_test_t *tests_head; IOR_test_t *tests_head;
IOR_test_t *tptr; IOR_test_t *tptr;
out_logfile = world_out; out_logfile = world_out;
out_resultfile = world_out;
mpi_comm_world = world_com; mpi_comm_world = world_com;
MPI_CHECK(MPI_Comm_size(mpi_comm_world, &numTasksWorld), "cannot get number of tasks"); MPI_CHECK(MPI_Comm_size(mpi_comm_world, &numTasksWorld), "cannot get number of tasks");
@ -122,6 +123,7 @@ int ior_main(int argc, char **argv)
IOR_test_t *tptr; IOR_test_t *tptr;
out_logfile = stdout; out_logfile = stdout;
out_resultfile = stdout;
/* /*
* check -h option from commandline without starting MPI; * check -h option from commandline without starting MPI;
@ -213,8 +215,7 @@ int ior_main(int argc, char **argv)
/* display finish time */ /* display finish time */
if (rank == 0 && verbose >= VERBOSE_0) { if (rank == 0 && verbose >= VERBOSE_0) {
fprintf(out_logfile, "\n"); PrintTestEnds();
fprintf(out_logfile, "Finished: %s", CurrentTimeString());
} }
DestroyTests(tests_head); DestroyTests(tests_head);
@ -730,6 +731,8 @@ static void DisplayUsage(char **argv)
" -Y fsyncPerWrite -- perform fsync/msync after each POSIX/MMAP write", " -Y fsyncPerWrite -- perform fsync/msync after each POSIX/MMAP write",
" -z randomOffset -- access is to random, not sequential, offsets within a file", " -z randomOffset -- access is to random, not sequential, offsets within a file",
" -Z reorderTasksRandom -- changes task ordering to random ordering for readback", " -Z reorderTasksRandom -- changes task ordering to random ordering for readback",
" -O summaryFile=FILE -- store result data into this file",
" -O summaryFormat=[default,JSON,CSV] -- use the format for outputing the summary",
" ", " ",
" NOTE: S is a string, N is an integer number.", " NOTE: S is a string, N is an integer number.",
" ", " ",
@ -1407,9 +1410,7 @@ static void TestIoSys(IOR_test_t *test)
} }
} }
if (rep == 0 && verbose >= VERBOSE_0) { if (rep == 0 && verbose >= VERBOSE_0) {
fprintf(out_logfile, "\n"); PrintTableHeader();
fprintf(out_logfile, "access bw(MiB/s) block(KiB) xfer(KiB) open(s) wr/rd(s) close(s) total(s) iter\n");
fprintf(out_logfile, "------ --------- ---------- --------- -------- -------- -------- -------- ----\n");
} }
} }
MPI_CHECK(MPI_Bcast MPI_CHECK(MPI_Bcast

4
src/parse_options.c
View File

@ -171,8 +171,8 @@ void DecodeDirective(char *line, IOR_param_t *params)
if (strcasecmp(option, "api") == 0) { if (strcasecmp(option, "api") == 0) {
strcpy(params->api, value); strcpy(params->api, value);
} else if (strcasecmp(option, "summaryFile") == 0) { } else if (strcasecmp(option, "summaryFile") == 0) {
out_logfile = fopen(value, "w"); out_resultfile = fopen(value, "w");
if (out_logfile == NULL){ if (out_resultfile == NULL){
FAIL("Cannot open output file for writes!"); FAIL("Cannot open output file for writes!");
} }
printf("Writing output to %s\n", value); printf("Writing output to %s\n", value);

1
src/utilities.c
View File

@ -57,6 +57,7 @@ int verbose = VERBOSE_0; /* verbose output */
MPI_Comm testComm; MPI_Comm testComm;
MPI_Comm mpi_comm_world; MPI_Comm mpi_comm_world;
FILE * out_logfile; FILE * out_logfile;
FILE * out_resultfile;
enum OutputFormat_t outputFormat; enum OutputFormat_t outputFormat;
/***************************** F U N C T I O N S ******************************/ /***************************** F U N C T I O N S ******************************/

1
src/utilities.h
View File

@ -26,6 +26,7 @@ extern int verbose;
extern MPI_Comm testComm; extern MPI_Comm testComm;
extern MPI_Comm mpi_comm_world; extern MPI_Comm mpi_comm_world;
extern FILE * out_logfile; extern FILE * out_logfile;
extern FILE * out_resultfile;
extern enum OutputFormat_t outputFormat; /* format of the output */ extern enum OutputFormat_t outputFormat; /* format of the output */
/* /*