TransferBench.hpp 8.98 KB
Newer Older
Gilbert Lee's avatar
Gilbert Lee committed
1
/*
gilbertlee-amd's avatar
gilbertlee-amd committed
2
Copyright (c) 2019-2023 Advanced Micro Devices, Inc. All rights reserved.
Gilbert Lee's avatar
Gilbert Lee committed
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/

#include <vector>
#include <sstream>
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <cstdint>
#include <set>
#include <unistd.h>
#include <map>
#include <iostream>
#include <sstream>
34

35
#include "Compatibility.hpp"
Gilbert Lee's avatar
Gilbert Lee committed
36
37

// Helper macro for catching HIP errors
gilbertlee-amd's avatar
gilbertlee-amd committed
38
39
40
41
42
43
44
45
46
#define HIP_CALL(cmd)                                                                   \
    do {                                                                                \
        hipError_t error = (cmd);                                                       \
        if (error != hipSuccess)                                                        \
        {                                                                               \
            std::cerr << "Encountered HIP error (" << hipGetErrorString(error)          \
                      << ") at line " << __LINE__ << " in file " << __FILE__ << "\n";   \
            exit(-1);                                                                   \
        }                                                                               \
Gilbert Lee's avatar
Gilbert Lee committed
47
48
    } while (0)

gilbertlee-amd's avatar
gilbertlee-amd committed
49
50
#include "EnvVars.hpp"

Gilbert Lee's avatar
Gilbert Lee committed
51
// Simple configuration parameters
Gilbert Lee's avatar
Gilbert Lee committed
52
size_t const DEFAULT_BYTES_PER_TRANSFER = (1<<26);  // Amount of data transferred per Transfer
Gilbert Lee's avatar
Gilbert Lee committed
53

54
55
#define MAX_LINE_LEN 32768

Gilbert Lee's avatar
Gilbert Lee committed
56
57
58
// Different src/dst memory types supported
typedef enum
{
gilbertlee-amd's avatar
gilbertlee-amd committed
59
60
61
62
  MEM_CPU          = 0, // Coarse-grained pinned CPU memory
  MEM_GPU          = 1, // Coarse-grained global GPU memory
  MEM_CPU_FINE     = 2, // Fine-grained pinned CPU memory
  MEM_GPU_FINE     = 3, // Fine-grained global GPU memory
gilbertlee-amd's avatar
gilbertlee-amd committed
63
64
  MEM_CPU_UNPINNED = 4, // Unpinned CPU memory
  MEM_NULL         = 5, // NULL memory - used for empty
Gilbert Lee's avatar
Gilbert Lee committed
65
66
} MemType;

gilbertlee-amd's avatar
gilbertlee-amd committed
67
typedef enum
gilbertlee-amd's avatar
gilbertlee-amd committed
68
{
gilbertlee-amd's avatar
gilbertlee-amd committed
69
70
71
72
  EXE_CPU          = 0, // CPU executor              (subExecutor = CPU thread)
  EXE_GPU_GFX      = 1, // GPU kernel-based executor (subExecutor = threadblock/CU)
  EXE_GPU_DMA      = 2, // GPU SDMA-based executor   (subExecutor = streams)
} ExeType;
Gilbert Lee's avatar
Gilbert Lee committed
73

gilbertlee-amd's avatar
gilbertlee-amd committed
74
75
76
77
78
79
80
81
bool IsGpuType(MemType m) { return (m == MEM_GPU || m == MEM_GPU_FINE); }
bool IsCpuType(MemType m) { return (m == MEM_CPU || m == MEM_CPU_FINE || m == MEM_CPU_UNPINNED); };
bool IsGpuType(ExeType e) { return (e == EXE_GPU_GFX || e == EXE_GPU_DMA); };
bool IsCpuType(ExeType e) { return (e == EXE_CPU); };

char const MemTypeStr[7] = "CGBFUN";
char const ExeTypeStr[4] = "CGD";
char const ExeTypeName[3][4] = {"CPU", "GPU", "DMA"};
Gilbert Lee's avatar
Gilbert Lee committed
82

Gilbert Lee's avatar
Gilbert Lee committed
83
84
MemType inline CharToMemType(char const c)
{
gilbertlee-amd's avatar
gilbertlee-amd committed
85
  char const* val = strchr(MemTypeStr, toupper(c));
86
  if (val) return (MemType)(val - MemTypeStr);
gilbertlee-amd's avatar
gilbertlee-amd committed
87
88
  printf("[ERROR] Unexpected memory type (%c)\n", c);
  exit(1);
Gilbert Lee's avatar
Gilbert Lee committed
89
90
}

gilbertlee-amd's avatar
gilbertlee-amd committed
91
ExeType inline CharToExeType(char const c)
Gilbert Lee's avatar
Gilbert Lee committed
92
{
gilbertlee-amd's avatar
gilbertlee-amd committed
93
  char const* val = strchr(ExeTypeStr, toupper(c));
94
  if (val) return (ExeType)(val - ExeTypeStr);
gilbertlee-amd's avatar
gilbertlee-amd committed
95
96
97
  printf("[ERROR] Unexpected executor type (%c)\n", c);
  exit(1);
}
Gilbert Lee's avatar
Gilbert Lee committed
98

gilbertlee-amd's avatar
gilbertlee-amd committed
99
100
// Each Transfer performs reads from source memory location(s), sums them (if multiple sources are specified)
// then writes the summation to each of the specified destination memory location(s)
Gilbert Lee's avatar
Gilbert Lee committed
101
struct Transfer
Gilbert Lee's avatar
Gilbert Lee committed
102
{
103
  // Inputs
104
105
  ExeType                    exeType;            // Transfer executor type
  int                        exeIndex;           // Executor index (NUMA node for CPU / device ID for GPU)
106
  int                        exeSubIndex;        // Executor subindex
107
108
109
110
111
112
113
114
115
  int                        numSubExecs;        // Number of subExecutors to use for this Transfer
  size_t                     numBytes;           // # of bytes requested to Transfer (may be 0 to fallback to default)
  int                        numSrcs;            // Number of sources
  std::vector<MemType>       srcType;            // Source memory types
  std::vector<int>           srcIndex;           // Source device indice
  int                        numDsts;            // Number of destinations
  std::vector<MemType>       dstType;            // Destination memory type
  std::vector<int>           dstIndex;           // Destination device index

116
117
118
119
120
121
122
123
124
125
  // Outputs
  size_t                     numBytesActual;     // Actual number of bytes to copy
  double                     transferTime;       // Time taken in milliseconds
  std::vector<double>        perIterationTime;   // Per-iteration timing
  std::vector<std::set<std::pair<int,int>>> perIterationCUs; // Per-iteration CU usage

  // Internal
  int                        transferIndex;      // Transfer identifier (within a Test)
  std::vector<float*>        srcMem;             // Source memory
  std::vector<float*>        dstMem;             // Destination memory
126
127
  std::vector<SubExecParam>  subExecParam;       // Defines subarrays assigned to each threadblock
  SubExecParam*              subExecParamGpuPtr; // Pointer to GPU copy of subExecParam
128
  std::vector<int>           subExecIdx;         // Indicies into subExecParamGpu
129

gilbertlee-amd's avatar
gilbertlee-amd committed
130
131
132
133
  // Prepares src/dst subarray pointers for each SubExecutor
  void PrepareSubExecParams(EnvVars const& ev);

  // Prepare source arrays with input data
134
  bool PrepareSrc(EnvVars const& ev);
gilbertlee-amd's avatar
gilbertlee-amd committed
135
136
137
138
139
140
141
142
143
144

  // Validate that destination data contains expected results
  void ValidateDst(EnvVars const& ev);

  // Prepare reference buffers
  void PrepareReference(EnvVars const& ev, std::vector<float>& buffer, int bufferIdx);

  // String representation functions
  std::string SrcToStr() const;
  std::string DstToStr() const;
Gilbert Lee's avatar
Gilbert Lee committed
145
146
147
148
};

struct ExecutorInfo
{
gilbertlee-amd's avatar
gilbertlee-amd committed
149
150
151
  std::vector<Transfer*>   transfers;        // Transfers to execute
  size_t                   totalBytes;       // Total bytes this executor transfers
  int                      totalSubExecs;    // Total number of subExecutors to use
Gilbert Lee's avatar
Gilbert Lee committed
152
153

  // For GPU-Executors
gilbertlee-amd's avatar
gilbertlee-amd committed
154
  SubExecParam*            subExecParamGpu;  // GPU copy of subExecutor parameters
Gilbert Lee's avatar
Gilbert Lee committed
155
156
157
158
159
160
161
162
  std::vector<hipStream_t> streams;
  std::vector<hipEvent_t>  startEvents;
  std::vector<hipEvent_t>  stopEvents;

  // Results
  double totalTime;
};

gilbertlee-amd's avatar
gilbertlee-amd committed
163
typedef std::pair<ExeType, int> Executor;
Gilbert Lee's avatar
Gilbert Lee committed
164
typedef std::map<Executor, ExecutorInfo> TransferMap;
Gilbert Lee's avatar
Gilbert Lee committed
165
166
167
168
169
170
171
172

// Display usage instructions
void DisplayUsage(char const* cmdName);

// Display detected GPU topology / CPU numa nodes
void DisplayTopology(bool const outputToCsv);

// Build array of test sizes based on sampling factor
Gilbert Lee's avatar
Gilbert Lee committed
173
void PopulateTestSizes(size_t const numBytesPerTransfer, int const samplingFactor,
Gilbert Lee's avatar
Gilbert Lee committed
174
175
                       std::vector<size_t>& valuesofN);

176
177
void ParseMemType(EnvVars const& ev, std::string const& token, std::vector<MemType>& memType, std::vector<int>& memIndex);
void ParseExeType(EnvVars const& ev, std::string const& token, ExeType& exeType, int& exeIndex, int& exeSubIndex);
Gilbert Lee's avatar
Gilbert Lee committed
178

179
void ParseTransfers(EnvVars const& ev, char* line, std::vector<Transfer>& transfers);
Gilbert Lee's avatar
Gilbert Lee committed
180

gilbertlee-amd's avatar
gilbertlee-amd committed
181
void ExecuteTransfers(EnvVars const& ev, int const testNum, size_t const N,
gilbertlee-amd's avatar
gilbertlee-amd committed
182
183
                      std::vector<Transfer>& transfers, bool verbose = true,
                      double* totalBandwidthCpu = nullptr);
Gilbert Lee's avatar
Gilbert Lee committed
184
185
186

void EnablePeerAccess(int const deviceId, int const peerDeviceId);
void AllocateMemory(MemType memType, int devIndex, size_t numBytes, void** memPtr);
gilbertlee-amd's avatar
gilbertlee-amd committed
187
void DeallocateMemory(MemType memType, void* memPtr, size_t const size = 0);
Gilbert Lee's avatar
Gilbert Lee committed
188
void CheckPages(char* byteArray, size_t numBytes, int targetId);
189
void RunTransfer(EnvVars const& ev, int const iteration, ExecutorInfo& exeInfo, int const transferIdx);
gilbertlee-amd's avatar
gilbertlee-amd committed
190
void RunPeerToPeerBenchmarks(EnvVars const& ev, size_t N);
191
void RunScalingBenchmark(EnvVars const& ev, size_t N, int const exeIndex, int const maxSubExecs);
gilbertlee-amd's avatar
gilbertlee-amd committed
192
void RunSweepPreset(EnvVars const& ev, size_t const numBytesPerTransfer, int const numGpuSubExec, int const numCpuSubExec, bool const isRandom);
gilbertlee-amd's avatar
gilbertlee-amd committed
193
void RunAllToAllBenchmark(EnvVars const& ev, size_t const numBytesPerTransfer, int const numSubExecs);
194
void RunSchmooBenchmark(EnvVars const& ev, size_t const numBytesPerTransfer, int const localIdx, int const remoteIdx, int const maxSubExecs);
Gilbert Lee's avatar
Gilbert Lee committed
195
196

std::string GetLinkTypeDesc(uint32_t linkType, uint32_t hopCount);
gilbertlee-amd's avatar
gilbertlee-amd committed
197
198

int RemappedIndex(int const origIdx, bool const isCpuType);
gilbertlee-amd's avatar
gilbertlee-amd committed
199
void LogTransfers(FILE *fp, int const testNum, std::vector<Transfer> const& transfers);
gilbertlee-amd's avatar
gilbertlee-amd committed
200
std::string PtrVectorToStr(std::vector<float*> const& strVector, int const initOffset);