NASP/cuda-samples
84
0
Fork 0
mirror of https://github.com/NVIDIA/cuda-samples.git synced 2026-10-13 00:08:26 +08:00
Code Issues Packages Projects Releases Wiki Activity

CUDA 13.2 samples update (#432)

Browse Source 
- Added Python samples for CUDA Python 1.0 release
- Renamed top-level `Samples` directory to `cpp` to accommodate Python samples.
This commit is contained in:
Dheemanth
2026-05-13 15:13:18 -07:00
committed by GitHub
parent a4526d5229
commit aeab82ff30
2072 changed files with 15077 additions and 1970 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
cpp/4_CUDA_Libraries/randomFog/.vscode/c_cpp_properties.json vendored Normal file
View File

@@ -0,0 +1,18 @@
{
"configurations": [
{
"name": "Linux",
"includePath": [
"${workspaceFolder}/**",
"${workspaceFolder}/../../../Common"
],
"defines": [],
"compilerPath": "/usr/local/cuda/bin/nvcc",
"cStandard": "gnu17",
"cppStandard": "gnu++14",
"intelliSenseMode": "linux-gcc-x64",
"configurationProvider": "ms-vscode.makefile-tools"
}
],
"version": 4
}

7
cpp/4_CUDA_Libraries/randomFog/.vscode/extensions.json vendored Normal file
View File

@@ -0,0 +1,7 @@
{
"recommendations": [
"nvidia.nsight-vscode-edition",
"ms-vscode.cpptools",
"ms-vscode.makefile-tools"
]
}

117
cpp/4_CUDA_Libraries/randomFog/CMakeLists.txt Normal file
View File

@@ -0,0 +1,117 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/Modules")
project(randomFog LANGUAGES CXX)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
set(CMAKE_CUDA_ARCHITECTURES 75 80 86 87 89 90 100 110 120)
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Wno-deprecated-gpu-targets")
if(ENABLE_CUDA_DEBUG)
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (may significantly affect performance on some targets)
else()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -lineinfo") # add line information to all builds for debug tools (exclusive to -G option)
endif()
# Include directories and libraries
include_directories(../../../Common)
# Check for Debian13 or later
if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
file(READ "/etc/os-release" OS_RELEASE_CONTENTS)
if(OS_RELEASE_CONTENTS MATCHES "ID=[^ ]*debian[^ ]*" AND
OS_RELEASE_CONTENTS MATCHES "VERSION_ID=\"(1[3-9]|[2-9][0-9])\"")
message(STATUS "Debian 13 or later detected")
set(DEBIAN TRUE)
endif()
endif()
if(WIN32)
set(PC_GLUT_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/../../../Common")
set(PC_GLUT_LIBRARY_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/../../../Common/lib/x64")
# The GLEW library built on Windows on Arm system is named as glew32.lib/glew32.dll by default.
if(EXISTS "${PC_GLUT_LIBRARY_DIRS}/glew32.lib")
set(GLEW_LIB_NAME "glew32")
else()
set(GLEW_LIB_NAME "glew64")
endif()
endif()
find_package(OpenGL)
find_package(GLUT)
# Source file
if(${OpenGL_FOUND})
if (${GLUT_FOUND})
# Add target for randomFog
add_executable(randomFog randomFog.cpp rng.cpp)
target_compile_options(randomFog PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(randomFog PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(randomFog PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(randomFog PUBLIC
${OPENGL_INCLUDE_DIR}
${CUDAToolkit_INCLUDE_DIRS}
${GLUT_INCLUDE_DIRS}
)
target_link_libraries(randomFog
${OPENGL_LIBRARIES}
${GLUT_LIBRARIES}
CUDA::curand
CUDA::cudart
)
# Need to add X11 and other libraries for Debian13 or later explicitly
if(DEBIAN)
target_link_libraries(randomFog
X11
Xi
Xxf86vm
Xext
)
endif()
# Copy data files to the output directory
add_custom_command(TARGET randomFog POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_directory
${CMAKE_CURRENT_SOURCE_DIR}/data
${CMAKE_CURRENT_BINARY_DIR}/data
)
if(WIN32)
target_link_libraries(randomFog
${PC_GLUT_LIBRARY_DIRS}/freeglut.lib
${PC_GLUT_LIBRARY_DIRS}/${GLEW_LIB_NAME}.lib
)
add_custom_command(TARGET randomFog
POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy
${CMAKE_CURRENT_SOURCE_DIR}/../../../bin/win64/$<CONFIGURATION>/freeglut.dll
${CMAKE_CURRENT_BINARY_DIR}/$<CONFIGURATION>
)
add_custom_command(TARGET randomFog
POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy
${CMAKE_CURRENT_SOURCE_DIR}/../../../bin/win64/$<CONFIGURATION>/${GLEW_LIB_NAME}.dll
${CMAKE_CURRENT_BINARY_DIR}/$<CONFIGURATION>
)
endif()
else()
message(STATUS "GLUT not found - will not build sample 'randomFog'")
endif()
else()
message(STATUS "OpenGL not found - will not build sample 'randomFog'")
endif()
# Include installation configuration
include(${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/InstallSamples.cmake)
setup_samples_install()

36
cpp/4_CUDA_Libraries/randomFog/README.md Normal file
View File

@@ -0,0 +1,36 @@
# randomFog - Random Fog
## Description
This sample illustrates pseudo- and quasi- random numbers produced by CURAND.
## Key Concepts
3D Graphics, CURAND Library
## Supported SM Architectures
[SM 5.0 ](https://developer.nvidia.com/cuda-gpus) [SM 5.2 ](https://developer.nvidia.com/cuda-gpus) [SM 5.3 ](https://developer.nvidia.com/cuda-gpus) [SM 6.0 ](https://developer.nvidia.com/cuda-gpus) [SM 6.1 ](https://developer.nvidia.com/cuda-gpus) [SM 7.0 ](https://developer.nvidia.com/cuda-gpus) [SM 7.2 ](https://developer.nvidia.com/cuda-gpus) [SM 7.5 ](https://developer.nvidia.com/cuda-gpus) [SM 8.0 ](https://developer.nvidia.com/cuda-gpus) [SM 8.6 ](https://developer.nvidia.com/cuda-gpus) [SM 8.7 ](https://developer.nvidia.com/cuda-gpus) [SM 8.9 ](https://developer.nvidia.com/cuda-gpus) [SM 9.0 ](https://developer.nvidia.com/cuda-gpus)
## Supported OSes
Linux, Windows
## Supported CPU Architecture
x86_64, armv7l
## CUDA APIs involved
### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
cudaMalloc, cudaGetErrorString, cudaMemcpy, cudaFree
## Dependencies needed to build/run
[X11](../../../README.md#x11), [OpenGL](../../../README.md#opengl), [Freeglut](../../../README.md#freeglut), [GLEW](../../../README.md#glew), [CURAND](../../../README.md#curand)
## Prerequisites
Download and install the [CUDA Toolkit](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
Make sure the dependencies mentioned in [Dependencies]() section above are installed.
## References (for more details)

BIN
cpp/4_CUDA_Libraries/randomFog/data/ref_randomFog.bin Normal file
View File

Binary file not shown.

752
cpp/4_CUDA_Libraries/randomFog/randomFog.cpp Normal file
View File

@@ -0,0 +1,752 @@
/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of NVIDIA CORPORATION nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// OpenGL Graphics includes
#include <helper_gl.h>
#if defined(__APPLE__) || defined(MACOSX)
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
#include <GLUT/glut.h>
#else
#include <GL/freeglut.h>
#endif
// CUDA Library Headers
#include <cuda_gl_interop.h>
#include <curand.h>
// CUDA utilities and system includes
#include <helper_cuda.h>
#include <rendercheck_gl.h>
// System includes
#include <iomanip>
#include <math.h>
#include <sstream>
#include <stdexcept>
// Includes
#include "rng.h"
// standard utility and system includes
#include <helper_timer.h>
// SDK information
static const char *printfFile = "randomFog.txt";
// RNG instance
RNG *g_pRng = NULL;
// CheckRender instance (for QA)
CheckRender *g_pCheckRender = NULL;
// Simple struct which contains the position and color of a vertex
struct SVertex
{
GLfloat x, y, z;
GLfloat r, g, b;
};
// Data for the vertices
SVertex *g_pVertices = NULL;
int g_nVertices; // Size of the vertex array
int g_nVerticesPopulated; // Number currently populated
// Control the randomness
int nSkip1 = 0; // Number of samples to discard between x,y
int nSkip2 = 0; // Number of samples to discard between y,z
int nSkip3 = 0; // Number of samples to discard between z,x
// Control the display
enum Shape_t { Sphere, SphericalShell, Cube, Plane };
Shape_t g_currentShape = Sphere;
bool g_bShowAxes = true;
bool g_bTenXZoom = false;
bool g_bAutoRotate = true;
int g_lastShapeX = 1024;
int g_lastShapeY = 1024;
float g_xRotated = 0.0f;
float g_yRotated = 0.0f;
const float PI = 3.14159265359f;
void createCube(void)
{
int startVertex = 0;
for (int i = startVertex; i < g_nVerticesPopulated; i++) {
g_pVertices[i].x = (g_pRng->getNextU01() - .5f) * 2;
for (int j = 0; j < nSkip1; j++) {
g_pRng->getNextU01();
}
g_pVertices[i].y = (g_pRng->getNextU01() - .5f) * 2;
for (int j = 0; j < nSkip2; j++) {
g_pRng->getNextU01();
}
g_pVertices[i].z = (g_pRng->getNextU01() - .5f) * 2;
for (int j = 0; j < nSkip3; j++) {
g_pRng->getNextU01();
}
g_pVertices[i].r = 1.0f;
g_pVertices[i].g = 1.0f;
g_pVertices[i].b = 1.0f;
}
}
void createPlane(void)
{
int startVertex = 0;
for (int i = startVertex; i < g_nVerticesPopulated; i++) {
g_pVertices[i].x = (g_pRng->getNextU01() - .5f) * 2;
for (int j = 0; j < nSkip1; j++) {
g_pRng->getNextU01();
}
g_pVertices[i].y = (g_pRng->getNextU01() - .5f) * 2;
for (int j = 0; j < nSkip2; j++) {
g_pRng->getNextU01();
}
g_pVertices[i].z = 0.0f;
g_pVertices[i].r = 1.0f;
g_pVertices[i].g = 1.0f;
g_pVertices[i].b = 1.0f;
}
}
void createSphere(void)
{
int startVertex = 0;
for (int i = startVertex; i < g_nVerticesPopulated; i++) {
float r;
float rho;
float theta;
if (g_currentShape == Sphere) {
r = g_pRng->getNextU01();
r = powf(r, 1.f / 3.f);
for (int j = 0; j < nSkip3; j++) {
g_pRng->getNextU01();
}
}
else {
r = 1.0f;
}
rho = g_pRng->getNextU01() * PI * 2.0f;
for (int j = 0; j < nSkip1; j++) {
g_pRng->getNextU01();
}
theta = (g_pRng->getNextU01() * 2.0f) - 1.0f;
theta = asin(theta);
for (int j = 0; j < nSkip2; j++) {
g_pRng->getNextU01();
}
g_pVertices[i].x = r * fabs(cos(theta)) * cos(rho);
g_pVertices[i].y = r * fabs(cos(theta)) * sin(rho);
g_pVertices[i].z = r * sin(theta);
g_pVertices[i].r = 1.0f;
g_pVertices[i].g = 1.0f;
g_pVertices[i].b = 1.0f;
}
}
void createAxes(void)
{
// z axis:
g_pVertices[200000].x = 0.0f;
g_pVertices[200000].y = 0.0f;
g_pVertices[200000].z = -1.5f;
g_pVertices[200001].x = 0.0f;
g_pVertices[200001].y = 0.0f;
g_pVertices[200001].z = 1.5f;
g_pVertices[200000].r = 1.0f;
g_pVertices[200000].g = 0.0f;
g_pVertices[200000].b = 0.0f;
g_pVertices[200001].r = 0.0f;
g_pVertices[200001].g = 1.0f;
g_pVertices[200001].b = 1.0f;
// y axis:
g_pVertices[200002].x = 0.0f;
g_pVertices[200002].y = -1.5f;
g_pVertices[200002].z = 0.0f;
g_pVertices[200003].x = 0.0f;
g_pVertices[200003].y = 1.5f;
g_pVertices[200003].z = 0.0f;
g_pVertices[200002].r = 0.0f;
g_pVertices[200002].g = 1.0f;
g_pVertices[200002].b = 0.0f;
g_pVertices[200003].r = 1.0f;
g_pVertices[200003].g = 0.0f;
g_pVertices[200003].b = 1.0f;
// x axis:
g_pVertices[200004].x = -1.5f;
g_pVertices[200004].y = 0.0f;
g_pVertices[200004].z = 0.0f;
g_pVertices[200005].x = 1.5f;
g_pVertices[200005].y = 0.0f;
g_pVertices[200005].z = 0.0f;
g_pVertices[200004].r = 0.0f;
g_pVertices[200004].g = 0.0f;
g_pVertices[200004].b = 1.0f;
g_pVertices[200005].r = 1.0f;
g_pVertices[200005].g = 1.0f;
g_pVertices[200005].b = 0.0f;
}
void drawPoints(void)
{
if (g_bShowAxes) {
glDrawArrays(GL_LINE_STRIP, 200000, 2);
glDrawArrays(GL_LINE_STRIP, 200002, 2);
glDrawArrays(GL_LINE_STRIP, 200004, 2);
}
glDrawArrays(GL_POINTS, 0, g_nVerticesPopulated);
}
void drawText(void)
{
using std::string;
using std::stringstream;
glPushMatrix();
glLoadIdentity();
glRasterPos2f(-1.2f, 1.2f);
string infoString;
stringstream ss;
g_pRng->getInfoString(infoString);
ss << " skip1=" << nSkip1;
ss << " skip2=" << nSkip2;
ss << " skip3=" << nSkip3;
ss << " points=" << g_nVerticesPopulated;
infoString.append(ss.str());
for (unsigned int i = 0; i < infoString.size(); i++) {
glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12, infoString[i]);
}
glPopMatrix();
}
void reshape(int x, int y)
{
float xScale;
float yScale;
g_lastShapeX = x;
g_lastShapeY = y;
// Check if shape is visible
if (x == 0 || y == 0) {
return;
}
// Set a new projection matrix
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// Adjust fit
if (y > x) {
xScale = 1.0f;
yScale = (float)y / x;
}
else {
xScale = (float)x / y;
yScale = 1.0f;
}
// Angle of view:40 degrees
// Near clipping plane distance: 10.0 (default)
// Far clipping plane distance: 10.0 (default)
if (g_bTenXZoom) {
glOrtho(-.15f * xScale, .15f * xScale, -.15f * yScale, .15f * yScale, -5.0f, 5.0f);
}
else {
glOrtho(-1.5f * xScale, 1.5f * xScale, -1.5f * yScale, 1.5f * yScale, -10.0f, 10.0f);
}
// Use the whole window for rendering
glViewport(0, 0, x, y);
glMatrixMode(GL_MODELVIEW);
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -4.0f);
glRotatef(g_yRotated, 0.0f, 1.0f, 0.0f);
glRotatef(g_xRotated, 1.0f, 0.0f, 0.0f);
drawPoints();
drawText();
glFlush();
glutSwapBuffers();
}
void idle(void)
{
if (g_bAutoRotate) {
g_yRotated += 0.1f;
if (g_yRotated >= 360.0f) {
g_yRotated -= 360.0f;
}
g_xRotated += 0.05f;
if (g_xRotated >= 360.0f) {
g_xRotated -= 360.0f;
}
display();
}
}
void reCreate(void)
{
switch (g_currentShape) {
case Sphere:
case SphericalShell:
createSphere();
break;
case Cube:
createCube();
break;
default:
createPlane();
}
display();
}
void cleanup(int code)
{
if (g_pRng) {
delete g_pRng;
g_pRng = NULL;
}
if (g_pVertices) {
delete[] g_pVertices;
g_pVertices = NULL;
}
if (g_pCheckRender) {
delete g_pCheckRender;
g_pCheckRender = NULL;
}
exit(code);
}
void glutClose() { cleanup(EXIT_SUCCESS); }
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
// Select shape
case 's':
case 'S':
g_currentShape = Sphere;
createSphere();
display();
break;
case 'e':
case 'E':
g_currentShape = SphericalShell;
createSphere();
display();
break;
case 'b':
case 'B':
g_currentShape = Cube;
createCube();
display();
break;
case 'p':
case 'P':
g_currentShape = Plane;
createPlane();
display();
break;
// Rotation
case 'a':
case 'A':
g_bAutoRotate = !g_bAutoRotate;
break;
case 'i':
case 'I':
g_xRotated -= 1.0f;
if (g_xRotated <= 0.0f) {
g_xRotated += 360.0f;
}
display();
break;
case ',':
g_xRotated += 1.0f;
if (g_xRotated >= 360.0f) {
g_xRotated -= 360.0f;
}
display();
break;
case 'j':
case 'J':
g_yRotated -= 1.0f;
if (g_yRotated <= 0.0f) {
g_yRotated += 360.0f;
}
display();
break;
case 'l':
case 'L':
g_yRotated += 1.0f;
if (g_yRotated >= 360.0f) {
g_yRotated -= 360.0f;
}
display();
break;
// Zoom
case 't':
case 'T':
g_bTenXZoom = !g_bTenXZoom;
reshape(g_lastShapeX, g_lastShapeY);
reCreate();
break;
// Axes
case 'z':
case 'Z':
g_bShowAxes = !g_bShowAxes;
reCreate();
break;
// RNG
case 'x':
case 'X':
g_pRng->selectRng(RNG::Pseudo);
reCreate();
break;
case 'c':
case 'C':
g_pRng->selectRng(RNG::Quasi);
reCreate();
break;
case 'v':
case 'V':
g_pRng->selectRng(RNG::ScrambledQuasi);
reCreate();
break;
case 'r':
case 'R':
g_pRng->resetSeed();
reCreate();
break;
case ']':
g_pRng->incrementDimensions();
reCreate();
break;
case '[':
g_pRng->resetDimensions();
reCreate();
break;
case '1':
nSkip1++;
reCreate();
break;
case '2':
nSkip2++;
reCreate();
break;
case '3':
nSkip3++;
reCreate();
break;
case '!':
nSkip1 = 0;
nSkip2 = 0;
nSkip3 = 0;
reCreate();
break;
// Number of vertices
case '+':
g_nVerticesPopulated += 8000;
if (g_nVerticesPopulated > g_nVertices) {
g_nVerticesPopulated = g_nVertices;
}
reCreate();
break;
case '-':
g_nVerticesPopulated -= 8000;
if (g_nVerticesPopulated < 8000) {
g_nVerticesPopulated = 8000;
}
reCreate();
break;
// Quit
case 27:
case 'q':
case 'Q':
#if defined(__APPLE__) || defined(MACOSX)
exit(EXIT_SUCCESS);
#else
glutDestroyWindow(glutGetWindow());
return;
#endif
}
}
void showHelp(void)
{
using std::left;
using std::setw;
using std::stringstream;
stringstream ss;
ss << "\nRandom number visualization\n\n";
ss << "On creation, randomFog generates 200,000 random coordinates in "
"spherical coordinate space (radius, angle rho, angle theta) with "
"curand's XORWOW algorithm. The coordinates are normalized for a "
"uniform distribution through the sphere.\n\n";
ss << "The X axis is drawn with blue in the negative direction and yellow "
"positive.\n"
<< "The Y axis is drawn with green in the negative direction and magenta "
"positive.\n"
<< "The Z axis is drawn with red in the negative direction and cyan "
"positive.\n\n";
ss << "The following keys can be used to control the output:\n\n";
ss << left;
ss << "\t" << setw(10) << "s"
<< "Generate a new set of random numbers and display as spherical "
"coordinates (Sphere)\n";
ss << "\t" << setw(10) << "e"
<< "Generate a new set of random numbers and display on a spherical "
"surface (shEll)\n";
ss << "\t" << setw(10) << "b"
<< "Generate a new set of random numbers and display as cartesian "
"coordinates (cuBe/Box)\n";
ss << "\t" << setw(10) << "p"
<< "Generate a new set of random numbers and display on a cartesian plane "
"(Plane)\n\n";
ss << "\t" << setw(10) << "i,l,j"
<< "Rotate the negative Z-axis up, right, down and left respectively\n";
ss << "\t" << setw(10) << "a"
<< "Toggle auto-rotation\n";
ss << "\t" << setw(10) << "t"
<< "Toggle 10x zoom\n";
ss << "\t" << setw(10) << "z"
<< "Toggle axes display\n\n";
ss << "\t" << setw(10) << "x"
<< "Select XORWOW generator (default)\n";
ss << "\t" << setw(10) << "c"
<< "Select Sobol' generator\n";
ss << "\t" << setw(10) << "v"
<< "Select scrambled Sobol' generator\n";
ss << "\t" << setw(10) << "r"
<< "Reset XORWOW (i.e. reset to initial seed) and regenerate\n";
ss << "\t" << setw(10) << "]"
<< "Increment the number of Sobol' dimensions and regenerate\n";
ss << "\t" << setw(10) << "["
<< "Reset the number of Sobol' dimensions to 1 and regenerate\n\n";
ss << "\t" << setw(10) << "+"
<< "Increment the number of displayed points by 8,000 (up to maximum "
"200,000)\n";
ss << "\t" << setw(10) << "-"
<< "Decrement the number of displayed points by 8,000 (down to minimum "
"8,000)\n\n";
ss << "\t" << setw(10) << "q/[ESC]"
<< "Quit the application.\n\n";
puts(ss.str().c_str());
}
int main(int argc, char **argv)
{
using std::runtime_error;
try {
bool bQA = false;
// Open the log file
printf("Random Fog\n");
printf("==========\n\n");
// Check QA mode
if (checkCmdLineFlag(argc, (const char **)argv, "qatest")) {
bQA = true;
findCudaDevice(argc, (const char **)argv);
g_pCheckRender = new CheckBackBuffer(g_lastShapeX, g_lastShapeY, 4, false);
}
else {
#if defined(__linux__)
setenv("DISPLAY", ":0", 0);
#endif
// Initialize GL
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
// TODO use width/height?
glutInitWindowSize(1000, 1000);
// Create a window with rendering context and everything else we need
glutCreateWindow("Random Fog");
if (!isGLVersionSupported(2, 0)) {
fprintf(stderr, "This sample requires at least OpenGL 2.0\n");
exit(EXIT_WAIVED);
}
// Select CUDA device with OpenGL interoperability
findCudaDevice(argc, (const char **)argv);
}
// Create vertices
g_nVertices = 200000;
g_nVerticesPopulated = 200000;
g_pVertices = new SVertex[g_nVertices + 6];
// Setup the random number generators
g_pRng = new RNG(12345, 1, 100000);
printf("CURAND initialized\n");
// Compute the initial vertices and indices, starting in spherical mode
createSphere();
createAxes();
showHelp();
if (bQA) {
g_pCheckRender->setExecPath(argv[0]);
g_pCheckRender->dumpBin(g_pVertices, g_nVerticesPopulated * sizeof(SVertex), "randomFog.bin");
if (g_pCheckRender->compareBin2BinFloat("randomFog.bin",
"ref_randomFog.bin",
g_nVerticesPopulated * sizeof(SVertex) / sizeof(float),
0.25f,
0.35f)) {
cleanup(EXIT_SUCCESS);
}
else {
cleanup(EXIT_FAILURE);
}
}
else {
// As we do not yet use a depth buffer, we cannot fill our sphere
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
// Enable the vertex array functionality:
glEnableClientState(GL_VERTEX_ARRAY);
// Enable the color array functionality (so we can specify a color for
// each vertex)
glEnableClientState(GL_COLOR_ARRAY);
// Pass the vertex pointer:
glVertexPointer(3, // 3 components per vertex (x,y,z)
GL_FLOAT,
sizeof(SVertex),
g_pVertices);
// Pass the color pointer
glColorPointer(3, // 3 components per vertex (r,g,b)
GL_FLOAT,
sizeof(SVertex),
&g_pVertices[0].r); // Pointer to the first color
// Point size for point mode
glPointSize(1.0f);
glLineWidth(2.0f);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
// Notify glut which messages we require:
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutIdleFunc(idle);
#if defined(__APPLE__) || defined(MACOSX)
atexit(glutClose);
#else
glutCloseFunc(glutClose);
#endif
// Let's get started!
glutMainLoop();
}
}
catch (runtime_error &e) {
printf("runtime error (%s)\n", e.what());
}
exit(EXIT_SUCCESS);
}

314
cpp/4_CUDA_Libraries/randomFog/rng.cpp Normal file
View File

@@ -0,0 +1,314 @@
/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of NVIDIA CORPORATION nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// Utilities and System includes
// Includes
#include "rng.h"
#include <curand.h>
#include <sstream>
#include <stdexcept>
// Shared Library Test Functions
#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;
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_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");
}
curandStatus_t curandResult;
cudaError_t cudaResult;
// 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");
}
// 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);
}
// 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);
}
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);
}
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);
}
// Setup initial parameters
resetSeed();
updateDimensions();
setBatchSize();
// Set default RNG to be pseudo-random (XORWOW)
m_pCurrent = &m_prng;
}
RNG::~RNG()
{
curandDestroyGenerator(m_prng);
curandDestroyGenerator(m_qrng);
curandDestroyGenerator(m_sqrng);
if (m_d_samples) {
cudaFree(m_d_samples);
}
if (m_h_samples) {
free(m_h_samples);
}
}
void RNG::generateBatch(void)
{
using std::runtime_error;
using std::string;
cudaError_t cudaResult;
curandStatus_t curandResult;
// 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);
}
// 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);
}
}
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];
}
}
void RNG::getInfoString(std::string &msg)
{
using std::stringstream;
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";
}
msg.assign(ss.str());
}
void RNG::selectRng(RNG::RngType type)
{
switch (type) {
case Quasi:
m_pCurrent = &m_qrng;
break;
case ScrambledQuasi:
m_pCurrent = &m_sqrng;
break;
case Pseudo:
default:
m_pCurrent = &m_prng;
break;
}
setBatchSize();
}
void RNG::resetSeed(void)
{
using std::runtime_error;
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);
}
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);
}
setBatchSize();
}
void RNG::resetDimensions(void)
{
m_qrngDimensions = 1;
updateDimensions();
setBatchSize();
}
void RNG::incrementDimensions(void)
{
if (++m_qrngDimensions > s_maxQrngDimensions) {
m_qrngDimensions = 1;
}
updateDimensions();
setBatchSize();
}
void RNG::updateDimensions(void)
{
using std::runtime_error;
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;
}

72
cpp/4_CUDA_Libraries/randomFog/rng.h Normal file
View File

@@ -0,0 +1,72 @@
/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of NVIDIA CORPORATION nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <curand.h>
#include <string>
// RNGs
class 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);
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;
// Batches
const unsigned int m_nSamplesBatchTarget;
unsigned int m_nSamplesBatchActual;
unsigned int m_nSamplesRemaining;
void generateBatch(void);
// Helpers
void updateDimensions(void);
void setBatchSize(void);
// Buffers
float *m_h_samples;
float *m_d_samples;
static const unsigned int s_maxQrngDimensions;
};