Merge pull request #1 from gilbertlee-amd/SweepPreset

Implementing sweep preset

CHANGELOG.md

 # Changelog for TransferBench
 
+## v1.03
+### Added
+- New preset modes stress-test benchmarks "sweep" and "randomsweep"
+  - sweep iterates over all possible sets of Transfers to test
+  - randomsweep iterates over random sets of Transfers
+  -  New sweep-only environment variables can modify sweep
+     - SWEEP_SRC - String containing only "B","C","F", or "G", defining possible source memory types
+     - SWEEP_EXE - String containing only "C", or "G", defining possible executors
+     - SWEEP_DST - String containing only "B","C","F", or "G", defining possible destination memory types
+     - SWEEP_SRC_IS_EXE - Restrict executor to be the same as the source if non-zero
+     - SWEEP_MIN - Minimum number of parallel transfers to test
+     - SWEEP_MAX - Maximum number of parallel transfers to test
+     - SWEEP_COUNT - Maximum number of tests to run
+     - SWEEP_TIME_LIMIT - Maximum number of seconds to run tests for
+- New environment variable to restrict number of available GPUs to test on (primarily for sweep runs)
+  - NUM_CPU_DEVICES - Number of CPU devices
+  - NUM_GPU_DEVICES - Number of GPU devices
+### Changed
+- Fixed timing display for CPU-executors when using single stream mode
+
 ## v1.02
 ### Added
 - Setting NUM_ITERATIONS to negative number indicates to run for -NUM_ITERATIONS seconds per Test

EnvVars.hpp

@@ -25,7 +25,9 @@ THE SOFTWARE.
 
 #include <algorithm>
 
-#define TB_VERSION "1.02"
+#define TB_VERSION "1.03"
+
+extern char const MemTypeStr[];
 
 // This class manages environment variable that affect TransferBench
 class EnvVars
@@ -37,10 +39,21 @@ public:
   int const DEFAULT_SAMPLING_FACTOR      =  1;
   int const DEFAULT_NUM_CPU_PER_TRANSFER =  4;
 
+  int const DEFAULT_SWEEP_SRC_IS_EXE  = 0;
+  std::string const DEFAULT_SWEEP_SRC = "CG";
+  std::string const DEFAULT_SWEEP_EXE = "CG";
+  std::string const DEFAULT_SWEEP_DST = "CG";
+  int const DEFAULT_SWEEP_MIN         = 1;
+  int const DEFAULT_SWEEP_MAX         = 24;
+  int const DEFAULT_SWEEP_TEST_LIMIT  = 0;
+  int const DEFAULT_SWEEP_TIME_LIMIT  = 0;
+
   // Environment variables
   int blockBytes;        // Each CU, except the last, gets a multiple of this many bytes to copy
   int byteOffset;        // Byte-offset for memory allocations
+  int numCpuDevices;     // Number of CPU devices to use (defaults to # NUMA nodes detected)
   int numCpuPerTransfer; // Number of CPU child threads to use per CPU Transfer
+  int numGpuDevices;     // Number of GPU devices to use (defaults to # HIP devices detected)
   int numIterations;     // Number of timed iterations to perform.  If negative, run for -numIterations seconds instead
   int numWarmups;        // Number of un-timed warmup iterations to perform
   int outputToCsv;       // Output in CSV format
@@ -54,6 +67,16 @@ public:
 
   std::vector<float> fillPattern; // Pattern of floats used to fill source data
 
+  // Environment variables only for Sweep-preset
+  int sweepSrcIsExe;     // Non-zero if executor should always be the same as source
+  int sweepMin;          // Min number of simultaneous Transfers to be executed per test
+  int sweepMax;          // Max number of simulatneous Transfers to be executed per test
+  int sweepTestLimit;    // Max number of tests to run during sweep (0 = no limit)
+  int sweepTimeLimit;    // Max number of seconds to run sweep for  (0 = no limit)
+  std::string sweepSrc;  // Set of src memory types to be swept
+  std::string sweepExe;  // Set of executors to be swept
+  std::string sweepDst;  // Set of dst memory types to be swept
+
   // Constructor that collects values
   EnvVars()
   {
@@ -61,9 +84,15 @@ public:
     hipDeviceGetAttribute(&maxSharedMemBytes,
                           hipDeviceAttributeMaxSharedMemoryPerMultiprocessor, 0);
 
+    int numDetectedCpus = numa_num_configured_nodes();
+    int numDetectedGpus;
+    hipGetDeviceCount(&numGpuDevices);
+
     blockBytes        = GetEnvVar("BLOCK_BYTES"         , 256);
     byteOffset        = GetEnvVar("BYTE_OFFSET"         , 0);
+    numCpuDevices     = GetEnvVar("NUM_CPU_DEVICES"     , numDetectedCpus);
     numCpuPerTransfer = GetEnvVar("NUM_CPU_PER_TRANSFER", DEFAULT_NUM_CPU_PER_TRANSFER);
+    numGpuDevices     = GetEnvVar("NUM_GPU_DEVICES"     , numDetectedGpus);
     numIterations     = GetEnvVar("NUM_ITERATIONS"      , DEFAULT_NUM_ITERATIONS);
     numWarmups        = GetEnvVar("NUM_WARMUPS"         , DEFAULT_NUM_WARMUPS);
     outputToCsv       = GetEnvVar("OUTPUT_TO_CSV"       , 0);
@@ -75,6 +104,15 @@ public:
     usePcieIndexing   = GetEnvVar("USE_PCIE_INDEX"      , 0);
     useSingleStream   = GetEnvVar("USE_SINGLE_STREAM"   , 0);
 
+    sweepSrcIsExe     = GetEnvVar("SWEEP_SRC_IS_EXE", DEFAULT_SWEEP_SRC_IS_EXE);
+    sweepMin          = GetEnvVar("SWEEP_MIN", DEFAULT_SWEEP_MIN);
+    sweepMax          = GetEnvVar("SWEEP_MAX", DEFAULT_SWEEP_MAX);
+    sweepSrc          = GetEnvVar("SWEEP_SRC", DEFAULT_SWEEP_SRC);
+    sweepExe          = GetEnvVar("SWEEP_EXE", DEFAULT_SWEEP_EXE);
+    sweepDst          = GetEnvVar("SWEEP_DST", DEFAULT_SWEEP_DST);
+    sweepTestLimit    = GetEnvVar("SWEEP_TEST_LIMIT", DEFAULT_SWEEP_TEST_LIMIT);
+    sweepTimeLimit    = GetEnvVar("SWEEP_TIME_LIMIT", DEFAULT_SWEEP_TIME_LIMIT);
+
     // Check for fill pattern
     char* pattern = getenv("FILL_PATTERN");
     if (pattern != NULL)
@@ -134,6 +172,16 @@ public:
     else fillPattern.clear();
 
     // Perform some basic validation
+    if (numCpuDevices > numDetectedCpus)
+    {
+      printf("[ERROR] Number of CPUs to use (%d) cannot exceed number of detected CPUs (%d)\n", numCpuDevices, numDetectedCpus);
+      exit(1);
+    }
+    if (numGpuDevices > numDetectedGpus)
+    {
+      printf("[ERROR] Number of GPUs to use (%d) cannot exceed number of detected GPUs (%d)\n", numGpuDevices, numDetectedGpus);
+      exit(1);
+    }
     if (byteOffset % sizeof(float))
     {
       printf("[ERROR] BYTE_OFFSET must be set to multiple of %lu\n", sizeof(float));
@@ -169,6 +217,49 @@ public:
       printf("[ERROR] Single stream mode cannot be used with HIP calls\n");
       exit(1);
     }
+
+    for (auto ch : sweepSrc)
+    {
+      if (!strchr(MemTypeStr, ch))
+      {
+        printf("[ERROR] Unrecognized memory type '%c' specified for sweep source\n", ch);
+        exit(1);
+      }
+      if (strchr(sweepSrc.c_str(), ch) != strrchr(sweepSrc.c_str(), ch))
+      {
+        printf("[ERROR] Duplicate memory type '%c' specified for sweep source\n", ch);
+        exit(1);
+      }
+    }
+
+    for (auto ch : sweepDst)
+    {
+      if (!strchr(MemTypeStr, ch))
+      {
+        printf("[ERROR] Unrecognized memory type '%c' specified for sweep destination\n", ch);
+        exit(1);
+      }
+      if (strchr(sweepDst.c_str(), ch) != strrchr(sweepDst.c_str(), ch))
+      {
+        printf("[ERROR] Duplicate memory type '%c' specified for sweep destination\n", ch);
+        exit(1);
+      }
+    }
+
+    char const* permittedExecutors = "CG";
+    for (auto ch : sweepExe)
+    {
+      if (!strchr(permittedExecutors, ch))
+      {
+        printf("[ERROR] Unrecognized executor type '%c' specified for sweep executor\n", ch);
+        exit(1);
+      }
+      if (strchr(sweepExe.c_str(), ch) != strrchr(sweepExe.c_str(), ch))
+      {
+        printf("[ERROR] Duplicate executor type '%c' specified for sweep executor\n", ch);
+        exit(1);
+      }
+    }
   }
 
   // Display info on the env vars that can be used
@@ -179,7 +270,9 @@ public:
     printf(" BLOCK_BYTES=B          - Each CU (except the last) receives a multiple of BLOCK_BYTES to copy\n");
     printf(" BYTE_OFFSET            - Initial byte-offset for memory allocations.  Must be multiple of 4. Defaults to 0\n");
     printf(" FILL_PATTERN=STR       - Fill input buffer with pattern specified in hex digits (0-9,a-f,A-F).  Must be even number of digits, (byte-level big-endian)\n");
+    printf(" NUM_CPU_DEVICES=X      - Restrict number of CPUs to X.  May not be greater than # detected NUMA nodes\n");
     printf(" NUM_CPU_PER_TRANSFER=C - Use C threads per Transfer for CPU-executed copies\n");
+    printf(" NUM_GPU_DEVICES=X      - Restrict number of GCPUs to X.  May not be greater than # detected HIP devices\n");
     printf(" NUM_ITERATIONS=I       - Perform I timed iteration(s) per test\n");
     printf(" NUM_WARMUPS=W          - Perform W untimed warmup iteration(s) per test\n");
     printf(" OUTPUT_TO_CSV          - Outputs to CSV format if set\n");
@@ -207,8 +300,10 @@ public:
       else
         printf("Pseudo-random: (Element i = i modulo 383 + 31)");
       printf("\n");
-      printf("%-20s = %12d : Using %d CPU thread(s) per CPU-based-copy Transfer\n", "NUM_CPU_PER_TRANSFER", numCpuPerTransfer, numCpuPerTransfer);
-      printf("%-20s = %12d : Running %d %s per topology\n", "NUM_ITERATIONS", numIterations,
+      printf("%-20s = %12d : Using %d CPU devices\n" , "NUM_CPU_DEVICES", numCpuDevices, numCpuDevices);
+      printf("%-20s = %12d : Using %d CPU thread(s) per CPU-executed Transfer\n", "NUM_CPU_PER_TRANSFER", numCpuPerTransfer, numCpuPerTransfer);
+      printf("%-20s = %12d : Using %d GPU devices\n", "NUM_GPU_DEVICES", numGpuDevices, numGpuDevices);
+      printf("%-20s = %12d : Running %d %s per test\n", "NUM_ITERATIONS", numIterations,
              numIterations > 0 ? numIterations : -numIterations,
              numIterations > 0 ? "timed iteration(s)" : "second(s)");
       printf("%-20s = %12d : Running %d warmup iteration(s) per topology\n", "NUM_WARMUPS", numWarmups, numWarmups);
@@ -236,13 +331,70 @@ public:
     }
   };
 
+  // Display env var settings
+  void DisplaySweepEnvVars() const
+  {
+    if (!outputToCsv)
+    {
+      printf("Sweep configuration (TransferBench v%s)\n", TB_VERSION);
+      printf("=====================================================\n");
+      printf("%-20s = %12s : Source Memory Types to sweep\n", "SWEEP_SRC", sweepSrc.c_str());
+      printf("%-20s = %12s : Executor Types to sweep\n", "SWEEP_EXE", sweepExe.c_str());
+      printf("%-20s = %12s : Destination Memory Types to sweep\n", "SWEEP_DST", sweepDst.c_str());
+      printf("%-20s = %12d : Transfer executor %s Transfer source\n", "SWEEP_SRC_IS_EXE", sweepSrcIsExe, sweepSrcIsExe ? "must match" : "may have any");
+      printf("%-20s = %12d : Min simultaneous Transfers\n", "SWEEP_MIN", sweepMin);
+      printf("%-20s = %12d : Max simultaneous Transfers              (0 = no limit)\n", "SWEEP_MAX", sweepMax);
+      printf("%-20s = %12d : Max number of tests to run during sweep (0 = no limit)\n", "SWEEP_TEST_LIMIT", sweepTestLimit);
+      printf("%-20s = %12d : Max number of seconds to run sweep for  (0 = no limit)\n", "SWEEP_TIME_LIMIT", sweepTimeLimit);
+      printf("%-20s = %12d : Using %d CPU devices\n" , "NUM_CPU_DEVICES", numCpuDevices, numCpuDevices);
+      printf("%-20s = %12d : Using %d CPU thread(s) per CPU-executed Transfer\n", "NUM_CPU_PER_TRANSFER", numCpuPerTransfer, numCpuPerTransfer);
+      printf("%-20s = %12d : Using %d GPU devices\n", "NUM_GPU_DEVICES", numGpuDevices, numGpuDevices);
+      printf("%-20s = %12d : Each CU gets a multiple of %d bytes to copy\n", "BLOCK_BYTES", blockBytes, blockBytes);
+      printf("%-20s = %12d : Using byte offset of %d\n", "BYTE_OFFSET", byteOffset, byteOffset);
+      printf("%-20s = %12s : ", "FILL_PATTERN", getenv("FILL_PATTERN") ? "(specified)" : "(unset)");
+      if (fillPattern.size())
+        printf("Pattern: %s", getenv("FILL_PATTERN"));
+      else
+        printf("Pseudo-random: (Element i = i modulo 383 + 31)");
+      printf("\n");
+      printf("%-20s = %12d : Running %d %s per test\n", "NUM_ITERATIONS", numIterations,
+             numIterations > 0 ? numIterations : -numIterations,
+             numIterations > 0 ? "timed iteration(s)" : "second(s)");
+      printf("%-20s = %12d : Running %d warmup iteration(s) per topology\n", "NUM_WARMUPS", numWarmups, numWarmups);
+      printf("%-20s = %12d : Output to %s\n", "OUTPUT_TO_CSV", outputToCsv,
+             outputToCsv ? "CSV" : "console");
+      printf("%-20s = %12s : Using %d shared mem per threadblock\n", "SHARED_MEM_BYTES",
+             getenv("SHARED_MEM_BYTES") ? "(specified)" : "(unset)", sharedMemBytes);
+      printf("%-20s = %12d : Using %s for GPU-executed copies\n", "USE_HIP_CALL", useHipCall,
+             useHipCall ? "HIP functions" : "custom kernels");
+      if (useHipCall && !useMemset)
+      {
+        char* env = getenv("HSA_ENABLE_SDMA");
+        printf("%-20s = %12s : %s\n", "HSA_ENABLE_SDMA", env,
+               (env && !strcmp(env, "0")) ? "Using blit kernels for hipMemcpy" : "Using DMA copy engines");
+      }
+      printf("%-20s = %12d : Using %s-based GPU indexing\n", "USE_PCIE_INDEX",
+             usePcieIndexing, (usePcieIndexing ? "PCIe" : "HIP"));
+      printf("%-20s = %12d : Using single stream per %s\n", "USE_SINGLE_STREAM",
+             useSingleStream, (useSingleStream ? "device" : "Transfer"));
+      printf("\n");
+    }
+  };
+
   // Helper function that gets parses environment variable or sets to default value
-  static int GetEnvVar(std::string const varname, int defaultValue)
+  static int GetEnvVar(std::string const& varname, int defaultValue)
   {
     if (getenv(varname.c_str()))
       return atoi(getenv(varname.c_str()));
     return defaultValue;
   }
+
+  static std::string GetEnvVar(std::string const& varname, std::string const& defaultValue)
+  {
+    if (getenv(varname.c_str()))
+      return getenv(varname.c_str());
+    return defaultValue;
+  }
 };
 
 #endif

README.md

@@ -12,3 +12,17 @@ TransferBench is a simple utility capable of benchmarking simultaneous copies be
 * `make`
 
   If ROCm is installed in a folder other than `/opt/rocm/`, set ROCM_PATH appropriately
+
+
+## Hints and suggestions
+- Running TransferBench with no arguments will display usage instructions and detected topology information
+- There are several preset configurations that can be used instead of a configuration file
+  including:
+  - p2p    - Peer to peer benchmark test
+  - sweep  - Sweep across possible sets of Transfers
+  - rsweep - Random sweep across possible sets of Transfers
+- When using the same GPU executor in multiple simultaneous Transfers, performance may be
+  serialized due to the maximum number of hardware queues available.
+  - The number of maximum hardware queues can be adjusted via GPU_MAX_HW_QUEUES
+  - Alternatively, running in single stream mode (USE_SINGLE_STREAM=1) may avoid this issue
+    by launching all Transfers on a single stream instead of individual streams

TransferBench.hpp

@@ -61,8 +61,27 @@ typedef enum
   MEM_GPU_FINE = 3     // Fine-grained global GPU memory
 } MemType;
 
+bool IsGpuType(MemType m)
+{
+  return (m == MEM_GPU || m == MEM_GPU_FINE);
+}
+
 char const MemTypeStr[5] = "CGBF";
 
+MemType inline CharToMemType(char const c)
+{
+  switch (c)
+  {
+  case 'C': return MEM_CPU;
+  case 'G': return MEM_GPU;
+  case 'B': return MEM_CPU_FINE;
+  case 'F': return MEM_GPU_FINE;
+  default:
+    printf("[ERROR] Unexpected mem type (%c)\n", c);
+    exit(1);
+  }
+}
+
 typedef enum
 {
   MODE_FILL  = 0,         // Fill data with pattern
@@ -141,7 +160,10 @@ void ParseMemType(std::string const& token, int const numCpus, int const numGpus
                   MemType* memType, int* memIndex);
 
 void ParseTransfers(char* line, int numCpus, int numGpus,
-                TransferMap& transferMap);
+                    std::vector<Transfer>& transfers);
+
+void ExecuteTransfers(EnvVars const& ev, int testNum, std::vector<size_t> const& valuesOfN,
+                      std::vector<Transfer>& transfers);
 
 void EnablePeerAccess(int const deviceId, int const peerDeviceId);
 void AllocateMemory(MemType memType, int devIndex, size_t numBytes, void** memPtr);
@@ -150,6 +172,7 @@ void CheckPages(char* byteArray, size_t numBytes, int targetId);
 void CheckOrFill(ModeType mode, int N, bool isMemset, bool isHipCall, std::vector<float> const& fillPattern, float* ptr);
 void RunTransfer(EnvVars const& ev, size_t const N, int const iteration, ExecutorInfo& exeInfo, int const transferIdx);
 void RunPeerToPeerBenchmarks(EnvVars const& ev, size_t N, int numBlocksToUse, int readMode, int skipCpu);
+void RunSweepPreset(EnvVars const& ev, size_t const numBytesPerTransfer, bool const isRandom);
 
 // Return the maximum bandwidth measured for given (src/dst) pair
 double GetPeakBandwidth(EnvVars const& ev,