NASP/cuda-samples
85
0
Fork 0
mirror of https://github.com/NVIDIA/cuda-samples.git synced 2026-10-26 06:38:16 +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

1
Samples/4_CUDA_Libraries/randomFog/README.md
View File

@@ -34,4 +34,3 @@ Download and install the [CUDA Toolkit 12.5](https://developer.nvidia.com/cuda-d
Make sure the dependencies mentioned in [Dependencies]() section above are installed.
## References (for more details)

1040
Samples/4_CUDA_Libraries/randomFog/randomFog.cpp
View File

File diff suppressed because it is too large Load Diff

425
Samples/4_CUDA_Libraries/randomFog/rng.cpp
View File

@@ -28,282 +28,287 @@
// Utilities and System includes
// Includes
#include <curand.h>
#include <stdexcept>
#include <sstream>
#include "rng.h"
#include <curand.h>
#include <sstream>
#include <stdexcept>
// Shared Library Test Functions
#include <helper_timer.h>
#include <helper_cuda.h>
#include <helper_timer.h>
const unsigned int RNG::s_maxQrngDimensions = 20000;
RNG::RNG(unsigned long prngSeed, unsigned int qrngDimensions,
unsigned int nSamples)
: m_prngSeed(prngSeed),
m_qrngDimensions(qrngDimensions),
m_nSamplesBatchTarget(nSamples),
m_nSamplesRemaining(0) {
using std::invalid_argument;
using std::runtime_error;
using std::string;
RNG::RNG(unsigned long prngSeed, unsigned int qrngDimensions, unsigned int nSamples)
: m_prngSeed(prngSeed)
, m_qrngDimensions(qrngDimensions)
, m_nSamplesBatchTarget(nSamples)
, m_nSamplesRemaining(0)
{
using std::invalid_argument;
using std::runtime_error;
using std::string;
if (m_prngSeed == 0) {
throw invalid_argument("PRNG seed must be non-zero");
}
if (m_prngSeed == 0) {
throw invalid_argument("PRNG seed must be non-zero");
}
if (m_qrngDimensions == 0) {
throw invalid_argument("QRNG dimensions must be non-zero");
}
if (m_qrngDimensions == 0) {
throw invalid_argument("QRNG dimensions must be non-zero");
}
if (m_nSamplesBatchTarget == 0) {
throw invalid_argument("RNG batch size must be non-zero");
}
if (m_nSamplesBatchTarget == 0) {
throw invalid_argument("RNG batch size must be non-zero");
}
if (m_nSamplesBatchTarget < s_maxQrngDimensions) {
throw invalid_argument(
"RNG batch size must be greater than RNG::s_maxQrngDimensions");
}
if (m_nSamplesBatchTarget < s_maxQrngDimensions) {
throw invalid_argument("RNG batch size must be greater than RNG::s_maxQrngDimensions");
}
curandStatus_t curandResult;
cudaError_t cudaResult;
curandStatus_t curandResult;
cudaError_t cudaResult;
// Allocate sample array in host mem
m_h_samples = (float *)malloc(m_nSamplesBatchTarget * sizeof(float));
// Allocate sample array in host mem
m_h_samples = (float *)malloc(m_nSamplesBatchTarget * sizeof(float));
if (m_h_samples == NULL) {
throw runtime_error("Could not allocate host memory for RNG::m_h_samples");
}
if (m_h_samples == NULL) {
throw runtime_error("Could not allocate host memory for RNG::m_h_samples");
}
// Allocate sample array in device mem
cudaResult =
cudaMalloc((void **)&m_d_samples, m_nSamplesBatchTarget * sizeof(float));
// Allocate sample array in device mem
cudaResult = cudaMalloc((void **)&m_d_samples, m_nSamplesBatchTarget * sizeof(float));
if (cudaResult != cudaSuccess) {
string msg("Could not allocate device memory for RNG::m_d_samples: ");
msg += cudaGetErrorString(cudaResult);
throw runtime_error(msg);
}
if (cudaResult != cudaSuccess) {
string msg("Could not allocate device memory for RNG::m_d_samples: ");
msg += cudaGetErrorString(cudaResult);
throw runtime_error(msg);
}
// Create the Random Number Generators
curandResult = curandCreateGenerator(&m_prng, CURAND_RNG_PSEUDO_XORWOW);
// Create the Random Number Generators
curandResult = curandCreateGenerator(&m_prng, CURAND_RNG_PSEUDO_XORWOW);
if (curandResult != CURAND_STATUS_SUCCESS) {
string msg("Could not create pseudo-random number generator: ");
msg += curandResult;
throw runtime_error(msg);
}
if (curandResult != CURAND_STATUS_SUCCESS) {
string msg("Could not create pseudo-random number generator: ");
msg += curandResult;
throw runtime_error(msg);
}
curandResult = curandCreateGenerator(&m_qrng, CURAND_RNG_QUASI_SOBOL32);
curandResult = curandCreateGenerator(&m_qrng, CURAND_RNG_QUASI_SOBOL32);
if (curandResult != CURAND_STATUS_SUCCESS) {
string msg("Could not create quasi-random number generator: ");
msg += curandResult;
throw runtime_error(msg);
}
if (curandResult != CURAND_STATUS_SUCCESS) {
string msg("Could not create quasi-random number generator: ");
msg += curandResult;
throw runtime_error(msg);
}
curandResult =
curandCreateGenerator(&m_sqrng, CURAND_RNG_QUASI_SCRAMBLED_SOBOL32);
curandResult = curandCreateGenerator(&m_sqrng, CURAND_RNG_QUASI_SCRAMBLED_SOBOL32);
if (curandResult != CURAND_STATUS_SUCCESS) {
string msg("Could not create scrambled quasi-random number generator: ");
msg += curandResult;
throw runtime_error(msg);
}
if (curandResult != CURAND_STATUS_SUCCESS) {
string msg("Could not create scrambled quasi-random number generator: ");
msg += curandResult;
throw runtime_error(msg);
}
// Setup initial parameters
resetSeed();
updateDimensions();
setBatchSize();
// Setup initial parameters
resetSeed();
updateDimensions();
setBatchSize();
// Set default RNG to be pseudo-random (XORWOW)
m_pCurrent = &m_prng;
// Set default RNG to be pseudo-random (XORWOW)
m_pCurrent = &m_prng;
}
RNG::~RNG() {
curandDestroyGenerator(m_prng);
curandDestroyGenerator(m_qrng);
curandDestroyGenerator(m_sqrng);
RNG::~RNG()
{
curandDestroyGenerator(m_prng);
curandDestroyGenerator(m_qrng);
curandDestroyGenerator(m_sqrng);
if (m_d_samples) {
cudaFree(m_d_samples);
}
if (m_d_samples) {
cudaFree(m_d_samples);
}
if (m_h_samples) {
free(m_h_samples);
}
if (m_h_samples) {
free(m_h_samples);
}
}
void RNG::generateBatch(void) {
using std::runtime_error;
using std::string;
void RNG::generateBatch(void)
{
using std::runtime_error;
using std::string;
cudaError_t cudaResult;
curandStatus_t curandResult;
cudaError_t cudaResult;
curandStatus_t curandResult;
// Generate random numbers
curandResult =
curandGenerateUniform(*m_pCurrent, m_d_samples, m_nSamplesBatchActual);
// Generate random numbers
curandResult = curandGenerateUniform(*m_pCurrent, m_d_samples, m_nSamplesBatchActual);
if (curandResult != CURAND_STATUS_SUCCESS) {
string msg("Could not generate random numbers: ");
msg += curandResult;
throw runtime_error(msg);
}
if (curandResult != CURAND_STATUS_SUCCESS) {
string msg("Could not generate random numbers: ");
msg += curandResult;
throw runtime_error(msg);
}
// Copy random numbers to host
cudaResult =
cudaMemcpy(m_h_samples, m_d_samples,
m_nSamplesBatchActual * sizeof(float), cudaMemcpyDeviceToHost);
// Copy random numbers to host
cudaResult = cudaMemcpy(m_h_samples, m_d_samples, m_nSamplesBatchActual * sizeof(float), cudaMemcpyDeviceToHost);
if (cudaResult != cudaSuccess) {
string msg("Could not copy random numbers to host: ");
msg += cudaGetErrorString(cudaResult);
throw runtime_error(msg);
}
if (cudaResult != cudaSuccess) {
string msg("Could not copy random numbers to host: ");
msg += cudaGetErrorString(cudaResult);
throw runtime_error(msg);
}
}
float RNG::getNextU01(void) {
if (m_nSamplesRemaining == 0) {
generateBatch();
m_nSamplesRemaining = m_nSamplesBatchActual;
}
float RNG::getNextU01(void)
{
if (m_nSamplesRemaining == 0) {
generateBatch();
m_nSamplesRemaining = m_nSamplesBatchActual;
}
if (m_pCurrent == &m_prng) {
return m_h_samples[m_nSamplesBatchActual - m_nSamplesRemaining--];
} else {
unsigned int index = m_nSamplesBatchActual - m_nSamplesRemaining--;
unsigned int samplesPerDim = m_nSamplesBatchActual / m_qrngDimensions;
unsigned int dimOffset = (index % m_qrngDimensions) * samplesPerDim;
unsigned int drawOffset = index / m_qrngDimensions;
return m_h_samples[dimOffset + drawOffset];
}
if (m_pCurrent == &m_prng) {
return m_h_samples[m_nSamplesBatchActual - m_nSamplesRemaining--];
}
else {
unsigned int index = m_nSamplesBatchActual - m_nSamplesRemaining--;
unsigned int samplesPerDim = m_nSamplesBatchActual / m_qrngDimensions;
unsigned int dimOffset = (index % m_qrngDimensions) * samplesPerDim;
unsigned int drawOffset = index / m_qrngDimensions;
return m_h_samples[dimOffset + drawOffset];
}
}
void RNG::getInfoString(std::string &msg) {
using std::stringstream;
void RNG::getInfoString(std::string &msg)
{
using std::stringstream;
stringstream ss;
stringstream ss;
if (m_pCurrent == &m_prng) {
ss << "XORWOW (seed=" << m_prngSeed << ")";
} else if (m_pCurrent == &m_qrng) {
ss << "Sobol (dimensions=" << m_qrngDimensions << ")";
} else if (m_pCurrent == &m_sqrng) {
ss << "Scrambled Sobol (dimensions=" << m_qrngDimensions << ")";
} else {
ss << "Invalid RNG";
}
if (m_pCurrent == &m_prng) {
ss << "XORWOW (seed=" << m_prngSeed << ")";
}
else if (m_pCurrent == &m_qrng) {
ss << "Sobol (dimensions=" << m_qrngDimensions << ")";
}
else if (m_pCurrent == &m_sqrng) {
ss << "Scrambled Sobol (dimensions=" << m_qrngDimensions << ")";
}
else {
ss << "Invalid RNG";
}
msg.assign(ss.str());
msg.assign(ss.str());
}
void RNG::selectRng(RNG::RngType type) {
switch (type) {
void RNG::selectRng(RNG::RngType type)
{
switch (type) {
case Quasi:
m_pCurrent = &m_qrng;
break;
m_pCurrent = &m_qrng;
break;
case ScrambledQuasi:
m_pCurrent = &m_sqrng;
break;
m_pCurrent = &m_sqrng;
break;
case Pseudo:
default:
m_pCurrent = &m_prng;
break;
}
m_pCurrent = &m_prng;
break;
}
setBatchSize();
setBatchSize();
}
void RNG::resetSeed(void) {
using std::runtime_error;
void RNG::resetSeed(void)
{
using std::runtime_error;
curandStatus_t curandResult;
curandResult = curandSetPseudoRandomGeneratorSeed(m_prng, m_prngSeed);
curandStatus_t curandResult;
curandResult = curandSetPseudoRandomGeneratorSeed(m_prng, m_prngSeed);
if (curandResult != CURAND_STATUS_SUCCESS) {
std::string msg("Could not set pseudo-random number generator seed: ");
msg += curandResult;
throw runtime_error(msg);
}
if (curandResult != CURAND_STATUS_SUCCESS) {
std::string msg("Could not set pseudo-random number generator seed: ");
msg += curandResult;
throw runtime_error(msg);
}
curandResult = curandSetGeneratorOffset(m_prng, 0);
curandResult = curandSetGeneratorOffset(m_prng, 0);
if (curandResult != CURAND_STATUS_SUCCESS) {
std::string msg("Could not set pseudo-random number generator offset: ");
msg += curandResult;
throw runtime_error(msg);
}
if (curandResult != CURAND_STATUS_SUCCESS) {
std::string msg("Could not set pseudo-random number generator offset: ");
msg += curandResult;
throw runtime_error(msg);
}
setBatchSize();
setBatchSize();
}
void RNG::resetDimensions(void) {
m_qrngDimensions = 1;
updateDimensions();
setBatchSize();
}
void RNG::incrementDimensions(void) {
if (++m_qrngDimensions > s_maxQrngDimensions) {
void RNG::resetDimensions(void)
{
m_qrngDimensions = 1;
}
updateDimensions();
setBatchSize();
updateDimensions();
setBatchSize();
}
void RNG::updateDimensions(void) {
using std::runtime_error;
void RNG::incrementDimensions(void)
{
if (++m_qrngDimensions > s_maxQrngDimensions) {
m_qrngDimensions = 1;
}
curandStatus_t curandResult;
curandResult =
curandSetQuasiRandomGeneratorDimensions(m_qrng, m_qrngDimensions);
if (curandResult != CURAND_STATUS_SUCCESS) {
std::string msg("Could not set quasi-random number generator dimensions: ");
msg += curandResult;
throw runtime_error(msg);
}
curandResult = curandSetGeneratorOffset(m_qrng, 0);
if (curandResult != CURAND_STATUS_SUCCESS) {
std::string msg("Could not set quasi-random number generator offset: ");
msg += curandResult;
throw runtime_error(msg);
}
curandResult =
curandSetQuasiRandomGeneratorDimensions(m_sqrng, m_qrngDimensions);
if (curandResult != CURAND_STATUS_SUCCESS) {
std::string msg(
"Could not set scrambled quasi-random number generator dimensions: ");
msg += curandResult;
throw runtime_error(msg);
}
curandResult = curandSetGeneratorOffset(m_sqrng, 0);
if (curandResult != CURAND_STATUS_SUCCESS) {
std::string msg(
"Could not set scrambled quasi-random number generator offset: ");
msg += curandResult;
throw runtime_error(msg);
}
updateDimensions();
setBatchSize();
}
void RNG::setBatchSize(void) {
if (m_pCurrent == &m_prng) {
m_nSamplesBatchActual = m_nSamplesBatchTarget;
} else {
m_nSamplesBatchActual =
(m_nSamplesBatchTarget / m_qrngDimensions) * m_qrngDimensions;
}
void RNG::updateDimensions(void)
{
using std::runtime_error;
m_nSamplesRemaining = 0;
curandStatus_t curandResult;
curandResult = curandSetQuasiRandomGeneratorDimensions(m_qrng, m_qrngDimensions);
if (curandResult != CURAND_STATUS_SUCCESS) {
std::string msg("Could not set quasi-random number generator dimensions: ");
msg += curandResult;
throw runtime_error(msg);
}
curandResult = curandSetGeneratorOffset(m_qrng, 0);
if (curandResult != CURAND_STATUS_SUCCESS) {
std::string msg("Could not set quasi-random number generator offset: ");
msg += curandResult;
throw runtime_error(msg);
}
curandResult = curandSetQuasiRandomGeneratorDimensions(m_sqrng, m_qrngDimensions);
if (curandResult != CURAND_STATUS_SUCCESS) {
std::string msg("Could not set scrambled quasi-random number generator dimensions: ");
msg += curandResult;
throw runtime_error(msg);
}
curandResult = curandSetGeneratorOffset(m_sqrng, 0);
if (curandResult != CURAND_STATUS_SUCCESS) {
std::string msg("Could not set scrambled quasi-random number generator offset: ");
msg += curandResult;
throw runtime_error(msg);
}
}
void RNG::setBatchSize(void)
{
if (m_pCurrent == &m_prng) {
m_nSamplesBatchActual = m_nSamplesBatchTarget;
}
else {
m_nSamplesBatchActual = (m_nSamplesBatchTarget / m_qrngDimensions) * m_qrngDimensions;
}
m_nSamplesRemaining = 0;
}

62
Samples/4_CUDA_Libraries/randomFog/rng.h
View File

@@ -31,42 +31,42 @@
// RNGs
class RNG
{
public:
enum RngType {Pseudo, Quasi, ScrambledQuasi};
RNG(unsigned long prngSeed, unsigned int qrngDimensions, unsigned int nSamples);
virtual ~RNG();
public:
enum RngType { Pseudo, Quasi, ScrambledQuasi };
RNG(unsigned long prngSeed, unsigned int qrngDimensions, unsigned int nSamples);
virtual ~RNG();
float getNextU01(void);
void getInfoString(std::string &msg);
void selectRng(RngType type);
void resetSeed(void);
void resetDimensions(void);
void incrementDimensions(void);
float getNextU01(void);
void getInfoString(std::string &msg);
void selectRng(RngType type);
void resetSeed(void);
void resetDimensions(void);
void incrementDimensions(void);
private:
// Generators
curandGenerator_t *m_pCurrent;
curandGenerator_t m_prng;
curandGenerator_t m_qrng;
curandGenerator_t m_sqrng;
private:
// Generators
curandGenerator_t *m_pCurrent;
curandGenerator_t m_prng;
curandGenerator_t m_qrng;
curandGenerator_t m_sqrng;
// Parameters
unsigned long m_prngSeed;
unsigned int m_qrngDimensions;
// Parameters
unsigned long m_prngSeed;
unsigned int m_qrngDimensions;
// Batches
const unsigned int m_nSamplesBatchTarget;
unsigned int m_nSamplesBatchActual;
unsigned int m_nSamplesRemaining;
void generateBatch(void);
// Batches
const unsigned int m_nSamplesBatchTarget;
unsigned int m_nSamplesBatchActual;
unsigned int m_nSamplesRemaining;
void generateBatch(void);
// Helpers
void updateDimensions(void);
void setBatchSize(void);
// Helpers
void updateDimensions(void);
void setBatchSize(void);
// Buffers
float *m_h_samples;
float *m_d_samples;
// Buffers
float *m_h_samples;
float *m_d_samples;
static const unsigned int s_maxQrngDimensions;
static const unsigned int s_maxQrngDimensions;
};