API

struct AgentData

#include <GetClosestNumaNode.hpp>

Public Members

bool isInitialized

std::vector<hsa_agent_t> cpuAgents

std::vector<hsa_agent_t> gpuAgents

std::vector<int> closestNumaNode

class EnvVars

#include <EnvVars.hpp>

Public Functions

inline EnvVars()

inline void DisplayEnvVars() const

inline void DisplayP2PBenchmarkEnvVars() const

inline void DisplaySweepEnvVars() const

inline void DisplayA2AEnvVars() const

inline void DisplaySchmooEnvVars() const

inline void DisplayRemoteWriteEnvVars() const

inline void DisplayParallelCopyEnvVars() const

inline std::string GetCuMaskDesc() const

Public Members

int const DEFAULT_NUM_WARMUPS = 3

int const DEFAULT_NUM_ITERATIONS = 10

int const DEFAULT_SAMPLING_FACTOR = 1

int const DEFAULT_P2P_NUM_CPU_SE = 4

std::string const DEFAULT_SWEEP_SRC = "CG"

std::string const DEFAULT_SWEEP_EXE = "CDG"

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

int alwaysValidate

int blockBytes

int blockOrder

int byteOffset

int continueOnError

int gfxBlockSize

int gfxSingleTeam

int gfxUnroll

int gfxWaveOrder

int hideEnv

int minNumVarSubExec

int maxNumVarSubExec

int numCpuDevices

int numGpuDevices

int numIterations

int numSubIterations

int numWarmups

int outputToCsv

int samplingFactor

int sharedMemBytes

int showIterations

int useHsaDma

int useInteractive

int usePcieIndexing

int usePrepSrcKernel

int useSingleStream

int useXccFilter

int validateDirect

std::vector<float> fillPattern

std::vector<uint32_t> cuMask

std::vector<std::vector<int>> prefXccTable

int numCpuSubExecs

int numGpuSubExecs

int p2pMode

int useDmaCopy

int useRemoteRead

int useFineGrain

int sweepMin

int sweepMax

int sweepTestLimit

int sweepTimeLimit

int sweepXgmiMin

int sweepXgmiMax

int sweepSeed

int sweepRandBytes

std::string sweepSrc

std::string sweepExe

std::string sweepDst

int a2aDirect

int a2aMode

int enableDebug

int gpuMaxHwQueues

ConfigModeEnum configMode

std::default_random_engine *generator

std::vector<int> numCpusPerNuma

std::vector<int> wallClockPerDeviceMhz

std::vector<std::set<int>> xccIdsPerDevice

Public Static Functions

static inline void DisplayUsage()

static inline int GetEnvVar(std::string const &varname, int defaultValue)

static inline std::string GetEnvVar(std::string const &varname, std::string const &defaultValue)

struct ExecutorInfo

#include <TransferBench.hpp>

Public Members

std::vector<Transfer*> transfers

size_t totalBytes

int totalSubExecs

SubExecParam *subExecParamGpu

std::vector<hipStream_t> streams

std::vector<hipEvent_t> startEvents

std::vector<hipEvent_t> stopEvents

double totalTime

struct ExeResult

#include <TransferBench.hpp>

Public Members

double bandwidthGbs

double durationMsec

double sumBandwidthGbs

size_t totalBytes

std::vector<int> transferIdx

struct SubExecParam

#include <Kernels.hpp>

Public Members

size_t N

int numSrcs

int numDsts

float *src[MAX_SRCS]

float *dst[MAX_DSTS]

int32_t preferredXccId

int teamSize

int teamIdx

long long startCycle

long long stopCycle

uint32_t hwId

uint32_t xccId

struct TestResults

#include <TransferBench.hpp>

Public Members

size_t numTimedIterations

size_t totalBytesTransferred

double totalBandwidthCpu

double totalDurationMsec

double overheadMsec

std::map<std::pair<ExeType, int>, ExeResult> exeResults

struct Transfer

#include <TransferBench.hpp>

Public Functions

void PrepareSubExecParams(EnvVars const &ev)

bool PrepareSrc(EnvVars const &ev)

void ValidateDst(EnvVars const &ev)

void PrepareReference(EnvVars const &ev, std::vector<float> &buffer, int bufferIdx)

std::string SrcToStr() const

std::string DstToStr() const

Public Members

ExeType exeType

int exeIndex

int exeSubIndex

int numSubExecs

size_t numBytes

int numSrcs

std::vector<MemType> srcType

std::vector<int> srcIndex

int numDsts

std::vector<MemType> dstType

std::vector<int> dstIndex

size_t numBytesActual

double transferTime

double transferBandwidth

double executorBandwidth

std::vector<double> perIterationTime

std::vector<std::set<std::pair<int, int>>> perIterationCUs

int transferIndex

std::vector<float*> srcMem

std::vector<float*> dstMem

std::vector<SubExecParam> subExecParam

SubExecParam *subExecParamGpuPtr

std::vector<int> subExecIdx

hsa_agent_t dstAgent

hsa_agent_t srcAgent

hsa_signal_t signal

hsa_amd_sdma_engine_id_t sdmaEngineId

namespace std

STL namespace.

file Compatibility.hpp

#include <hip/hip_ext.h>

#include <hip/hip_runtime.h>

#include <hsa/hsa_ext_amd.h>

Defines

HIP_CALL(cmd)

file EnvVars.hpp

#include <algorithm>

#include <random>

#include <time.h>

#include “Compatibility.hpp”

#include “Kernels.hpp”

Defines

TB_VERSION

PRINT_EV(NAME, VALUE, DESCRIPTION)

PRINT_ES(NAME, VALUE, DESCRIPTION)

Enums

enum ConfigModeEnum

Values:

enumerator CFG_FILE

enumerator CFG_P2P

enumerator CFG_SWEEP

enumerator CFG_SCALE

enumerator CFG_A2A

enumerator CFG_SCHMOO

enumerator CFG_RWRITE

enum BlockOrderEnum

Values:

enumerator ORDER_SEQUENTIAL

enumerator ORDER_INTERLEAVED

enumerator ORDER_RANDOM

Variables

char const MemTypeStr[]

char const ExeTypeStr[]

file GetClosestNumaNode.hpp

Defines

HSA_CHECK(cmd)

Functions

hsa_status_t MemPoolInfoCallback(hsa_amd_memory_pool_t pool, void *data)

hsa_status_t AgentInfoCallback(hsa_agent_t agent, void *data)

AgentData &GetAgentData()

int GetClosestNumaNode(int gpuIdx)

file Kernels.hpp

Defines

PackedFloat_t

MAX_BLOCKSIZE

FLOATS_PER_PACK

MEMSET_CHAR

MEMSET_VAL

MAX_WAVEGROUPS

MAX_UNROLL

NUM_WAVEORDERS

MAX_SRCS

MAX_DSTS

GetHwId(hwId)

GetXccId(val)

GPU_KERNEL_UNROLL_DECL(BLOCKSIZE)

Typedefs

typedef void (*GpuKernelFuncPtr)(SubExecParam*, int, int)

Functions

void CpuReduceKernel(SubExecParam const &p)

std::string PrepSrcValueString()

__host__ __device__ float PrepSrcValue (int srcBufferIdx, size_t idx)

__global__ void CollectXccIdsKernel (int *xccIds)

__global__ void PrepSrcDataKernel (float *ptr, size_t N, int srcBufferIdx)

__device__ int64_t GetTimestamp ()

template<typename T> __device__ __forceinline__ T MemsetVal ()

template<> __device__ __forceinline__ float MemsetVal ()

template<int BLOCKSIZE, int UNROLL> __global__ void __launch_bounds__ (BLOCKSIZE) GpuReduceKernel(SubExecParam *params

if (threadIdx.x==0) startCycle

GetXccId(xccId)

if (p.preferredXccId !=-1 &&xccId !=p.preferredXccId) return

for (int i=0;i< numSrcs;i++) srcFloat4[i]

switch (waveOrder)

while (1)

__syncthreads()

Variables

__global__ void int waveOrder

__global__ void int int numSubIterations  {int64_t startCycle

SubExecParam &p = params[blockIdx.y]

int32_t xccId

int32_t const numSrcs = p.numSrcs

int32_t const numDsts = p.numDsts

float4 const  *__restrict__ srcFloat4 [MAX_SRCS]

float4 *__restrict__ dstFloat4 [MAX_DSTS]

int32_t const nTeams = p.teamSize

int32_t const teamIdx = p.teamIdx

int32_t const nWaves = BLOCKSIZE / warpSize

int32_t const waveIdx = threadIdx.x / warpSize

int32_t const tIdx = threadIdx.x % warpSize

size_t const numFloat4 = p.N / 4

int32_t teamStride

int32_t waveStride

int32_t unrlStride

int32_t teamStride2

int32_t waveStride2

int subIterations = 0

GpuKernelFuncPtr GpuKernelTable[MAX_WAVEGROUPS][MAX_UNROLL] = {GPU_KERNEL_UNROLL_DECL(64), GPU_KERNEL_UNROLL_DECL(128), GPU_KERNEL_UNROLL_DECL(192), GPU_KERNEL_UNROLL_DECL(256), GPU_KERNEL_UNROLL_DECL(320), GPU_KERNEL_UNROLL_DECL(384), GPU_KERNEL_UNROLL_DECL(448),}

file TransferBench.hpp

#include <vector>

#include <sstream>

#include <chrono>

#include <cstdio>

#include <cstdlib>

#include <cstdint>

#include <set>

#include <unistd.h>

#include <map>

#include <iostream>

#include “Compatibility.hpp”

#include “EnvVars.hpp”

Defines

MAX_LINE_LEN

Typedefs

typedef std::pair<ExeType, int> Executor

typedef std::map<Executor, ExecutorInfo> TransferMap

Enums

enum MemType

Values:

enumerator MEM_CPU

enumerator MEM_GPU

enumerator MEM_CPU_FINE

enumerator MEM_GPU_FINE

enumerator MEM_CPU_UNPINNED

enumerator MEM_NULL

enumerator MEM_MANAGED

enum ExeType

Values:

enumerator EXE_CPU

enumerator EXE_GPU_GFX

enumerator EXE_GPU_DMA

Functions

bool IsGpuType(MemType m)

bool IsCpuType(MemType m)

bool IsGpuType(ExeType e)

bool IsCpuType(ExeType e)

inline MemType CharToMemType(char const c)

inline ExeType CharToExeType(char const c)

void DisplayUsage(char const *cmdName)

void DisplayTopology(bool const outputToCsv)

void PopulateTestSizes(size_t const numBytesPerTransfer, int const samplingFactor, std::vector<size_t> &valuesofN)

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)

void ParseTransfers(EnvVars const &ev, char *line, std::vector<Transfer> &transfers)

void ExecuteTransfers(EnvVars const &ev, int const testNum, size_t const N, std::vector<Transfer> &transfers, bool verbose = true, double *totalBandwidthCpu = nullptr)

TestResults ExecuteTransfersImpl(EnvVars const &ev, std::vector<Transfer> &transfers)

void ReportResults(EnvVars const &ev, std::vector<Transfer> const &transfers, TestResults const results)

void EnablePeerAccess(int const deviceId, int const peerDeviceId)

void AllocateMemory(MemType memType, int devIndex, size_t numBytes, void **memPtr)

void DeallocateMemory(MemType memType, void *memPtr, size_t const size = 0)

void CheckPages(char *byteArray, size_t numBytes, int targetId)

void RunTransfer(EnvVars const &ev, int const iteration, ExecutorInfo &exeInfo, int const transferIdx)

void RunPeerToPeerBenchmarks(EnvVars const &ev, size_t N)

void RunScalingBenchmark(EnvVars const &ev, size_t N, int const exeIndex, int const maxSubExecs)

void RunSweepPreset(EnvVars const &ev, size_t const numBytesPerTransfer, int const numGpuSubExec, int const numCpuSubExec, bool const isRandom)

void RunAllToAllBenchmark(EnvVars const &ev, size_t const numBytesPerTransfer, int const numSubExecs)

void RunSchmooBenchmark(EnvVars const &ev, size_t const numBytesPerTransfer, int const localIdx, int const remoteIdx, int const maxSubExecs)

void RunRemoteWriteBenchmark(EnvVars const &ev, size_t const numBytesPerTransfer, int numSubExecs, int const srcIdx, int minGpus, int maxGpus)

void RunParallelCopyBenchmark(EnvVars const &ev, size_t const numBytesPerTransfer, int numSubExecs, int const srcIdx, int minGpus, int maxGpus)

void RunHealthCheck(EnvVars ev)

std::string GetLinkTypeDesc(uint32_t linkType, uint32_t hopCount)

int RemappedIndex(int const origIdx, bool const isCpuType)

void LogTransfers(FILE *fp, int const testNum, std::vector<Transfer> const &transfers)

std::string PtrVectorToStr(std::vector<float*> const &strVector, int const initOffset)

Variables

size_t const DEFAULT_BYTES_PER_TRANSFER = (1 << 26)

char const MemTypeStr[8] = "CGBFUNM"

char const ExeTypeStr[4] = "CGD"

char const ExeTypeName[3][4] = {"CPU", "GPU", "DMA"}

file TransferBench.cpp

#include <numa.h>

#include <cmath>

#include <numaif.h>

#include <random>

#include <stack>

#include <thread>

#include “TransferBench.hpp”

#include “GetClosestNumaNode.hpp”

Functions

int main(int argc, char **argv)

void ExecuteTransfers(EnvVars const &ev, int const testNum, size_t const N, std::vector<Transfer> &transfers, bool verbose, double *totalBandwidthCpu)

TestResults ExecuteTransfersImpl(EnvVars const &ev, std::vector<Transfer> &transfers)

void DisplayUsage(char const *cmdName)

int RemappedIndex(int const origIdx, bool const isCpuType)

void DisplayTopology(bool const outputToCsv)

void ParseMemType(EnvVars const &ev, std::string const &token, std::vector<MemType> &memTypes, std::vector<int> &memIndices)

void ParseExeType(EnvVars const &ev, std::string const &token, ExeType &exeType, int &exeIndex, int &exeSubIndex)

void ParseTransfers(EnvVars const &ev, char *line, std::vector<Transfer> &transfers)

void EnablePeerAccess(int const deviceId, int const peerDeviceId)

void AllocateMemory(MemType memType, int devIndex, size_t numBytes, void **memPtr)

void DeallocateMemory(MemType memType, void *memPtr, size_t const bytes)

void CheckPages(char *array, size_t numBytes, int targetId)

uint32_t GetId(uint32_t hwId)

void RunTransfer(EnvVars const &ev, int const iteration, ExecutorInfo &exeInfo, int const transferIdx)

void RunPeerToPeerBenchmarks(EnvVars const &ev, size_t N)

void RunScalingBenchmark(EnvVars const &ev, size_t N, int const exeIndex, int const maxSubExecs)

void RunAllToAllBenchmark(EnvVars const &ev, size_t const numBytesPerTransfer, int const numSubExecs)

void RunSchmooBenchmark(EnvVars const &ev, size_t const numBytesPerTransfer, int const localIdx, int const remoteIdx, int const maxSubExecs)

void RunRemoteWriteBenchmark(EnvVars const &ev, size_t const numBytesPerTransfer, int numSubExecs, int const srcIdx, int minGpus, int maxGpus)

void RunParallelCopyBenchmark(EnvVars const &ev, size_t const numBytesPerTransfer, int numSubExecs, int const srcIdx, int minGpus, int maxGpus)

void RunSweepPreset(EnvVars const &ev, size_t const numBytesPerTransfer, int const numGpuSubExecs, int const numCpuSubExecs, bool const isRandom)

void LogTransfers(FILE *fp, int const testNum, std::vector<Transfer> const &transfers)

std::string PtrVectorToStr(std::vector<float*> const &strVector, int const initOffset)

void ReportResults(EnvVars const &ev, std::vector<Transfer> const &transfers, TestResults const results)

void RunHealthCheck(EnvVars ev)

dir /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-transferbench/checkouts/latest/src/include

dir /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-transferbench/checkouts/latest/src