v1.64.00 (#198)

* Added BLOCKSIZES to a2asweep preset to allow sweeping over threadblock sizes
* Fixing src initialization when using BYTE_OFFSET
* Adding FILL_COMPRESS functionality to allow for different input data patterns
* Updating CHANGELOG regarding GFX_BLOCKSIZE limit increase to 1024

Author: gilbertlee-amd

CHANGELOG.md

@@ -3,6 +3,27 @@
 Documentation for TransferBench is available at
 [https://rocm.docs.amd.com/projects/TransferBench](https://rocm.docs.amd.com/projects/TransferBench).
 
+## v1.64.00
+### Added
+- Added BLOCKSIZES to a2asweep preset to allow also sweeping over threadblock sizes
+- Added FILL_COMPRESS to allow more control over input data pattern
+  - FILL_COMPRESS takes in a comma-separated list of integer percentages (that must add up to 100)
+    that sets the percentages of 64B lines to be filled by random/1B0/2B0/4B0/32B0 data patterns
+    - Bins:
+      - 0 - random
+      - 1 - 1B0    upper 1 byte of each aligned 2 bytes is 0
+      - 2 - 2B0    upper 2 bytes of each aligned 4 bytes is 0
+      - 3 - 4B0    upper 4 bytes of each aligned 8 bytes is 0
+      - 4 - 32B0   upper 32 bytes of each aligned 64-byte line are 0
+  - FILL_PATTERN will be ignored if FILL_COMPRESS is specified
+- Additional details about data patterns generated will be printed if the debug env var DUMP_LINES is
+  set to a non-zero value, which also corresponds to how many 64 byte lines will be printed
+### Modified
+- Increased GFX_BLOCKSIZE limit from 512 to 1024 (still requires multiple of 64)
+
+### Fixed
+- Fixed bug when using BYTE_OFFSET
+
 ## v1.63.00
 ### Added
 - Added `gfx950`, `gfx1150`, and `gfx1151` to default GPU targets list in CMake builds

CMakeLists.txt

@@ -9,7 +9,7 @@ if (NOT CMAKE_TOOLCHAIN_FILE)
   message(STATUS "CMAKE_TOOLCHAIN_FILE: ${CMAKE_TOOLCHAIN_FILE}")
 endif()
 
-set(VERSION_STRING "1.63.00")
+set(VERSION_STRING "1.64.00")
 project(TransferBench VERSION ${VERSION_STRING} LANGUAGES CXX)
 
 ## Load CMake modules

Makefile

@@ -83,4 +83,3 @@ TransferBenchCuda: ./src/client/Client.cpp $(shell find -regex ".*\.\hpp")
 
 clean:
 	rm -f ./TransferBench ./TransferBenchCuda
-

src/client/EnvVars.hpp

@@ -77,6 +77,7 @@ class EnvVars
   int blockBytes;                    // Each subexecutor, except the last, gets a multiple of this many bytes to copy
   int byteOffset;                    // Byte-offset for memory allocations
   vector<float> fillPattern;         // Pattern of floats used to fill source data
+  vector<int> fillCompress;          // Percentages of 64B lines to be filled by random/1B0/2B0/4B0/32B0
   int validateDirect;                // Validate GPU destination memory directly instead of staging GPU memory on host
   int validateSource;                // Validate source GPU memory immediately after preparation
 
@@ -137,6 +138,7 @@ class EnvVars
     alwaysValidate    = GetEnvVar("ALWAYS_VALIDATE"     , 0);
     blockBytes        = GetEnvVar("BLOCK_BYTES"         , 256);
     byteOffset        = GetEnvVar("BYTE_OFFSET"         , 0);
+    fillCompress      = GetEnvVarArray("FILL_COMPRESS"  , {});
     gfxBlockOrder     = GetEnvVar("GFX_BLOCK_ORDER"     , 0);
     gfxBlockSize      = GetEnvVar("GFX_BLOCK_SIZE"      , 256);
     gfxSingleTeam     = GetEnvVar("GFX_SINGLE_TEAM"     , 1);
@@ -314,6 +316,7 @@ class EnvVars
     printf(" CLOSEST_NIC       - Comma-separated list of per-GPU closest NIC (default=auto)\n");
 #endif
     printf(" CU_MASK           - CU mask for streams. Can specify ranges e.g '5,10-12,14'\n");
+    printf(" FILL_COMPRESS     - Percentages of 64B lines to be filled by random/1B0/2B0/4B0/32B0\n");
     printf(" FILL_PATTERN      - Big-endian pattern for source data, specified in hex digits. Must be even # of digits\n");
     printf(" GFX_BLOCK_ORDER   - How blocks for transfers are ordered. 0=sequential, 1=interleaved\n");
     printf(" GFX_BLOCK_SIZE    - # of threads per threadblock (Must be multiple of 64)\n");
@@ -400,6 +403,8 @@ class EnvVars
 #endif
     Print("CU_MASK", getenv("CU_MASK") ? 1 : 0,
           "%s", (cuMask.size() ? GetCuMaskDesc().c_str() : "All"));
+    Print("FILL_COMPRESS", getenv("FILL_COMPRESS") ? 1 : 0,
+          "%s", (fillCompress.size() ? GetStr(fillCompress).c_str() : "Not specified"));
     Print("FILL_PATTERN", getenv("FILL_PATTERN") ? 1 : 0,
           "%s", (fillPattern.size() ? getenv("FILL_PATTERN") : TransferBench::GetStrAttribute(ATR_SRC_PREP_DESCRIPTION).c_str()));
     Print("GFX_BLOCK_ORDER", gfxBlockOrder,
@@ -493,6 +498,27 @@ class EnvVars
   }
 
   static std::vector<int> GetEnvVarArray(std::string const& varname, std::vector<int> const& defaultValue)
+  {
+    if (getenv(varname.c_str())) {
+      std::vector<int> values;
+      char* arrayStr = getenv(varname.c_str());
+      char* token = strtok(arrayStr, ",");
+      while (token) {
+        int val;
+        if (sscanf(token, "%d", &val) == 1) {
+          values.push_back(val);
+        } else {
+          printf("[ERROR] Unrecognized token [%s]\n", token);
+          exit(1);
+        }
+        token = strtok(NULL, ",");
+      }
+      return values;
+    }
+    return defaultValue;
+  }
+
+  static std::vector<int> GetEnvVarRangeArray(std::string const& varname, std::vector<int> const& defaultValue)
   {
     if (getenv(varname.c_str())) {
       char* rangeStr = getenv(varname.c_str());
@@ -524,6 +550,15 @@ class EnvVars
     return defaultValue;
   }
 
+  std::string GetStr(std::vector<int> const& varnameList) const {
+    std::string result = "";
+    for (int i = 0; i < varnameList.size(); i++) {
+      if (i) result += ",";
+      result += std::to_string(varnameList[i]);
+    }
+    return result;
+  }
+
   std::string GetCuMaskDesc() const
   {
     std::vector<std::pair<int, int>> runs;
@@ -572,9 +607,10 @@ class EnvVars
     cfg.data.alwaysValidate        = alwaysValidate;
     cfg.data.blockBytes            = blockBytes;
     cfg.data.byteOffset            = byteOffset;
+    cfg.data.fillCompress          = fillCompress;
+    cfg.data.fillPattern           = fillPattern;
     cfg.data.validateDirect        = validateDirect;
     cfg.data.validateSource        = validateSource;
-    cfg.data.fillPattern           = fillPattern;
 
     cfg.dma.useHipEvents           = useHipEvents;
     cfg.dma.useHsaCopy             = useHsaDma;

src/client/Presets/AllToAllSweep.hpp

@@ -50,6 +50,7 @@ void AllToAllSweepPreset(EnvVars&           ev,
   int useSpray      = EnvVars::GetEnvVar("USE_SPRAY",       0);
   int verbose       = EnvVars::GetEnvVar("VERBOSE",         0);
 
+  std::vector<int> blockList  = EnvVars::GetEnvVarArray("BLOCKSIZES", {256});
   std::vector<int> unrollList = EnvVars::GetEnvVarArray("UNROLLS", {1,2,3,4,6,8});
   std::vector<int> numCusList = EnvVars::GetEnvVarArray("NUM_CUS", {4,8,12,16,24,32});
 
@@ -77,6 +78,7 @@ void AllToAllSweepPreset(EnvVars&           ev,
     ev.Print("A2A_MODE"       , (a2aMode == A2A_CUSTOM) ?  std::to_string(numSrcs) + ":" + std::to_string(numDsts) : std::to_string(a2aMode),
                                 (a2aMode == A2A_CUSTOM) ? (std::to_string(numSrcs) + " read(s) " +
                                                            std::to_string(numDsts) + " write(s)").c_str(): a2aModeStr[a2aMode]);
+    ev.Print("BLOCKSIZES"     , blockList.size() , EnvVars::ToStr(blockList).c_str());
     ev.Print("SHOW_MIN_ONLY"  , showMinOnly      , showMinOnly ? "Showing only slowest GPU results" : "Showing slowest and fastest GPU results");
     ev.Print("NUM_CUS"        , numCusList.size(), EnvVars::ToStr(numCusList).c_str());
     ev.Print("NUM_GPU_DEVICES", numGpus          , "Using %d GPUs", numGpus);
@@ -180,48 +182,53 @@ void AllToAllSweepPreset(EnvVars&           ev,
   std::map<std::pair<int, int>, TransferBench::TestResults> results;
 
   // Display summary
-  printf("#CUs\\Unroll");
-  for (int u : unrollList) {
-    printf("  %d(Min) ", u);
-    if (!showMinOnly) printf("  %d(Max) ", u);
-  }
-  printf("\n");
-  for (int c : numCusList) {
-    printf("   %5d   ", c);  fflush(stdout);
+  for (int blockSize : blockList) {
+    printf("Blocksize: %d\n", blockSize);
+    ev.gfxBlockSize = cfg.gfx.blockSize = blockSize;
+
+    printf("#CUs\\Unroll");
     for (int u : unrollList) {
-      ev.gfxUnroll = cfg.gfx.unrollFactor = u;
-      for (auto& transfer : transfers)
-        transfer.numSubExecs = useSpray ? (c * targetCount) : c;
-
-      double minBandwidth = std::numeric_limits<double>::max();
-      double maxBandwidth = std::numeric_limits<double>::min();
-      TransferBench::TestResults result;
-      if (TransferBench::RunTransfers(cfg, transfers, result)) {
-        for (auto const& exeResult : result.exeResults) {
-          minBandwidth = std::min(minBandwidth, exeResult.second.avgBandwidthGbPerSec);
-	  maxBandwidth = std::max(maxBandwidth, exeResult.second.avgBandwidthGbPerSec);
-	}
-        if (useSpray) {
-	  minBandwidth *= targetCount;
-	  maxBandwidth *= targetCount;
-	}
-        results[std::make_pair(c,u)] = result;
-      } else {
-        minBandwidth = 0.0;
-      }
-      printf(" %7.2f ", minBandwidth);
-      if (!showMinOnly) printf(" %7.2f ", maxBandwidth);
-      fflush(stdout);
+      printf("  %d(Min) ", u);
+      if (!showMinOnly) printf("  %d(Max) ", u);
     }
-    printf("\n"); fflush(stdout);
-  }
-
-  if (verbose) {
-    int testNum = 0;
+    printf("\n");
     for (int c : numCusList) {
+      printf("   %5d   ", c);  fflush(stdout);
       for (int u : unrollList) {
-        printf("CUs: %d Unroll %d\n", c, u);
-        PrintResults(ev, ++testNum, transfers, results[std::make_pair(c,u)]);
+        ev.gfxUnroll = cfg.gfx.unrollFactor = u;
+        for (auto& transfer : transfers)
+          transfer.numSubExecs = useSpray ? (c * targetCount) : c;
+
+        double minBandwidth = std::numeric_limits<double>::max();
+        double maxBandwidth = std::numeric_limits<double>::min();
+        TransferBench::TestResults result;
+        if (TransferBench::RunTransfers(cfg, transfers, result)) {
+          for (auto const& exeResult : result.exeResults) {
+            minBandwidth = std::min(minBandwidth, exeResult.second.avgBandwidthGbPerSec);
+            maxBandwidth = std::max(maxBandwidth, exeResult.second.avgBandwidthGbPerSec);
+          }
+          if (useSpray) {
+            minBandwidth *= targetCount;
+            maxBandwidth *= targetCount;
+          }
+          results[std::make_pair(c,u)] = result;
+        } else {
+          minBandwidth = 0.0;
+        }
+        printf(" %7.2f ", minBandwidth);
+        if (!showMinOnly) printf(" %7.2f ", maxBandwidth);
+        fflush(stdout);
+      }
+      printf("\n"); fflush(stdout);
+    }
+
+    if (verbose) {
+      int testNum = 0;
+      for (int c : numCusList) {
+        for (int u : unrollList) {
+          printf("CUs: %d Unroll %d\n", c, u);
+          PrintResults(ev, ++testNum, transfers, results[std::make_pair(c,u)]);
+        }
       }
     }
   }