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

10
Samples/5_Domain_Specific/FDTD3d/inc/FDTD3d.h
View File

@@ -34,21 +34,21 @@
// primary display in this case.
#define k_dim_min 96
#define k_dim_max 376
#define k_dim_qa 248
#define k_dim_qa 248
// Note that the radius is defined here as exactly 4 since the
// kernel code uses a constant. If you want a different radius
// you must change the kernel accordingly.
#define k_radius_min 4
#define k_radius_max 4
#define k_radius_min 4
#define k_radius_max 4
#define k_radius_default 4
// The values are set to give reasonable runtimes, they can
// be changed but note that running a very large number of
// timesteps can take a very long time and you should avoid
// running on your primary display in this case.
#define k_timesteps_min 1
#define k_timesteps_max 10
#define k_timesteps_min 1
#define k_timesteps_max 10
#define k_timesteps_default 5
#endif

21
Samples/5_Domain_Specific/FDTD3d/inc/FDTD3dGPU.h
View File

@@ -29,23 +29,28 @@
#define _FDTD3DGPU_H_
#include <cstddef>
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || \
defined(_WIN64) && defined(_MSC_VER)
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) && defined(_MSC_VER)
typedef unsigned __int64 memsize_t;
#else
#include <stdint.h>
typedef uint64_t memsize_t;
#endif
#define k_blockDimX 32
#define k_blockDimX 32
#define k_blockDimMaxY 16
#define k_blockSizeMin 128
#define k_blockSizeMax (k_blockDimX * k_blockDimMaxY)
bool getTargetDeviceGlobalMemSize(memsize_t *result, const int argc,
const char **argv);
bool fdtdGPU(float *output, const float *input, const float *coeff,
const int dimx, const int dimy, const int dimz, const int radius,
const int timesteps, const int argc, const char **argv);
bool getTargetDeviceGlobalMemSize(memsize_t *result, const int argc, const char **argv);
bool fdtdGPU(float *output,
const float *input,
const float *coeff,
const int dimx,
const int dimy,
const int dimz,
const int radius,
const int timesteps,
const int argc,
const char **argv);
#endif

176
Samples/5_Domain_Specific/FDTD3d/inc/FDTD3dGPUKernel.cuh
View File

@@ -25,9 +25,10 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "FDTD3dGPU.h"
#include <cooperative_groups.h>
#include "FDTD3dGPU.h"
namespace cg = cooperative_groups;
// Note: If you change the RADIUS, you should also change the unrolling below
@@ -35,116 +36,125 @@ namespace cg = cooperative_groups;
__constant__ float stencil[RADIUS + 1];
__global__ void FiniteDifferencesKernel(float *output, const float *input,
const int dimx, const int dimy,
const int dimz) {
bool validr = true;
bool validw = true;
const int gtidx = blockIdx.x * blockDim.x + threadIdx.x;
const int gtidy = blockIdx.y * blockDim.y + threadIdx.y;
const int ltidx = threadIdx.x;
const int ltidy = threadIdx.y;
const int workx = blockDim.x;
const int worky = blockDim.y;
// Handle to thread block group
cg::thread_block cta = cg::this_thread_block();
__shared__ float tile[k_blockDimMaxY + 2 * RADIUS][k_blockDimX + 2 * RADIUS];
__global__ void
FiniteDifferencesKernel(float *output, const float *input, const int dimx, const int dimy, const int dimz)
{
bool validr = true;
bool validw = true;
const int gtidx = blockIdx.x * blockDim.x + threadIdx.x;
const int gtidy = blockIdx.y * blockDim.y + threadIdx.y;
const int ltidx = threadIdx.x;
const int ltidy = threadIdx.y;
const int workx = blockDim.x;
const int worky = blockDim.y;
// Handle to thread block group
cg::thread_block cta = cg::this_thread_block();
__shared__ float tile[k_blockDimMaxY + 2 * RADIUS][k_blockDimX + 2 * RADIUS];
const int stride_y = dimx + 2 * RADIUS;
const int stride_z = stride_y * (dimy + 2 * RADIUS);
const int stride_y = dimx + 2 * RADIUS;
const int stride_z = stride_y * (dimy + 2 * RADIUS);
int inputIndex = 0;
int outputIndex = 0;
int inputIndex = 0;
int outputIndex = 0;
// Advance inputIndex to start of inner volume
inputIndex += RADIUS * stride_y + RADIUS;
// Advance inputIndex to start of inner volume
inputIndex += RADIUS * stride_y + RADIUS;
// Advance inputIndex to target element
inputIndex += gtidy * stride_y + gtidx;
// Advance inputIndex to target element
inputIndex += gtidy * stride_y + gtidx;
float infront[RADIUS];
float behind[RADIUS];
float current;
float infront[RADIUS];
float behind[RADIUS];
float current;
const int tx = ltidx + RADIUS;
const int ty = ltidy + RADIUS;
const int tx = ltidx + RADIUS;
const int ty = ltidy + RADIUS;
// Check in bounds
if ((gtidx >= dimx + RADIUS) || (gtidy >= dimy + RADIUS)) validr = false;
// Check in bounds
if ((gtidx >= dimx + RADIUS) || (gtidy >= dimy + RADIUS))
validr = false;
if ((gtidx >= dimx) || (gtidy >= dimy)) validw = false;
if ((gtidx >= dimx) || (gtidy >= dimy))
validw = false;
// Preload the "infront" and "behind" data
for (int i = RADIUS - 2; i >= 0; i--) {
if (validr) behind[i] = input[inputIndex];
// Preload the "infront" and "behind" data
for (int i = RADIUS - 2; i >= 0; i--) {
if (validr)
behind[i] = input[inputIndex];
inputIndex += stride_z;
}
if (validr)
current = input[inputIndex];
outputIndex = inputIndex;
inputIndex += stride_z;
}
if (validr) current = input[inputIndex];
for (int i = 0; i < RADIUS; i++) {
if (validr)
infront[i] = input[inputIndex];
outputIndex = inputIndex;
inputIndex += stride_z;
for (int i = 0; i < RADIUS; i++) {
if (validr) infront[i] = input[inputIndex];
inputIndex += stride_z;
}
inputIndex += stride_z;
}
// Step through the xy-planes
#pragma unroll 9
for (int iz = 0; iz < dimz; iz++) {
// Advance the slice (move the thread-front)
for (int i = RADIUS - 1; i > 0; i--) behind[i] = behind[i - 1];
for (int iz = 0; iz < dimz; iz++) {
// Advance the slice (move the thread-front)
for (int i = RADIUS - 1; i > 0; i--)
behind[i] = behind[i - 1];
behind[0] = current;
current = infront[0];
behind[0] = current;
current = infront[0];
#pragma unroll 4
for (int i = 0; i < RADIUS - 1; i++) infront[i] = infront[i + 1];
for (int i = 0; i < RADIUS - 1; i++)
infront[i] = infront[i + 1];
if (validr) infront[RADIUS - 1] = input[inputIndex];
if (validr)
infront[RADIUS - 1] = input[inputIndex];
inputIndex += stride_z;
outputIndex += stride_z;
cg::sync(cta);
inputIndex += stride_z;
outputIndex += stride_z;
cg::sync(cta);
// Note that for the work items on the boundary of the problem, the
// supplied index when reading the halo (below) may wrap to the
// previous/next row or even the previous/next xy-plane. This is
// acceptable since a) we disable the output write for these work
// items and b) there is at least one xy-plane before/after the
// current plane, so the access will be within bounds.
// Note that for the work items on the boundary of the problem, the
// supplied index when reading the halo (below) may wrap to the
// previous/next row or even the previous/next xy-plane. This is
// acceptable since a) we disable the output write for these work
// items and b) there is at least one xy-plane before/after the
// current plane, so the access will be within bounds.
// Update the data slice in the local tile
// Halo above & below
if (ltidy < RADIUS) {
tile[ltidy][tx] = input[outputIndex - RADIUS * stride_y];
tile[ltidy + worky + RADIUS][tx] = input[outputIndex + worky * stride_y];
}
// Update the data slice in the local tile
// Halo above & below
if (ltidy < RADIUS) {
tile[ltidy][tx] = input[outputIndex - RADIUS * stride_y];
tile[ltidy + worky + RADIUS][tx] = input[outputIndex + worky * stride_y];
}
// Halo left & right
if (ltidx < RADIUS) {
tile[ty][ltidx] = input[outputIndex - RADIUS];
tile[ty][ltidx + workx + RADIUS] = input[outputIndex + workx];
}
// Halo left & right
if (ltidx < RADIUS) {
tile[ty][ltidx] = input[outputIndex - RADIUS];
tile[ty][ltidx + workx + RADIUS] = input[outputIndex + workx];
}
tile[ty][tx] = current;
cg::sync(cta);
tile[ty][tx] = current;
cg::sync(cta);
// Compute the output value
float value = stencil[0] * current;
// Compute the output value
float value = stencil[0] * current;
#pragma unroll 4
for (int i = 1; i <= RADIUS; i++) {
value +=
stencil[i] * (infront[i - 1] + behind[i - 1] + tile[ty - i][tx] +
tile[ty + i][tx] + tile[ty][tx - i] + tile[ty][tx + i]);
}
for (int i = 1; i <= RADIUS; i++) {
value += stencil[i]
* (infront[i - 1] + behind[i - 1] + tile[ty - i][tx] + tile[ty + i][tx] + tile[ty][tx - i]
+ tile[ty][tx + i]);
}
// Store the output value
if (validw) output[outputIndex] = value;
}
// Store the output value
if (validw)
output[outputIndex] = value;
}
}

35
Samples/5_Domain_Specific/FDTD3d/inc/FDTD3dReference.h
View File

@@ -28,17 +28,32 @@
#ifndef _FDTD3DREFERENCE_H_
#define _FDTD3DREFERENCE_H_
void generateRandomData(float *data, const int dimx, const int dimy,
const int dimz, const float lowerBound,
void generateRandomData(float *data,
const int dimx,
const int dimy,
const int dimz,
const float lowerBound,
const float upperBound);
void generatePatternData(float *data, const int dimx, const int dimy,
const int dimz, const float lowerBound,
void generatePatternData(float *data,
const int dimx,
const int dimy,
const int dimz,
const float lowerBound,
const float upperBound);
bool fdtdReference(float *output, const float *input, const float *coeff,
const int dimx, const int dimy, const int dimz,
const int radius, const int timesteps);
bool compareData(const float *output, const float *reference, const int dimx,
const int dimy, const int dimz, const int radius,
const float tolerance = 0.0001f);
bool fdtdReference(float *output,
const float *input,
const float *coeff,
const int dimx,
const int dimy,
const int dimz,
const int radius,
const int timesteps);
bool compareData(const float *output,
const float *reference,
const int dimx,
const int dimy,
const int dimz,
const int radius,
const float tolerance = 0.0001f);
#endif