24 #if defined(HAVE_STRINGS_H) 32 # include <sys/time.h> 33 # include <sys/utsname.h> 37 #include <cuda_runtime.h> 48 #define IOR_NB_TIMERS 6 93 MPI_Group orig_group, new_group;
97 "MPI_Comm_group() error");
101 MPI_CHECK(MPI_Group_range_incl(orig_group, 1, &range, &new_group),
102 "MPI_Group_range_incl() error");
104 "MPI_Comm_create() error");
105 MPI_CHECK(MPI_Group_free(&orig_group),
"MPI_Group_Free() error");
106 MPI_CHECK(MPI_Group_free(&new_group),
"MPI_Group_Free() error");
109 if (params->
testComm == MPI_COMM_NULL) {
121 cudaError_t cret = cudaSetDevice(test->
params.
gpuID);
122 if(cret != cudaSuccess){
123 EWARNF(
"cudaSetDevice(%d) error: %s", test->
params.
gpuID, cudaGetErrorString(cret));
155 MPI_CHECK(MPI_Comm_rank(world_com, &
rank),
"cannot get rank");
164 for (tptr = tests_head; tptr !=
NULL; tptr = tptr->
next) {
166 if( ! participate )
continue;
197 MPI_CHECK(MPI_Init(&argc, &argv),
"cannot initialize MPI");
199 MPI_CHECK(MPI_Comm_rank(MPI_COMM_WORLD, &
rank),
"cannot get rank");
211 for (tptr = tests_head; tptr !=
NULL; tptr = tptr->
next) {
213 if( ! participate )
continue;
236 MPI_CHECK(MPI_Finalize(),
"cannot finalize MPI");
251 assert (
NULL != default_aiori);
254 p->
api = strdup(default_aiori);
255 p->
platform = strdup(
"HOST(OSTYPE)");
287 char *timeString,
int access,
int outlierThreshold)
296 (&timerVal, &sum, 1, MPI_DOUBLE, MPI_SUM,
testComm),
299 sqrDiff = pow((mean - timerVal), 2);
301 (&sqrDiff, &var, 1, MPI_DOUBLE, MPI_SUM,
testComm),
306 if (access ==
WRITE) {
307 strcpy(accessString,
"write");
309 strcpy(accessString,
"read");
311 if (fabs(timerVal - mean) > (
double)outlierThreshold) {
313 int ret = gethostname(hostname,
MAX_STR);
315 strcpy(hostname,
"unknown");
317 EWARNF(
"for %s, task %d, %s %s is %f (mean=%f, stddev=%f)\n",
318 hostname,
rank, accessString, timeString, timerVal, mean, sd);
335 "elapsed transfer time", access,
356 IOR_offset_t aggFileSizeFromStat, tmpMin, tmpMax, tmpSum;
360 MPI_CHECK(MPI_Allreduce(&aggFileSizeFromStat, &tmpSum, 1,
361 MPI_LONG_LONG_INT, MPI_SUM,
testComm),
362 "cannot reduce total data moved");
363 aggFileSizeFromStat = tmpSum;
365 MPI_CHECK(MPI_Allreduce(&aggFileSizeFromStat, &tmpMin, 1,
366 MPI_LONG_LONG_INT, MPI_MIN,
testComm),
367 "cannot reduce total data moved");
368 MPI_CHECK(MPI_Allreduce(&aggFileSizeFromStat, &tmpMax, 1,
369 MPI_LONG_LONG_INT, MPI_MAX,
testComm),
370 "cannot reduce total data moved");
371 if (tmpMin != tmpMax) {
373 WARN(
"inconsistent file size by different tasks");
376 aggFileSizeFromStat = tmpMin;
382 1, MPI_LONG_LONG_INT, MPI_SUM,
testComm),
383 "cannot total data moved");
385 if (strcasecmp(params->
api,
"HDF5") != 0 && strcasecmp(params->
api,
"NCMPI") != 0) {
395 EWARN(
"Maybe caused by deadlineForStonewalling");
414 char * bufferLabel1 =
"Expected: ";
415 char * bufferLabel2 =
"Actual: ";
417 size_t errorCount = 0;
420 unsigned long long hi, lo,
val;
421 hi = ((
unsigned long long)fillrank) << 32;
427 unsigned long long *testbuf = (
unsigned long long *)expectedBuffer;
432 "[%d] At file byte offset %lld, comparing %llu-byte transfer\n",
433 rank, (
long long) offset, (
long long)size);
437 for (i = 0; i < length; i++) {
441 hi = ((
unsigned long long) rand_r(& incompressibleSeed) << 32);
442 lo = (
unsigned long long) rand_r(& incompressibleSeed);
450 val = offsetSignature + (i *
sizeof(
unsigned long long));
453 if (testbuf[i] != val) {
457 "[%d] At transfer buffer #%lld, index #%lld (file byte offset %lld):\n",
458 rank, transferCount - 1, (
long long)i,
469 "[%d] PASSED offset = %llu bytes, transfer %lld\n",
470 rank, ((i *
sizeof(
unsigned long long)) + offset), transferCount);
480 EWARNF(
"[%d] FAILED comparison of buffer in file %s during transfer %lld offset %lld containing %d-byte ints (%zd errors)",
481 rank, testFileName, transferCount, offset, (
int)
sizeof(
unsigned long long int),errorCount);
483 fprintf(
out_logfile,
"[%d] comparison successful during transfer %lld offset %lld\n",
rank, transferCount, offset);
497 MPI_CHECK(MPI_Reduce(&errors, &allErrors, 1, MPI_INT, MPI_SUM,
498 0,
testComm),
"cannot reduce errors");
500 "cannot broadcast allErrors value");
501 if (allErrors != 0) {
505 if (
rank == 0 && allErrors != 0) {
507 WARN(
"overflow in errors counted");
510 EWARNF(
"Incorrect data on %s (%d errors found).\n",
511 access ==
WRITECHECK ?
"write" :
"read", allErrors);
513 "Used Time Stamp %u (0x%x) for Data Signature\n",
548 ERR(
"malloc() of IOR_test_t failed");
549 newTest->
params = *init_params;
568 for (tptr = tests_head; tptr !=
NULL; tptr = next) {
580 int hintCount = 0, i;
584 if (strncmp(
environ[i],
"IOR_HINT", strlen(
"IOR_HINT"))
588 WARN(
"exceeded max hints; reset MAX_HINTS and recompile");
593 strncpy(hint[hintCount - 1],
environ[i],
599 MPI_CHECK(MPI_Bcast(&hintCount,
sizeof(hintCount), MPI_BYTE, 0, com),
"cannot broadcast hints");
600 for (i = 0; i < hintCount; i++) {
602 "cannot broadcast hints");
603 strcpy(fullHint, hint[i]);
604 strcpy(hintVariable, strtok(fullHint,
"="));
605 if (getenv(hintVariable) ==
NULL) {
607 if (putenv(hint[i]) != 0)
608 WARN(
"cannot set environment variable");
626 unsigned long long hi, lo;
627 unsigned long long *buf = (
unsigned long long *)buffer;
636 for (i = 0; i < test->
transferSize /
sizeof(
unsigned long long); i++) {
648 unsigned long long hi, lo;
649 unsigned long long *buf = (
unsigned long long *)buffer;
654 hi = ((
unsigned long long)fillrank) << 32;
656 for (i = 0; i < test->
transferSize /
sizeof(
unsigned long long); i++) {
662 buf[i] = offset + (i *
sizeof(
unsigned long long));
677 if (uname(&name) != 0) {
678 EWARN(
"cannot get platform name");
679 sprintf(sysName,
"%s",
"Unknown");
680 sprintf(nodeName,
"%s",
"Unknown");
682 sprintf(sysName,
"%s", name.sysname);
683 sprintf(nodeName,
"%s", name.nodename);
687 if (strlen(nodeName) == 0) {
691 p = start + strlen(nodeName) - 1;
698 if (*p < '0' || *p >
'9') {
706 sprintf(platformName,
"%s(%s)", nodeName, sysName);
707 return strdup(platformName);
717 char **fileNames, *tmp, *token;
730 while (*tmp !=
'\0') {
737 fileNames = (
char **)malloc((*count) *
sizeof(
char **));
738 if (fileNames ==
NULL)
739 ERR(
"out of memory");
742 token = strtok(name, delimiterString);
743 while (token !=
NULL) {
744 fileNames[i] = token;
745 token = strtok(
NULL, delimiterString);
760 char testFileNameRoot[
MAX_STR];
769 sprintf(tmpString,
"%s%d/%s",initialTestFileName, socket,
"data");
770 strcpy(initialTestFileName, tmpString);
774 ERR(
"cannot use multiple file names with unique directories");
776 strcpy(testFileNameRoot,
780 strcpy(testFileNameRoot, fileNames[0]);
790 strcpy(testFileNameRoot,
793 sprintf(testFileName,
"%s.%08d", testFileNameRoot,
796 strcpy(testFileName, testFileNameRoot);
802 strcat(testFileName, tmpString);
817 dir = (
char *)malloc(
MAX_STR + 1);
819 ERR(
"out of memory");
822 strcpy(dir, rootDir);
825 if (dir[i] ==
'\0' || dir[i] ==
'/') {
834 fname = rootDir + i + 1;
842 ERRF(
"cannot create directory: %s", dir);
849 ERRF(
"invalid directory permissions: %s", dir);
868 double totalTime, accessTime;
870 double bw, iops, latency, minlatency;
874 assert(access ==
WRITE || access ==
READ);
879 op = i % 2 ? MPI_MAX : MPI_MIN;
880 MPI_CHECK(MPI_Reduce(&timer[i], &reduced[i], 1, MPI_DOUBLE,
885 for (i = 0; i < IOR_NB_TIMERS / 2; i++)
886 diff[i] = reduced[2 * i + 1] - reduced[2 * i];
888 totalTime = reduced[5] - reduced[0];
889 accessTime = reduced[3] - reduced[2];
894 point->
time = totalTime;
911 MPI_CHECK(MPI_Reduce(&latency, &minlatency, 1, MPI_DOUBLE,
912 MPI_MIN, 0,
testComm),
"MPI_Reduce()");
927 int tmpRankOffset = 0;
969 int mpiNumTasksOnNode0 = 0;
990 while (tests !=
NULL) {
1000 }
else if (params->
numTasks > mpiNumTasks) {
1002 EWARNF(
"More tasks requested (%d) than available (%d),",
1004 EWARNF(
" running with %d tasks.\n", mpiNumTasks);
1017 tests = tests->
next;
1055 page_size = sysconf(_SC_PAGESIZE);
1057 buf = (
char *)malloc(size);
1061 for (ptr = buf; ptr < buf+size; ptr += page_size) {
1070 int *rankoffs =
NULL;
1071 int *filecont =
NULL;
1072 int *filehits =
NULL;
1077 rankoffs = (
int *)malloc(params->
numTasks *
sizeof(
int));
1078 filecont = (
int *)malloc(params->
numTasks *
sizeof(
int));
1079 filehits = (
int *)malloc(params->
numTasks *
sizeof(
int));
1084 "MPI_Gather error");
1089 memset((
void *)filecont, 0, params->
numTasks *
sizeof(
int));
1090 for (ifile = 0; ifile < params->
numTasks; ifile++) {
1091 filecont[(ifile + rankoffs[ifile]) % params->
numTasks]++;
1093 memset((
void *)filehits, 0, params->
numTasks *
sizeof(
int));
1094 for (ifile = 0; ifile < params->
numTasks; ifile++)
1095 for (jfile = 0; jfile < params->
numTasks; jfile++) {
1096 if (ifile == filecont[jfile])
1104 jfile += filehits[ifile], ifile++;
1137 fprintf(
out_logfile,
"This node hogging %ld bytes of memory\n",
1145 fprintf(
out_logfile,
"This task hogging %ld bytes of memory\n", size);
1149 ERR(
"malloc of simulated applciation buffer failed");
1164 if (access ==
WRITE) {
1167 strcpy(timerName,
"write open start");
1170 strcpy(timerName,
"write open stop");
1173 strcpy(timerName,
"write start");
1176 strcpy(timerName,
"write stop");
1179 strcpy(timerName,
"write close start");
1182 strcpy(timerName,
"write close stop");
1185 strcpy(timerName,
"invalid timer");
1192 strcpy(timerName,
"read open start");
1195 strcpy(timerName,
"read open stop");
1198 strcpy(timerName,
"read start");
1201 strcpy(timerName,
"read stop");
1204 strcpy(timerName,
"read close start");
1207 strcpy(timerName,
"read close stop");
1210 strcpy(timerName,
"invalid timer");
1214 fprintf(
out_logfile,
"Test %d: Iter=%d, Task=%d, Time=%f, %s\n",
1215 test->
id, iteration, (
int)
rank, timer[i],
1222 double totalTime = timer[5] - timer[0];
1223 double accessTime = timer[3] - timer[2];
1224 double times[] = {totalTime, accessTime};
1229 FAIL(
"Cannot open saveRankPerformanceDetailsCSV file for writes!");
1232 MPI_Comm_size(params->
testComm, & size);
1233 double *all_times = malloc(2* size *
sizeof(
double));
1234 MPI_Gather(times, 2, MPI_DOUBLE, all_times, 2, MPI_DOUBLE, 0, params->
testComm);
1238 for(
int i=0; i < size; i++){
1240 sprintf(buff,
"%s,%d,%.10e,%.10e,%.10e,%.10e\n", access==
WRITE ?
"write" :
"read", i, all_times[i*2], all_times[i*2+1], file_size/all_times[i*2], file_size/all_times[i*2+1] );
1241 int ret = fwrite(buff, strlen(buff), 1, fd);
1243 WARN(
"Couln't append to saveRankPerformanceDetailsCSV file\n");
1249 MPI_Gather(& times, 2, MPI_DOUBLE,
NULL, 2, MPI_DOUBLE, 0,
testComm);
1291 "Using reorderTasks '-C' (useful to avoid read cache in client)\n");
1322 EWARNF(
"The file \"%s\" exists already and will be overwritten", testFileName);
1332 if ((currentTime = time(
NULL)) == -1) {
1333 ERR(
"cannot get current time");
1336 (
unsigned int)currentTime;
1340 "Using Time Stamp %u (0x%x) for Data Signature\n",
1350 testComm),
"cannot broadcast start time value");
1378 if(fd ==
NULL)
FAIL(
"Cannot create file");
1385 "Commencing write performance test: %s",
1391 fprintf(
out_logfile,
"* data moved = %llu\n", dataMoved);
1424 "Verifying contents of the file(s) just written.\n");
1440 if(fd ==
NULL)
FAIL(
"Cannot open file");
1453 WARN(
"Could not read back the stonewalling status from the file!");
1457 int operation_flag =
READ;
1477 unsigned int iseed0;
1479 nodeoffset = (nodeoffset < params->
numNodes) ? nodeoffset : params->
numNodes - 1;
1484 srand(
rank + iseed0);
1509 if(fd ==
NULL)
FAIL(
"Cannot open file");
1516 "Commencing read performance test: %s\n",
1520 dataMoved =
WriteOrRead(params, &results[rep], fd, operation_flag, &ioBuffers);
1538 double start, finish;
1563 if (hog_buf !=
NULL)
1577 test, &defaults, repetitions);
1579 ERR(
"too few tasks for testing");
1581 WARN_RESET(
"inter-test delay must be nonnegative value",
1582 test, &defaults, interTestDelay);
1585 ERR(
"test must write, read, or check read/write file");
1587 ERR(
"using readCheck only requires to write a timeStampSignature -- use -G");
1589 ERR(
"segment count must be positive value");
1591 ERR(
"block size must be a multiple of access size");
1593 ERR(
"block size must be non-negative integer");
1595 ERR(
"transfer size must be a multiple of access size");
1597 ERR(
"transfer size must be non-negative integer");
1599 ERR(
"test will not complete with zero transfer size");
1602 ERR(
"block size must be a multiple of transfer size");
1605 ERR(
"block size must not be smaller than transfer size");
1607 ERR(
"IOR will randomize access within a block and repeats the same pattern for all segments, therefore choose blocksize > transferSize");
1609 ERR(
"Setting the randomPrefill option without using random is not useful");
1611 ERR(
"The randomPrefill option must divide the blockSize");
1613 if ((strcasecmp(test->
api,
"MPIIO") == 0)
1616 ERR(
"block/transfer size may not be smaller than IOR_size_t for MPIIO");
1617 if ((strcasecmp(test->
api,
"HDF5") == 0)
1620 ERR(
"block/transfer size may not be smaller than IOR_size_t for HDF5");
1621 if ((strcasecmp(test->
api,
"NCMPI") == 0)
1624 ERR(
"block/transfer size may not be smaller than IOR_size_t for NCMPI");
1625 if (((strcasecmp(test->
api,
"POSIX") != 0)
1626 && (strcasecmp(test->
api,
"MPIIO") != 0)
1627 && (strcasecmp(test->
api,
"MMAP") != 0)
1628 && (strcasecmp(test->
api,
"HDFS") != 0)
1629 && (strcasecmp(test->
api,
"DFS") != 0)
1630 && (strcasecmp(test->
api,
"Gfarm") != 0)
1631 && (strcasecmp(test->
api,
"RADOS") != 0)
1632 && (strcasecmp(test->
api,
"CEPHFS") != 0)) && test->
fsync)
1633 WARN_RESET(
"fsync() not supported in selected backend",
1634 test, &defaults, fsync);
1637 ERR(
"Both Constant and Random task re-ordering specified. Choose one and resubmit");
1640 ERR(
"random offset and random reorder tasks specified with single-shared-file. Choose one and resubmit");
1643 ERR(
"random offset and constant reorder tasks specified with single-shared-file. Choose one and resubmit");
1645 ERR(
"random offset with read check option requires to set the random seed");
1647 ERR(
"random offset not available with store file offset option)");
1649 ERR(
"random offset not available with HDF5");
1651 ERR(
"random offset not available with NCMPI");
1653 ERR(
"file-per-proc not available in current NCMPI");
1661 ERR(
"The backend returned that the test parameters are invalid.");
1702 MPI_CHECK(MPI_Bcast(& seed, 1, MPI_INT, 0, test->
testComm),
"cannot broadcast random seed value");
1717 if ((rand() % test->
numTasks) == pretendRank) {
1726 *out_count = offsets;
1730 for (i = 0; i < offsets; i++) {
1737 if ((rand() % test->
numTasks) == pretendRank) {
1738 offsetArray[offsetCnt] = i;
1744 for (i = 0; i < offsets; i++) {
1746 value = rand() % offsets;
1747 tmp = offsetArray[value];
1748 offsetArray[value] = offsetArray[i];
1749 offsetArray[i] = tmp;
1752 return (offsetArray);
1758 void *buffer = ioBuffers->
buffer;
1759 if (access ==
WRITE) {
1763 FillBuffer(buffer, test, offset, pretendRank);
1766 if (amtXferred != transfer)
1767 ERR(
"cannot write to file");
1772 nanosleep( & wait,
NULL);
1774 }
else if (access ==
READ) {
1776 if (amtXferred != transfer)
1777 ERR(
"cannot read from file");
1780 nanosleep( & wait,
NULL);
1783 ((
long long int*) buffer)[0] = ~((
long long int*) buffer)[0];
1785 if (amtXferred != transfer)
1786 ERR(
"cannot read from file write check");
1790 ((
long long int*) buffer)[0] = ~((
long long int*) buffer)[0];
1792 if (amtXferred != transfer){
1793 ERR(
"cannot read from file");
1795 *errors +=
CompareData(buffer, transfer, *transferCount, test, offset, pretendRank,
READCHECK);
1803 void * oldBuffer = ioBuffers->
buffer;
1806 ioBuffers->
buffer = randomPrefillBuffer;
1807 for (
int i = startSegment; i < endSegment; i++){
1808 for (
int j = 0; j < offsets; j++) {
1818 ioBuffers->
buffer = oldBuffer;
1830 uint64_t pairCnt = 0;
1833 double startForStonewall;
1852 void * randomPrefillBuffer =
NULL;
1873 for (i = 0; i < test->
segmentCount && !hitStonewall; i++) {
1877 prefillSegment(test, randomPrefillBuffer, pretendRank, fd, ioBuffers, i, i+1);
1880 fprintf(
out_logfile,
"Random: synchronizing segment count with barrier and prefill took: %fs\n",
GetTimeStamp() - t_start);
1883 for (j = 0; j < offsets && !hitStonewall ; j++) {
1887 offset = offsets_rnd[j] + (i * test->
blockSize);
1909 MPI_CHECK(MPI_Bcast(&hitStonewall, 1, MPI_INT, 0,
testComm),
"hitStonewall broadcast failed");
1915 fprintf(
out_logfile,
"%d: stonewalling pairs accessed: %lld\n",
rank, (
long long) pairCnt);
1917 long long data_moved_ll = (
long long) dataMoved;
1918 long long pairs_accessed_min = 0;
1920 1, MPI_LONG_LONG_INT, MPI_MAX,
testComm),
"cannot reduce pairs moved");
1921 double stonewall_runtime =
GetTimeStamp() - startForStonewall;
1923 MPI_CHECK(MPI_Reduce(& pairCnt, & pairs_accessed_min,
1924 1, MPI_LONG_LONG_INT, MPI_MIN, 0,
testComm),
"cannot reduce pairs moved");
1926 1, MPI_LONG_LONG_INT, MPI_MIN, 0,
testComm),
"cannot reduce pairs moved");
1928 1, MPI_LONG_LONG_INT, MPI_SUM, 0,
testComm),
"cannot reduce pairs moved");
1932 fprintf(
out_logfile,
"stonewalling pairs accessed min: %lld max: %zu -- min data: %.1f GiB mean data: %.1f GiB time: %.1fs\n",
1948 offset = offsets_rnd[j] + (i * test->
blockSize);
1975 if(randomPrefillBuffer){
void init_IOR_Param_t(IOR_param_t *p, MPI_Comm com)
int GetNumTasks(MPI_Comm comm)
IOR_test_t * ParseCommandLine(int argc, char **argv, MPI_Comm com)
int reorderTasksRandomSeed
int ior_main(int argc, char **argv)
long long stonewall_avg_data_accessed
unsigned long GetProcessorAndCore(int *chip, int *core)
static void file_hits_histogram(IOR_param_t *params)
static void DisplayOutliers(int numTasks, double timerVal, char *timeString, int access, int outlierThreshold)
IOR_offset_t segmentCount
unsigned int incompressibleSeed
static void ValidateTests(IOR_param_t *params, MPI_Comm com)
IOR_offset_t aggFileSizeFromStat
unsigned int timeStampSignatureValue
int64_t ReadStoneWallingIterations(char *const filename, MPI_Comm com)
IOR_offset_t segmentCount
void PrintHeader(int argc, char **argv)
static void XferBuffersFree(IOR_io_buffers *ioBuffers, IOR_param_t *test)
void PrintLongSummaryOneTest(IOR_test_t *test)
int test_time_elapsed(IOR_param_t *params, double startTime)
void(* delete)(char *, aiori_mod_opt_t *module_options)
void FreeResults(IOR_test_t *test)
IOR_offset_t transferSize
void PrintLongSummaryHeader()
ior_memory_flags gpuMemoryFlags
int(* mkdir)(const char *path, mode_t mode, aiori_mod_opt_t *module_options)
static size_t CompareData(void *expectedBuffer, size_t size, IOR_offset_t transferCount, IOR_param_t *test, IOR_offset_t offset, int fillrank, int access)
IOR_offset_t aggFileSizeFromXfer
int QueryNodeMapping(MPI_Comm comm, int print_nodemap)
static int totalErrorCount
static void * HogMemory(IOR_param_t *params)
IOR_offset_t * GetOffsetArrayRandom(IOR_param_t *test, int pretendRank, IOR_offset_t *out_count)
static void DestroyTest(IOR_test_t *test)
static void ReduceIterResults(IOR_test_t *test, double *timer, const int rep, const int access)
int setTimeStampSignature
IOR_offset_t expectedAggFileSize
int(* access)(const char *path, int mode, aiori_mod_opt_t *module_options)
#define WARN_RESET(MSG, TO_STRUCT_PTR, FROM_STRUCT_PTR, MEMBER)
#define MPI_CHECK(MPI_STATUS, MSG)
IOR_test_t * ior_run(int argc, char **argv, MPI_Comm world_com, FILE *world_out)
static IOR_offset_t WriteOrRead(IOR_param_t *test, IOR_results_t *results, aiori_fd_t *fd, const int access, IOR_io_buffers *ioBuffers)
char * stoneWallingStatusFile
void ShowTestStart(IOR_param_t *params)
static char ** ParseFileName(char *, int *)
static void ProcessIterResults(IOR_test_t *test, double *timer, const int rep, const int access)
void GetTestFileName(char *testFileName, IOR_param_t *test)
int(* check_params)(aiori_mod_opt_t *)
static void DistributeHints(MPI_Comm com)
static unsigned int reseed_incompressible_prng
void ShowSetup(IOR_param_t *params)
static aiori_xfer_hint_t * hints
void init_clock(MPI_Comm com)
IOR_offset_t aggFileSizeForBW
void(* initialize)(aiori_mod_opt_t *options)
static void XferBuffersSetup(IOR_io_buffers *ioBuffers, IOR_param_t *test, int pretendRank)
char * CurrentTimeString(void)
void PrintRemoveTiming(double start, double finish, int rep)
void(* fsync)(aiori_fd_t *, aiori_mod_opt_t *module_options)
static void FillBuffer(void *buffer, IOR_param_t *test, unsigned long long offset, int fillrank)
static int test_initialize(IOR_test_t *test)
static void RemoveFile(char *testFileName, int filePerProc, IOR_param_t *test)
static void CheckForOutliers(IOR_param_t *test, const double *timer, const int access)
IOR_offset_t(* get_file_size)(aiori_mod_opt_t *module_options, char *filename)
IOR_offset_t expectedAggFileSize
int GetNumNodes(MPI_Comm comm)
static void DestroyTests(IOR_test_t *tests_head)
void(* xfer_hints)(aiori_xfer_hint_t *params)
void(* close)(aiori_fd_t *, aiori_mod_opt_t *module_options)
int aiori_warning_as_errors
int(* stat)(const char *path, struct stat *buf, aiori_mod_opt_t *module_options)
static void CheckFileSize(IOR_test_t *test, char *testFilename, IOR_offset_t dataMoved, int rep, const int access)
char * saveRankDetailsCSV
double GetTimeStamp(void)
static void WriteTimes(IOR_param_t *test, const double *timer, const int iteration, const int access)
#define EWARNF(FORMAT,...)
static void prefillSegment(IOR_param_t *test, void *randomPrefillBuffer, int pretendRank, aiori_fd_t *fd, IOR_io_buffers *ioBuffers, int startSegment, int endSegment)
IOR_offset_t transferSize
void PrintShortSummary(IOR_test_t *test)
static const ior_aiori_t * backend
aiori_fd_t *(* create)(char *, int iorflags, aiori_mod_opt_t *)
long long stonewall_min_data_accessed
IOR_offset_t(* xfer)(int access, aiori_fd_t *, IOR_size_t *, IOR_offset_t size, IOR_offset_t offset, aiori_mod_opt_t *module_options)
IOR_test_t * CreateTest(IOR_param_t *init_params, int test_num)
static void TestIoSys(IOR_test_t *)
void PrintLongSummaryAllTests(IOR_test_t *tests_head)
void PrintReducedResult(IOR_test_t *test, int access, double bw, double iops, double latency, double *diff_subset, double totalTime, int rep)
enum PACKET_TYPE dataPacketType
static void StoreRankInformation(IOR_test_t *test, double *timer, const int rep, const int access)
void(* finalize)(aiori_mod_opt_t *options)
const char * aiori_default(void)
uint64_t stoneWallingWearOutIterations
static int CountErrors(IOR_param_t *test, int access, int errors)
IOR_offset_t randomPrefillBlocksize
static void * malloc_and_touch(size_t size)
aiori_fd_t *(* open)(char *, int iorflags, aiori_mod_opt_t *)
const struct ior_aiori * backend
static void FillIncompressibleBuffer(void *buffer, IOR_param_t *test)
static char * PrependDir(IOR_param_t *, char *)
void DelaySecs(int delay)
int deadlineForStonewalling
#define FILENAME_DELIMITER
static void test_finalize(IOR_test_t *test)
long long stonewall_total_data_accessed
void aligned_buffer_free(void *buf, ior_memory_flags gpu)
static void ior_set_xfer_hints(IOR_param_t *p)
static void InitTests(IOR_test_t *)
long long int IOR_offset_t
int GetNumTasksOnNode0(MPI_Comm comm)
static IOR_offset_t WriteOrReadSingle(IOR_offset_t offset, int pretendRank, IOR_offset_t transfer, IOR_offset_t *transferCount, int *errors, IOR_param_t *test, aiori_fd_t *fd, IOR_io_buffers *ioBuffers, int access)
void ShowTestEnd(IOR_test_t *tptr)
void * safeMalloc(uint64_t size)
void AllocResults(IOR_test_t *test)
void * aligned_buffer_alloc(size_t size, ior_memory_flags type)