NASP/cuda-samples
85
0
Fork 0
mirror of https://github.com/NVIDIA/cuda-samples.git synced 2026-10-25 22:28:17 +08:00
Code Issues Packages Projects Releases Wiki Activity

Apply consistent code formatting across the repo. Add clang-format and pre-commit hooks.

Browse Source
This commit is contained in:
Rob Armstrong
2025-03-27 10:30:07 -07:00
parent 2cd58fbc9a
commit ceab6e8bcc
782 changed files with 107230 additions and 106548 deletions
Download Patch File Download Diff File Expand all files Collapse all files

355
Samples/2_Concepts_and_Techniques/streamOrderedAllocationP2P/streamOrderedAllocationP2P.cu
View File

@@ -33,10 +33,10 @@
// System includes
#include <assert.h>
#include <stdio.h>
#include <iostream>
#include <map>
#include <set>
#include <stdio.h>
#include <utility>
// CUDA runtime
@@ -48,205 +48,198 @@
// Simple kernel to demonstrate copying cudaMallocAsync memory via P2P to peer
// device
__global__ void copyP2PAndScale(const int *src, int *dst, int N) {
int idx = blockIdx.x * blockDim.x + threadIdx.x;
__global__ void copyP2PAndScale(const int *src, int *dst, int N)
{
int idx = blockIdx.x * blockDim.x + threadIdx.x;
if (idx < N) {
// scale & store src vector.
dst[idx] = 2 * src[idx];
}
if (idx < N) {
// scale & store src vector.
dst[idx] = 2 * src[idx];
}
}
// Map of device version to device number
std::multimap<std::pair<int, int>, int> getIdenticalGPUs() {
int numGpus = 0;
checkCudaErrors(cudaGetDeviceCount(&numGpus));
std::multimap<std::pair<int, int>, int> getIdenticalGPUs()
{
int numGpus = 0;
checkCudaErrors(cudaGetDeviceCount(&numGpus));
std::multimap<std::pair<int, int>, int> identicalGpus;
std::multimap<std::pair<int, int>, int> identicalGpus;
for (int i = 0; i < numGpus; i++) {
int isMemPoolSupported = 0;
checkCudaErrors(cudaDeviceGetAttribute(&isMemPoolSupported,
cudaDevAttrMemoryPoolsSupported, i));
for (int i = 0; i < numGpus; i++) {
int isMemPoolSupported = 0;
checkCudaErrors(cudaDeviceGetAttribute(&isMemPoolSupported, cudaDevAttrMemoryPoolsSupported, i));
// Filter unsupported devices
if (isMemPoolSupported) {
int major = 0, minor = 0;
checkCudaErrors(
cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, i));
checkCudaErrors(
cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, i));
identicalGpus.emplace(std::make_pair(major, minor), i);
}
}
return identicalGpus;
}
std::pair<int, int> getP2PCapableGpuPair() {
constexpr size_t kNumGpusRequired = 2;
auto gpusByArch = getIdenticalGPUs();
auto it = gpusByArch.begin();
auto end = gpusByArch.end();
auto bestFit = std::make_pair(it, it);
// use std::distance to find the largest number of GPUs amongst architectures
auto distance = [](decltype(bestFit) p) {
return std::distance(p.first, p.second);
};
// Read each unique key/pair element in order
for (; it != end; it = gpusByArch.upper_bound(it->first)) {
// first and second are iterators bounded within the architecture group
auto testFit = gpusByArch.equal_range(it->first);
// Always use devices with highest architecture version or whichever has the
// most devices available
if (distance(bestFit) <= distance(testFit)) bestFit = testFit;
}
if (distance(bestFit) < kNumGpusRequired) {
printf(
"No Two or more GPUs with same architecture capable of cuda Memory "
"Pools found."
"\nWaiving the sample\n");
exit(EXIT_WAIVED);
}
std::set<int> bestFitDeviceIds;
// check & select peer-to-peer access capable GPU devices.
int devIds[2];
for (auto itr = bestFit.first; itr != bestFit.second; itr++) {
int deviceId = itr->second;
checkCudaErrors(cudaSetDevice(deviceId));
std::for_each(itr, bestFit.second, [&deviceId, &bestFitDeviceIds,
&kNumGpusRequired](
decltype(*itr) mapPair) {
if (deviceId != mapPair.second) {
int access = 0;
checkCudaErrors(
cudaDeviceCanAccessPeer(&access, deviceId, mapPair.second));
printf("Device=%d %s Access Peer Device=%d\n", deviceId,
access ? "CAN" : "CANNOT", mapPair.second);
if (access && bestFitDeviceIds.size() < kNumGpusRequired) {
bestFitDeviceIds.emplace(deviceId);
bestFitDeviceIds.emplace(mapPair.second);
} else {
printf("Ignoring device %i (max devices exceeded)\n", mapPair.second);
// Filter unsupported devices
if (isMemPoolSupported) {
int major = 0, minor = 0;
checkCudaErrors(cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, i));
checkCudaErrors(cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, i));
identicalGpus.emplace(std::make_pair(major, minor), i);
}
}
});
if (bestFitDeviceIds.size() >= kNumGpusRequired) {
printf("Selected p2p capable devices - ");
int i = 0;
for (auto devicesItr = bestFitDeviceIds.begin();
devicesItr != bestFitDeviceIds.end(); devicesItr++) {
devIds[i++] = *devicesItr;
printf("deviceId = %d ", *devicesItr);
}
printf("\n");
break;
}
}
// if bestFitDeviceIds.size() == 0 it means the GPUs in system are not p2p
// capable, hence we add it without p2p capability check.
if (!bestFitDeviceIds.size()) {
printf("No Two or more Devices p2p capable found.. exiting..\n");
exit(EXIT_WAIVED);
}
auto p2pGpuPair = std::make_pair(devIds[0], devIds[1]);
return p2pGpuPair;
return identicalGpus;
}
int memPoolP2PCopy() {
int *dev0_srcVec, *dev1_dstVec; // Device buffers
cudaStream_t stream1, stream2;
cudaMemPool_t memPool;
cudaEvent_t waitOnStream1;
std::pair<int, int> getP2PCapableGpuPair()
{
constexpr size_t kNumGpusRequired = 2;
// Allocate CPU memory.
size_t nelem = 1048576;
size_t bytes = nelem * sizeof(int);
auto gpusByArch = getIdenticalGPUs();
int *a = (int *)malloc(bytes);
int *output = (int *)malloc(bytes);
auto it = gpusByArch.begin();
auto end = gpusByArch.end();
/* Initialize the vectors. */
for (int n = 0; n < nelem; n++) {
a[n] = rand() / (int)RAND_MAX;
}
auto bestFit = std::make_pair(it, it);
// use std::distance to find the largest number of GPUs amongst architectures
auto distance = [](decltype(bestFit) p) { return std::distance(p.first, p.second); };
auto p2pDevices = getP2PCapableGpuPair();
printf("selected devices = %d & %d\n", p2pDevices.first, p2pDevices.second);
checkCudaErrors(cudaSetDevice(p2pDevices.first));
checkCudaErrors(cudaEventCreate(&waitOnStream1));
checkCudaErrors(cudaStreamCreateWithFlags(&stream1, cudaStreamNonBlocking));
// Get the default mempool for device p2pDevices.first from the pair
checkCudaErrors(cudaDeviceGetDefaultMemPool(&memPool, p2pDevices.first));
// Allocate memory in a stream from the pool set above.
checkCudaErrors(cudaMallocAsync(&dev0_srcVec, bytes, stream1));
checkCudaErrors(
cudaMemcpyAsync(dev0_srcVec, a, bytes, cudaMemcpyHostToDevice, stream1));
checkCudaErrors(cudaEventRecord(waitOnStream1, stream1));
checkCudaErrors(cudaSetDevice(p2pDevices.second));
checkCudaErrors(cudaStreamCreateWithFlags(&stream2, cudaStreamNonBlocking));
// Allocate memory in p2pDevices.second device
checkCudaErrors(cudaMallocAsync(&dev1_dstVec, bytes, stream2));
// Setup peer mappings for p2pDevices.second device
cudaMemAccessDesc desc;
memset(&desc, 0, sizeof(cudaMemAccessDesc));
desc.location.type = cudaMemLocationTypeDevice;
desc.location.id = p2pDevices.second;
desc.flags = cudaMemAccessFlagsProtReadWrite;
checkCudaErrors(cudaMemPoolSetAccess(memPool, &desc, 1));
printf("> copyP2PAndScale kernel running ...\n");
dim3 block(256);
dim3 grid((unsigned int)ceil(nelem / (int)block.x));
checkCudaErrors(cudaStreamWaitEvent(stream2, waitOnStream1));
copyP2PAndScale<<<grid, block, 0, stream2>>>(dev0_srcVec, dev1_dstVec, nelem);
checkCudaErrors(cudaMemcpyAsync(output, dev1_dstVec, bytes,
cudaMemcpyDeviceToHost, stream2));
checkCudaErrors(cudaFreeAsync(dev0_srcVec, stream2));
checkCudaErrors(cudaFreeAsync(dev1_dstVec, stream2));
checkCudaErrors(cudaStreamSynchronize(stream2));
/* Compare the results */
printf("> Checking the results from copyP2PAndScale() ...\n");
for (int n = 0; n < nelem; n++) {
if ((2 * a[n]) != output[n]) {
printf("mismatch i = %d expected = %d val = %d\n", n, 2 * a[n],
output[n]);
return EXIT_FAILURE;
// Read each unique key/pair element in order
for (; it != end; it = gpusByArch.upper_bound(it->first)) {
// first and second are iterators bounded within the architecture group
auto testFit = gpusByArch.equal_range(it->first);
// Always use devices with highest architecture version or whichever has the
// most devices available
if (distance(bestFit) <= distance(testFit))
bestFit = testFit;
}
}
free(a);
free(output);
checkCudaErrors(cudaStreamDestroy(stream1));
checkCudaErrors(cudaStreamDestroy(stream2));
printf("PASSED\n");
if (distance(bestFit) < kNumGpusRequired) {
printf("No Two or more GPUs with same architecture capable of cuda Memory "
"Pools found."
"\nWaiving the sample\n");
exit(EXIT_WAIVED);
}
return EXIT_SUCCESS;
std::set<int> bestFitDeviceIds;
// check & select peer-to-peer access capable GPU devices.
int devIds[2];
for (auto itr = bestFit.first; itr != bestFit.second; itr++) {
int deviceId = itr->second;
checkCudaErrors(cudaSetDevice(deviceId));
std::for_each(itr, bestFit.second, [&deviceId, &bestFitDeviceIds, &kNumGpusRequired](decltype(*itr) mapPair) {
if (deviceId != mapPair.second) {
int access = 0;
checkCudaErrors(cudaDeviceCanAccessPeer(&access, deviceId, mapPair.second));
printf("Device=%d %s Access Peer Device=%d\n", deviceId, access ? "CAN" : "CANNOT", mapPair.second);
if (access && bestFitDeviceIds.size() < kNumGpusRequired) {
bestFitDeviceIds.emplace(deviceId);
bestFitDeviceIds.emplace(mapPair.second);
}
else {
printf("Ignoring device %i (max devices exceeded)\n", mapPair.second);
}
}
});
if (bestFitDeviceIds.size() >= kNumGpusRequired) {
printf("Selected p2p capable devices - ");
int i = 0;
for (auto devicesItr = bestFitDeviceIds.begin(); devicesItr != bestFitDeviceIds.end(); devicesItr++) {
devIds[i++] = *devicesItr;
printf("deviceId = %d ", *devicesItr);
}
printf("\n");
break;
}
}
// if bestFitDeviceIds.size() == 0 it means the GPUs in system are not p2p
// capable, hence we add it without p2p capability check.
if (!bestFitDeviceIds.size()) {
printf("No Two or more Devices p2p capable found.. exiting..\n");
exit(EXIT_WAIVED);
}
auto p2pGpuPair = std::make_pair(devIds[0], devIds[1]);
return p2pGpuPair;
}
int main(int argc, char **argv) {
int ret = memPoolP2PCopy();
return ret;
int memPoolP2PCopy()
{
int *dev0_srcVec, *dev1_dstVec; // Device buffers
cudaStream_t stream1, stream2;
cudaMemPool_t memPool;
cudaEvent_t waitOnStream1;
// Allocate CPU memory.
size_t nelem = 1048576;
size_t bytes = nelem * sizeof(int);
int *a = (int *)malloc(bytes);
int *output = (int *)malloc(bytes);
/* Initialize the vectors. */
for (int n = 0; n < nelem; n++) {
a[n] = rand() / (int)RAND_MAX;
}
auto p2pDevices = getP2PCapableGpuPair();
printf("selected devices = %d & %d\n", p2pDevices.first, p2pDevices.second);
checkCudaErrors(cudaSetDevice(p2pDevices.first));
checkCudaErrors(cudaEventCreate(&waitOnStream1));
checkCudaErrors(cudaStreamCreateWithFlags(&stream1, cudaStreamNonBlocking));
// Get the default mempool for device p2pDevices.first from the pair
checkCudaErrors(cudaDeviceGetDefaultMemPool(&memPool, p2pDevices.first));
// Allocate memory in a stream from the pool set above.
checkCudaErrors(cudaMallocAsync(&dev0_srcVec, bytes, stream1));
checkCudaErrors(cudaMemcpyAsync(dev0_srcVec, a, bytes, cudaMemcpyHostToDevice, stream1));
checkCudaErrors(cudaEventRecord(waitOnStream1, stream1));
checkCudaErrors(cudaSetDevice(p2pDevices.second));
checkCudaErrors(cudaStreamCreateWithFlags(&stream2, cudaStreamNonBlocking));
// Allocate memory in p2pDevices.second device
checkCudaErrors(cudaMallocAsync(&dev1_dstVec, bytes, stream2));
// Setup peer mappings for p2pDevices.second device
cudaMemAccessDesc desc;
memset(&desc, 0, sizeof(cudaMemAccessDesc));
desc.location.type = cudaMemLocationTypeDevice;
desc.location.id = p2pDevices.second;
desc.flags = cudaMemAccessFlagsProtReadWrite;
checkCudaErrors(cudaMemPoolSetAccess(memPool, &desc, 1));
printf("> copyP2PAndScale kernel running ...\n");
dim3 block(256);
dim3 grid((unsigned int)ceil(nelem / (int)block.x));
checkCudaErrors(cudaStreamWaitEvent(stream2, waitOnStream1));
copyP2PAndScale<<<grid, block, 0, stream2>>>(dev0_srcVec, dev1_dstVec, nelem);
checkCudaErrors(cudaMemcpyAsync(output, dev1_dstVec, bytes, cudaMemcpyDeviceToHost, stream2));
checkCudaErrors(cudaFreeAsync(dev0_srcVec, stream2));
checkCudaErrors(cudaFreeAsync(dev1_dstVec, stream2));
checkCudaErrors(cudaStreamSynchronize(stream2));
/* Compare the results */
printf("> Checking the results from copyP2PAndScale() ...\n");
for (int n = 0; n < nelem; n++) {
if ((2 * a[n]) != output[n]) {
printf("mismatch i = %d expected = %d val = %d\n", n, 2 * a[n], output[n]);
return EXIT_FAILURE;
}
}
free(a);
free(output);
checkCudaErrors(cudaStreamDestroy(stream1));
checkCudaErrors(cudaStreamDestroy(stream2));
printf("PASSED\n");
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
int ret = memPoolP2PCopy();
return ret;
}