True random option added compared to shuffling when using -z -z.

Author: JulianKunkel

src/aiori-DUMMY.c

@@ -137,7 +137,7 @@ static IOR_offset_t DUMMY_GetFileSize(aiori_mod_opt_t * options, char *testFileN
 
 static IOR_offset_t DUMMY_Xfer(int access, aiori_fd_t *file, IOR_size_t * buffer, IOR_offset_t length, IOR_offset_t offset, aiori_mod_opt_t * options){
   if(verbose > 4){
-    fprintf(out_logfile, "DUMMY xfer: %p\n", file);
+    fprintf(out_logfile, "DUMMY %d xfer: %p, %lld, %lld\n", rank, file, offset, length);
   }
   dummy_options_t * o = (dummy_options_t*) options;
   if (o->delay_xfer){

src/ior.c

@@ -1,5 +1,5 @@
-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ * vim:expandtab:shiftwidth=2:tabstop=2:
  */
 /******************************************************************************\
 *                                                                              *
@@ -1401,6 +1401,9 @@ static void TestIoSys(IOR_test_t *test)
                         }
                         /* Using globally passed rankOffset, following function generates testFileName to read */
                         GetTestFileName(testFileName, params);
+                        if(params->randomOffset > 1){
+                          params->expectedAggFileSize = backend->get_file_size(params->backend_options, testFileName);
+                        }
 
                         if (verbose >= VERBOSE_3) {
                                 fprintf(out_logfile, "task %d reading %s\n", rank,
@@ -1520,7 +1523,7 @@ static void ValidateTests(IOR_param_t * test, MPI_Comm com)
         }
         if (test->blockSize < test->transferSize)
                 ERR("block size must not be smaller than transfer size");
-        if (test->randomOffset && test->blockSize == test->transferSize)
+        if (test->randomOffset == 1 && test->blockSize == test->transferSize)
             ERR("IOR will randomize access within a block and repeats the same pattern for all segments, therefore choose blocksize > transferSize");
         if (! test->randomOffset && test->randomPrefillBlocksize)
           ERR("Setting the randomPrefill option without using random is not useful");
@@ -1583,6 +1586,33 @@ static void ValidateTests(IOR_param_t * test, MPI_Comm com)
         }
 }
 
+static int init_random_seed(IOR_param_t * test, int pretendRank){
+  int seed;
+  if (test->filePerProc) {
+    /* set up seed, each process can determine which regions to access individually */
+    if (test->randomSeed == -1) {
+            seed = time(NULL);
+            test->randomSeed = seed;
+    } else {
+        seed = test->randomSeed + pretendRank;
+    }
+  }else{
+    /* Shared file requires that the seed is synchronized */
+    if (test->randomSeed == -1) {
+      // all processes need to have the same seed.
+      if(rank == 0){
+        seed = time(NULL);
+      }
+      MPI_CHECK(MPI_Bcast(& seed, 1, MPI_INT, 0, test->testComm), "cannot broadcast random seed value");
+      test->randomSeed = seed;
+    }else{
+      seed = test->randomSeed;
+    }
+  }
+  srandom(seed);
+  return seed;
+}
+
 /**
  * Returns a precomputed array of IOR_offset_t for the inner benchmark loop.
  * They get created sequentially and mixed up in the end.
@@ -1604,28 +1634,7 @@ IOR_offset_t *GetOffsetArrayRandom(IOR_param_t * test, int pretendRank, IOR_offs
         IOR_offset_t offsetCnt = 0;
         IOR_offset_t *offsetArray;
 
-        if (test->filePerProc) {
-          /* set up seed, each process can determine which regions to access individually */
-          if (test->randomSeed == -1) {
-                  seed = time(NULL);
-                  test->randomSeed = seed;
-          } else {
-              seed = test->randomSeed + pretendRank;
-          }
-        }else{
-          /* Shared file requires that the seed is synchronized */
-          if (test->randomSeed == -1) {
-            // all processes need to have the same seed.
-            if(rank == 0){
-              seed = time(NULL);
-            }
-            MPI_CHECK(MPI_Bcast(& seed, 1, MPI_INT, 0, test->testComm), "cannot broadcast random seed value");
-            test->randomSeed = seed;
-          }else{
-            seed = test->randomSeed;
-          }
-        }
-        srandom(seed);
+        seed = init_random_seed(test, pretendRank);
 
         /* count needed offsets (pass 1) */
         if (test->filePerProc) {
@@ -1766,11 +1775,15 @@ static IOR_offset_t WriteOrRead(IOR_param_t *test, int rep, IOR_results_t *resul
 
         IOR_offset_t offsets;
         IOR_offset_t * offsets_rnd;
-        if (test->randomOffset) {
+        if (test->randomOffset == 1) {
           offsets_rnd = GetOffsetArrayRandom(test, pretendRank, & offsets);
         }else{
           offsets = (test->blockSize / test->transferSize);
         }
+        if (test->randomOffset > 1){
+          int seed = init_random_seed(test, pretendRank);
+          srand(seed + pretendRank);
+        }
 
         void * randomPrefillBuffer = NULL;
         if(test->randomPrefillBlocksize && (access == WRITE || access == WRITECHECK)){
@@ -1799,9 +1812,9 @@ static IOR_offset_t WriteOrRead(IOR_param_t *test, int rep, IOR_results_t *resul
           // must synchronize processes to ensure they are not running ahead
           MPI_Barrier(test->testComm);
         }
-
         do{ // to ensure the benchmark runs a certain time
           for (i = 0; i < test->segmentCount && !hitStonewall; i++) {
+            IOR_offset_t offset;
             if(randomPrefillBuffer && test->deadlineForStonewalling != 0){
               // prefill the whole segment with data, this needs to be done collectively
               double t_start = GetTimeStamp();
@@ -1811,14 +1824,27 @@ static IOR_offset_t WriteOrRead(IOR_param_t *test, int rep, IOR_results_t *resul
                 fprintf(out_logfile, "Random: synchronizing segment count with barrier and prefill took: %fs\n", GetTimeStamp() - t_start);
               }
             }
+            if (test->randomOffset > 1){
+                size_t sizerand = test->expectedAggFileSize; 
+                if(test->filePerProc){
+                  sizerand /= test->numTasks;
+                }
+                offset = rand() % (sizerand / test->blockSize) * test->blockSize - test->transferSize;
+                if(i == 0 && access == WRITE){ // always write the last block first
+                  if(test->filePerProc || rank == 0){
+                    offset = (sizerand / test->blockSize - 1) * test->blockSize - test->transferSize;
+                  }
+                }
+            }
             for (j = 0; j < offsets &&  !hitStonewall ; j++) {
-              IOR_offset_t offset;
-              if (test->randomOffset) {
+              if (test->randomOffset == 1) {
                 if(test->filePerProc){
                   offset = offsets_rnd[j] + (i * test->blockSize);
                 }else{
                   offset = offsets_rnd[j] + (i * test->numTasks * test->blockSize);
                 }
+              }else if (test->randomOffset > 1){
+                offset += test->transferSize;
               }else{
                 offset = j * test->transferSize;
                 if (test->filePerProc) {
@@ -1873,15 +1899,24 @@ static IOR_offset_t WriteOrRead(IOR_param_t *test, int rep, IOR_results_t *resul
               i++;
             }
             for ( ; pairCnt < point->pairs_accessed; i++) {
+              IOR_offset_t offset;
               if(i == test->segmentCount) i = 0; // wrap over, necessary to deal with minTimeDuration
+              if (test->randomOffset > 1){
+                  size_t sizerand = test->expectedAggFileSize; 
+                  if(test->filePerProc){
+                    sizerand /= test->numTasks;
+                  }
+                  offset = rand() % (sizerand / test->blockSize) * test->blockSize - test->transferSize;
+              }
               for ( ; j < offsets && pairCnt < point->pairs_accessed ; j++) {
-                IOR_offset_t offset;
-                if (test->randomOffset) {
+                if (test->randomOffset == 1) {
                   if(test->filePerProc){
                     offset = offsets_rnd[j] + (i * test->blockSize);
                   }else{
                     offset = offsets_rnd[j] + (i * test->numTasks * test->blockSize);
                   }
+                }else if (test->randomOffset > 1){
+                  offset += test->transferSize;
                 }else{
                   offset = j * test->transferSize;
                   if (test->filePerProc) {

src/parse_options.c

@@ -467,7 +467,7 @@ option_help * createGlobalOptions(IOR_param_t * params){
     {'X', NULL,        "reorderTasksRandomSeed -- random seed for -Z option", OPTION_OPTIONAL_ARGUMENT, 'd', & params->reorderTasksRandomSeed},
     {'y', NULL,        "dualMount -- use dual mount points for a filesystem", OPTION_FLAG, 'd', & params->dualMount},
     {'Y', NULL,        "fsyncPerWrite -- perform sync operation after every write operation", OPTION_FLAG, 'd', & params->fsyncPerWrite},
-    {'z', NULL,        "randomOffset -- access is to random, not sequential, offsets within a file", OPTION_FLAG, 'd', & params->randomOffset},
+    {'z', NULL,        "randomOffset -- access is to shuffled, not sequential, offsets within a file, specify twice for random (potentially overlapping)", OPTION_FLAG, 'd', & params->randomOffset},
     {0, "randomPrefill", "For random -z access only: Prefill the file with this blocksize, e.g., 2m", OPTION_OPTIONAL_ARGUMENT, 'l', & params->randomPrefillBlocksize},
     {0, "random-offset-seed",        "The seed for -z", OPTION_OPTIONAL_ARGUMENT, 'd', & params->randomSeed},
     {'Z', NULL,        "reorderTasksRandom -- changes task ordering to random select regions for readback, use twice for shuffling", OPTION_FLAG, 'd', & params->reorderTasksRandom},