mirror of
https://github.com/NVIDIA/cuda-samples.git
synced 2026-10-25 22:28:17 +08:00
Apply consistent code formatting across the repo. Add clang-format and pre-commit hooks.
This commit is contained in:
Rob Armstrong
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -27,16 +27,14 @@
|
||||
|
||||
#include "FDTD3d.h"
|
||||
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
|
||||
#include "FDTD3dReference.h"
|
||||
#include "FDTD3dGPU.h"
|
||||
|
||||
#include <helper_functions.h>
|
||||
|
||||
#include <math.h>
|
||||
#include <assert.h>
|
||||
#include <helper_functions.h>
|
||||
#include <iomanip>
|
||||
#include <iostream>
|
||||
#include <math.h>
|
||||
|
||||
#include "FDTD3dGPU.h"
|
||||
#include "FDTD3dReference.h"
|
||||
|
||||
#ifndef CLAMP
|
||||
#define CLAMP(a, min, max) (MIN(max, MAX(a, min)))
|
||||
@@ -49,187 +47,186 @@
|
||||
bool runTest(int argc, const char **argv);
|
||||
void showHelp(const int argc, const char **argv);
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
bool bTestResult = false;
|
||||
// Start the log
|
||||
printf("%s Starting...\n\n", argv[0]);
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
bool bTestResult = false;
|
||||
// Start the log
|
||||
printf("%s Starting...\n\n", argv[0]);
|
||||
|
||||
// Check help flag
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "help")) {
|
||||
printf("Displaying help on console\n");
|
||||
showHelp(argc, (const char **)argv);
|
||||
bTestResult = true;
|
||||
} else {
|
||||
// Execute
|
||||
bTestResult = runTest(argc, (const char **)argv);
|
||||
}
|
||||
// Check help flag
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "help")) {
|
||||
printf("Displaying help on console\n");
|
||||
showHelp(argc, (const char **)argv);
|
||||
bTestResult = true;
|
||||
}
|
||||
else {
|
||||
// Execute
|
||||
bTestResult = runTest(argc, (const char **)argv);
|
||||
}
|
||||
|
||||
// Finish
|
||||
exit(bTestResult ? EXIT_SUCCESS : EXIT_FAILURE);
|
||||
// Finish
|
||||
exit(bTestResult ? EXIT_SUCCESS : EXIT_FAILURE);
|
||||
}
|
||||
|
||||
void showHelp(const int argc, const char **argv) {
|
||||
if (argc > 0) std::cout << std::endl << argv[0] << std::endl;
|
||||
void showHelp(const int argc, const char **argv)
|
||||
{
|
||||
if (argc > 0)
|
||||
std::cout << std::endl << argv[0] << std::endl;
|
||||
|
||||
std::cout << std::endl << "Syntax:" << std::endl;
|
||||
std::cout << std::left;
|
||||
std::cout << " " << std::setw(20) << "--device=<device>"
|
||||
<< "Specify device to use for execution" << std::endl;
|
||||
std::cout << " " << std::setw(20) << "--dimx=<N>"
|
||||
<< "Specify number of elements in x direction (excluding halo)"
|
||||
<< std::endl;
|
||||
std::cout << " " << std::setw(20) << "--dimy=<N>"
|
||||
<< "Specify number of elements in y direction (excluding halo)"
|
||||
<< std::endl;
|
||||
std::cout << " " << std::setw(20) << "--dimz=<N>"
|
||||
<< "Specify number of elements in z direction (excluding halo)"
|
||||
<< std::endl;
|
||||
std::cout << " " << std::setw(20) << "--radius=<N>"
|
||||
<< "Specify radius of stencil" << std::endl;
|
||||
std::cout << " " << std::setw(20) << "--timesteps=<N>"
|
||||
<< "Specify number of timesteps" << std::endl;
|
||||
std::cout << " " << std::setw(20) << "--block-size=<N>"
|
||||
<< "Specify number of threads per block" << std::endl;
|
||||
std::cout << std::endl;
|
||||
std::cout << " " << std::setw(20) << "--noprompt"
|
||||
<< "Skip prompt before exit" << std::endl;
|
||||
std::cout << std::endl;
|
||||
std::cout << std::endl << "Syntax:" << std::endl;
|
||||
std::cout << std::left;
|
||||
std::cout << " " << std::setw(20) << "--device=<device>"
|
||||
<< "Specify device to use for execution" << std::endl;
|
||||
std::cout << " " << std::setw(20) << "--dimx=<N>"
|
||||
<< "Specify number of elements in x direction (excluding halo)" << std::endl;
|
||||
std::cout << " " << std::setw(20) << "--dimy=<N>"
|
||||
<< "Specify number of elements in y direction (excluding halo)" << std::endl;
|
||||
std::cout << " " << std::setw(20) << "--dimz=<N>"
|
||||
<< "Specify number of elements in z direction (excluding halo)" << std::endl;
|
||||
std::cout << " " << std::setw(20) << "--radius=<N>"
|
||||
<< "Specify radius of stencil" << std::endl;
|
||||
std::cout << " " << std::setw(20) << "--timesteps=<N>"
|
||||
<< "Specify number of timesteps" << std::endl;
|
||||
std::cout << " " << std::setw(20) << "--block-size=<N>"
|
||||
<< "Specify number of threads per block" << std::endl;
|
||||
std::cout << std::endl;
|
||||
std::cout << " " << std::setw(20) << "--noprompt"
|
||||
<< "Skip prompt before exit" << std::endl;
|
||||
std::cout << std::endl;
|
||||
}
|
||||
|
||||
bool runTest(int argc, const char **argv) {
|
||||
float *host_output;
|
||||
float *device_output;
|
||||
float *input;
|
||||
float *coeff;
|
||||
bool runTest(int argc, const char **argv)
|
||||
{
|
||||
float *host_output;
|
||||
float *device_output;
|
||||
float *input;
|
||||
float *coeff;
|
||||
|
||||
int defaultDim;
|
||||
int dimx;
|
||||
int dimy;
|
||||
int dimz;
|
||||
int outerDimx;
|
||||
int outerDimy;
|
||||
int outerDimz;
|
||||
int radius;
|
||||
int timesteps;
|
||||
size_t volumeSize;
|
||||
memsize_t memsize;
|
||||
int defaultDim;
|
||||
int dimx;
|
||||
int dimy;
|
||||
int dimz;
|
||||
int outerDimx;
|
||||
int outerDimy;
|
||||
int outerDimz;
|
||||
int radius;
|
||||
int timesteps;
|
||||
size_t volumeSize;
|
||||
memsize_t memsize;
|
||||
|
||||
const float lowerBound = 0.0f;
|
||||
const float upperBound = 1.0f;
|
||||
const float lowerBound = 0.0f;
|
||||
const float upperBound = 1.0f;
|
||||
|
||||
// Determine default dimensions
|
||||
printf("Set-up, based upon target device GMEM size...\n");
|
||||
// Get the memory size of the target device
|
||||
printf(" getTargetDeviceGlobalMemSize\n");
|
||||
getTargetDeviceGlobalMemSize(&memsize, argc, argv);
|
||||
// Determine default dimensions
|
||||
printf("Set-up, based upon target device GMEM size...\n");
|
||||
// Get the memory size of the target device
|
||||
printf(" getTargetDeviceGlobalMemSize\n");
|
||||
getTargetDeviceGlobalMemSize(&memsize, argc, argv);
|
||||
|
||||
// We can never use all the memory so to keep things simple we aim to
|
||||
// use around half the total memory
|
||||
memsize /= 2;
|
||||
// We can never use all the memory so to keep things simple we aim to
|
||||
// use around half the total memory
|
||||
memsize /= 2;
|
||||
|
||||
// Most of our memory use is taken up by the input and output buffers -
|
||||
// two buffers of equal size - and for simplicity the volume is a cube:
|
||||
// dim = floor( (N/2)^(1/3) )
|
||||
defaultDim = (int)floor(pow((memsize / (2.0 * sizeof(float))), 1.0 / 3.0));
|
||||
// Most of our memory use is taken up by the input and output buffers -
|
||||
// two buffers of equal size - and for simplicity the volume is a cube:
|
||||
// dim = floor( (N/2)^(1/3) )
|
||||
defaultDim = (int)floor(pow((memsize / (2.0 * sizeof(float))), 1.0 / 3.0));
|
||||
|
||||
// By default, make the volume edge size an integer multiple of 128B to
|
||||
// improve performance by coalescing memory accesses, in a real
|
||||
// application it would make sense to pad the lines accordingly
|
||||
int roundTarget = 128 / sizeof(float);
|
||||
defaultDim = defaultDim / roundTarget * roundTarget;
|
||||
defaultDim -= k_radius_default * 2;
|
||||
// By default, make the volume edge size an integer multiple of 128B to
|
||||
// improve performance by coalescing memory accesses, in a real
|
||||
// application it would make sense to pad the lines accordingly
|
||||
int roundTarget = 128 / sizeof(float);
|
||||
defaultDim = defaultDim / roundTarget * roundTarget;
|
||||
defaultDim -= k_radius_default * 2;
|
||||
|
||||
// Check dimension is valid
|
||||
if (defaultDim < k_dim_min) {
|
||||
printf(
|
||||
"insufficient device memory (maximum volume on device is %d, must be "
|
||||
"between %d and %d).\n",
|
||||
defaultDim, k_dim_min, k_dim_max);
|
||||
exit(EXIT_FAILURE);
|
||||
} else if (defaultDim > k_dim_max) {
|
||||
defaultDim = k_dim_max;
|
||||
}
|
||||
// Check dimension is valid
|
||||
if (defaultDim < k_dim_min) {
|
||||
printf("insufficient device memory (maximum volume on device is %d, must be "
|
||||
"between %d and %d).\n",
|
||||
defaultDim,
|
||||
k_dim_min,
|
||||
k_dim_max);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
else if (defaultDim > k_dim_max) {
|
||||
defaultDim = k_dim_max;
|
||||
}
|
||||
|
||||
// For QA testing, override default volume size
|
||||
if (checkCmdLineFlag(argc, argv, "qatest")) {
|
||||
defaultDim = MIN(defaultDim, k_dim_qa);
|
||||
}
|
||||
// For QA testing, override default volume size
|
||||
if (checkCmdLineFlag(argc, argv, "qatest")) {
|
||||
defaultDim = MIN(defaultDim, k_dim_qa);
|
||||
}
|
||||
|
||||
// set default dim
|
||||
dimx = defaultDim;
|
||||
dimy = defaultDim;
|
||||
dimz = defaultDim;
|
||||
radius = k_radius_default;
|
||||
timesteps = k_timesteps_default;
|
||||
// set default dim
|
||||
dimx = defaultDim;
|
||||
dimy = defaultDim;
|
||||
dimz = defaultDim;
|
||||
radius = k_radius_default;
|
||||
timesteps = k_timesteps_default;
|
||||
|
||||
// Parse command line arguments
|
||||
if (checkCmdLineFlag(argc, argv, "dimx")) {
|
||||
dimx =
|
||||
CLAMP(getCmdLineArgumentInt(argc, argv, "dimx"), k_dim_min, k_dim_max);
|
||||
}
|
||||
// Parse command line arguments
|
||||
if (checkCmdLineFlag(argc, argv, "dimx")) {
|
||||
dimx = CLAMP(getCmdLineArgumentInt(argc, argv, "dimx"), k_dim_min, k_dim_max);
|
||||
}
|
||||
|
||||
if (checkCmdLineFlag(argc, argv, "dimy")) {
|
||||
dimy =
|
||||
CLAMP(getCmdLineArgumentInt(argc, argv, "dimy"), k_dim_min, k_dim_max);
|
||||
}
|
||||
if (checkCmdLineFlag(argc, argv, "dimy")) {
|
||||
dimy = CLAMP(getCmdLineArgumentInt(argc, argv, "dimy"), k_dim_min, k_dim_max);
|
||||
}
|
||||
|
||||
if (checkCmdLineFlag(argc, argv, "dimz")) {
|
||||
dimz =
|
||||
CLAMP(getCmdLineArgumentInt(argc, argv, "dimz"), k_dim_min, k_dim_max);
|
||||
}
|
||||
if (checkCmdLineFlag(argc, argv, "dimz")) {
|
||||
dimz = CLAMP(getCmdLineArgumentInt(argc, argv, "dimz"), k_dim_min, k_dim_max);
|
||||
}
|
||||
|
||||
if (checkCmdLineFlag(argc, argv, "radius")) {
|
||||
radius = CLAMP(getCmdLineArgumentInt(argc, argv, "radius"), k_radius_min,
|
||||
k_radius_max);
|
||||
}
|
||||
if (checkCmdLineFlag(argc, argv, "radius")) {
|
||||
radius = CLAMP(getCmdLineArgumentInt(argc, argv, "radius"), k_radius_min, k_radius_max);
|
||||
}
|
||||
|
||||
if (checkCmdLineFlag(argc, argv, "timesteps")) {
|
||||
timesteps = CLAMP(getCmdLineArgumentInt(argc, argv, "timesteps"),
|
||||
k_timesteps_min, k_timesteps_max);
|
||||
}
|
||||
if (checkCmdLineFlag(argc, argv, "timesteps")) {
|
||||
timesteps = CLAMP(getCmdLineArgumentInt(argc, argv, "timesteps"), k_timesteps_min, k_timesteps_max);
|
||||
}
|
||||
|
||||
// Determine volume size
|
||||
outerDimx = dimx + 2 * radius;
|
||||
outerDimy = dimy + 2 * radius;
|
||||
outerDimz = dimz + 2 * radius;
|
||||
volumeSize = outerDimx * outerDimy * outerDimz;
|
||||
// Determine volume size
|
||||
outerDimx = dimx + 2 * radius;
|
||||
outerDimy = dimy + 2 * radius;
|
||||
outerDimz = dimz + 2 * radius;
|
||||
volumeSize = outerDimx * outerDimy * outerDimz;
|
||||
|
||||
// Allocate memory
|
||||
host_output = (float *)calloc(volumeSize, sizeof(float));
|
||||
input = (float *)malloc(volumeSize * sizeof(float));
|
||||
coeff = (float *)malloc((radius + 1) * sizeof(float));
|
||||
// Allocate memory
|
||||
host_output = (float *)calloc(volumeSize, sizeof(float));
|
||||
input = (float *)malloc(volumeSize * sizeof(float));
|
||||
coeff = (float *)malloc((radius + 1) * sizeof(float));
|
||||
|
||||
// Create coefficients
|
||||
for (int i = 0; i <= radius; i++) {
|
||||
coeff[i] = 0.1f;
|
||||
}
|
||||
// Create coefficients
|
||||
for (int i = 0; i <= radius; i++) {
|
||||
coeff[i] = 0.1f;
|
||||
}
|
||||
|
||||
// Generate data
|
||||
printf(" generateRandomData\n\n");
|
||||
generateRandomData(input, outerDimx, outerDimy, outerDimz, lowerBound,
|
||||
upperBound);
|
||||
printf(
|
||||
"FDTD on %d x %d x %d volume with symmetric filter radius %d for %d "
|
||||
"timesteps...\n\n",
|
||||
dimx, dimy, dimz, radius, timesteps);
|
||||
// Generate data
|
||||
printf(" generateRandomData\n\n");
|
||||
generateRandomData(input, outerDimx, outerDimy, outerDimz, lowerBound, upperBound);
|
||||
printf("FDTD on %d x %d x %d volume with symmetric filter radius %d for %d "
|
||||
"timesteps...\n\n",
|
||||
dimx,
|
||||
dimy,
|
||||
dimz,
|
||||
radius,
|
||||
timesteps);
|
||||
|
||||
// Execute on the host
|
||||
printf("fdtdReference...\n");
|
||||
fdtdReference(host_output, input, coeff, dimx, dimy, dimz, radius, timesteps);
|
||||
printf("fdtdReference complete\n");
|
||||
// Execute on the host
|
||||
printf("fdtdReference...\n");
|
||||
fdtdReference(host_output, input, coeff, dimx, dimy, dimz, radius, timesteps);
|
||||
printf("fdtdReference complete\n");
|
||||
|
||||
// Allocate memory
|
||||
device_output = (float *)calloc(volumeSize, sizeof(float));
|
||||
// Allocate memory
|
||||
device_output = (float *)calloc(volumeSize, sizeof(float));
|
||||
|
||||
// Execute on the device
|
||||
printf("fdtdGPU...\n");
|
||||
fdtdGPU(device_output, input, coeff, dimx, dimy, dimz, radius, timesteps,
|
||||
argc, argv);
|
||||
printf("fdtdGPU complete\n");
|
||||
// Execute on the device
|
||||
printf("fdtdGPU...\n");
|
||||
fdtdGPU(device_output, input, coeff, dimx, dimy, dimz, radius, timesteps, argc, argv);
|
||||
printf("fdtdGPU complete\n");
|
||||
|
||||
// Compare the results
|
||||
float tolerance = 0.0001f;
|
||||
printf("\nCompareData (tolerance %f)...\n", tolerance);
|
||||
return compareData(device_output, host_output, dimx, dimy, dimz, radius,
|
||||
tolerance);
|
||||
// Compare the results
|
||||
float tolerance = 0.0001f;
|
||||
printf("\nCompareData (tolerance %f)...\n", tolerance);
|
||||
return compareData(device_output, host_output, dimx, dimy, dimz, radius, tolerance);
|
||||
}
|
||||
|
||||
@@ -25,239 +25,236 @@
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "FDTD3dGPU.h"
|
||||
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <helper_functions.h>
|
||||
#include <helper_cuda.h>
|
||||
#include <helper_functions.h>
|
||||
#include <iostream>
|
||||
|
||||
#include "FDTD3dGPU.h"
|
||||
#include "FDTD3dGPUKernel.cuh"
|
||||
|
||||
bool getTargetDeviceGlobalMemSize(memsize_t *result, const int argc,
|
||||
const char **argv) {
|
||||
int deviceCount = 0;
|
||||
int targetDevice = 0;
|
||||
size_t memsize = 0;
|
||||
bool getTargetDeviceGlobalMemSize(memsize_t *result, const int argc, const char **argv)
|
||||
{
|
||||
int deviceCount = 0;
|
||||
int targetDevice = 0;
|
||||
size_t memsize = 0;
|
||||
|
||||
// Get the number of CUDA enabled GPU devices
|
||||
printf(" cudaGetDeviceCount\n");
|
||||
checkCudaErrors(cudaGetDeviceCount(&deviceCount));
|
||||
// Get the number of CUDA enabled GPU devices
|
||||
printf(" cudaGetDeviceCount\n");
|
||||
checkCudaErrors(cudaGetDeviceCount(&deviceCount));
|
||||
|
||||
// Select target device (device 0 by default)
|
||||
targetDevice = findCudaDevice(argc, (const char **)argv);
|
||||
// Select target device (device 0 by default)
|
||||
targetDevice = findCudaDevice(argc, (const char **)argv);
|
||||
|
||||
// Query target device for maximum memory allocation
|
||||
printf(" cudaGetDeviceProperties\n");
|
||||
struct cudaDeviceProp deviceProp;
|
||||
checkCudaErrors(cudaGetDeviceProperties(&deviceProp, targetDevice));
|
||||
// Query target device for maximum memory allocation
|
||||
printf(" cudaGetDeviceProperties\n");
|
||||
struct cudaDeviceProp deviceProp;
|
||||
checkCudaErrors(cudaGetDeviceProperties(&deviceProp, targetDevice));
|
||||
|
||||
memsize = deviceProp.totalGlobalMem;
|
||||
memsize = deviceProp.totalGlobalMem;
|
||||
|
||||
// Save the result
|
||||
*result = (memsize_t)memsize;
|
||||
return true;
|
||||
// Save the result
|
||||
*result = (memsize_t)memsize;
|
||||
return true;
|
||||
}
|
||||
|
||||
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) {
|
||||
const int outerDimx = dimx + 2 * radius;
|
||||
const int outerDimy = dimy + 2 * radius;
|
||||
const int outerDimz = dimz + 2 * radius;
|
||||
const size_t volumeSize = outerDimx * outerDimy * outerDimz;
|
||||
int deviceCount = 0;
|
||||
int targetDevice = 0;
|
||||
float *bufferOut = 0;
|
||||
float *bufferIn = 0;
|
||||
dim3 dimBlock;
|
||||
dim3 dimGrid;
|
||||
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)
|
||||
{
|
||||
const int outerDimx = dimx + 2 * radius;
|
||||
const int outerDimy = dimy + 2 * radius;
|
||||
const int outerDimz = dimz + 2 * radius;
|
||||
const size_t volumeSize = outerDimx * outerDimy * outerDimz;
|
||||
int deviceCount = 0;
|
||||
int targetDevice = 0;
|
||||
float *bufferOut = 0;
|
||||
float *bufferIn = 0;
|
||||
dim3 dimBlock;
|
||||
dim3 dimGrid;
|
||||
|
||||
// Ensure that the inner data starts on a 128B boundary
|
||||
const int padding = (128 / sizeof(float)) - radius;
|
||||
const size_t paddedVolumeSize = volumeSize + padding;
|
||||
// Ensure that the inner data starts on a 128B boundary
|
||||
const int padding = (128 / sizeof(float)) - radius;
|
||||
const size_t paddedVolumeSize = volumeSize + padding;
|
||||
|
||||
#ifdef GPU_PROFILING
|
||||
cudaEvent_t profileStart = 0;
|
||||
cudaEvent_t profileEnd = 0;
|
||||
const int profileTimesteps = timesteps - 1;
|
||||
cudaEvent_t profileStart = 0;
|
||||
cudaEvent_t profileEnd = 0;
|
||||
const int profileTimesteps = timesteps - 1;
|
||||
|
||||
if (profileTimesteps < 1) {
|
||||
printf(
|
||||
" cannot profile with fewer than two timesteps (timesteps=%d), "
|
||||
"profiling is disabled.\n",
|
||||
timesteps);
|
||||
}
|
||||
if (profileTimesteps < 1) {
|
||||
printf(" cannot profile with fewer than two timesteps (timesteps=%d), "
|
||||
"profiling is disabled.\n",
|
||||
timesteps);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
// Check the radius is valid
|
||||
if (radius != RADIUS) {
|
||||
printf("radius is invalid, must be %d - see kernel for details.\n", RADIUS);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
// Check the radius is valid
|
||||
if (radius != RADIUS) {
|
||||
printf("radius is invalid, must be %d - see kernel for details.\n", RADIUS);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
// Get the number of CUDA enabled GPU devices
|
||||
checkCudaErrors(cudaGetDeviceCount(&deviceCount));
|
||||
// Get the number of CUDA enabled GPU devices
|
||||
checkCudaErrors(cudaGetDeviceCount(&deviceCount));
|
||||
|
||||
// Select target device (device 0 by default)
|
||||
targetDevice = findCudaDevice(argc, (const char **)argv);
|
||||
// Select target device (device 0 by default)
|
||||
targetDevice = findCudaDevice(argc, (const char **)argv);
|
||||
|
||||
checkCudaErrors(cudaSetDevice(targetDevice));
|
||||
checkCudaErrors(cudaSetDevice(targetDevice));
|
||||
|
||||
// Allocate memory buffers
|
||||
checkCudaErrors(
|
||||
cudaMalloc((void **)&bufferOut, paddedVolumeSize * sizeof(float)));
|
||||
checkCudaErrors(
|
||||
cudaMalloc((void **)&bufferIn, paddedVolumeSize * sizeof(float)));
|
||||
// Allocate memory buffers
|
||||
checkCudaErrors(cudaMalloc((void **)&bufferOut, paddedVolumeSize * sizeof(float)));
|
||||
checkCudaErrors(cudaMalloc((void **)&bufferIn, paddedVolumeSize * sizeof(float)));
|
||||
|
||||
// Check for a command-line specified block size
|
||||
int userBlockSize;
|
||||
// Check for a command-line specified block size
|
||||
int userBlockSize;
|
||||
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "block-size")) {
|
||||
userBlockSize = getCmdLineArgumentInt(argc, argv, "block-size");
|
||||
// Constrain to a multiple of k_blockDimX
|
||||
userBlockSize = (userBlockSize / k_blockDimX * k_blockDimX);
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "block-size")) {
|
||||
userBlockSize = getCmdLineArgumentInt(argc, argv, "block-size");
|
||||
// Constrain to a multiple of k_blockDimX
|
||||
userBlockSize = (userBlockSize / k_blockDimX * k_blockDimX);
|
||||
|
||||
// Constrain within allowed bounds
|
||||
userBlockSize = MIN(MAX(userBlockSize, k_blockSizeMin), k_blockSizeMax);
|
||||
} else {
|
||||
userBlockSize = k_blockSizeMax;
|
||||
}
|
||||
// Constrain within allowed bounds
|
||||
userBlockSize = MIN(MAX(userBlockSize, k_blockSizeMin), k_blockSizeMax);
|
||||
}
|
||||
else {
|
||||
userBlockSize = k_blockSizeMax;
|
||||
}
|
||||
|
||||
// Check the device limit on the number of threads
|
||||
struct cudaFuncAttributes funcAttrib;
|
||||
checkCudaErrors(cudaFuncGetAttributes(&funcAttrib, FiniteDifferencesKernel));
|
||||
// Check the device limit on the number of threads
|
||||
struct cudaFuncAttributes funcAttrib;
|
||||
checkCudaErrors(cudaFuncGetAttributes(&funcAttrib, FiniteDifferencesKernel));
|
||||
|
||||
userBlockSize = MIN(userBlockSize, funcAttrib.maxThreadsPerBlock);
|
||||
userBlockSize = MIN(userBlockSize, funcAttrib.maxThreadsPerBlock);
|
||||
|
||||
// Set the block size
|
||||
dimBlock.x = k_blockDimX;
|
||||
// Visual Studio 2005 does not like std::min
|
||||
// dimBlock.y = std::min<size_t>(userBlockSize / k_blockDimX,
|
||||
// (size_t)k_blockDimMaxY);
|
||||
dimBlock.y = ((userBlockSize / k_blockDimX) < (size_t)k_blockDimMaxY)
|
||||
? (userBlockSize / k_blockDimX)
|
||||
: (size_t)k_blockDimMaxY;
|
||||
dimGrid.x = (unsigned int)ceil((float)dimx / dimBlock.x);
|
||||
dimGrid.y = (unsigned int)ceil((float)dimy / dimBlock.y);
|
||||
printf(" set block size to %dx%d\n", dimBlock.x, dimBlock.y);
|
||||
printf(" set grid size to %dx%d\n", dimGrid.x, dimGrid.y);
|
||||
// Set the block size
|
||||
dimBlock.x = k_blockDimX;
|
||||
// Visual Studio 2005 does not like std::min
|
||||
// dimBlock.y = std::min<size_t>(userBlockSize / k_blockDimX,
|
||||
// (size_t)k_blockDimMaxY);
|
||||
dimBlock.y = ((userBlockSize / k_blockDimX) < (size_t)k_blockDimMaxY) ? (userBlockSize / k_blockDimX)
|
||||
: (size_t)k_blockDimMaxY;
|
||||
dimGrid.x = (unsigned int)ceil((float)dimx / dimBlock.x);
|
||||
dimGrid.y = (unsigned int)ceil((float)dimy / dimBlock.y);
|
||||
printf(" set block size to %dx%d\n", dimBlock.x, dimBlock.y);
|
||||
printf(" set grid size to %dx%d\n", dimGrid.x, dimGrid.y);
|
||||
|
||||
// Check the block size is valid
|
||||
if (dimBlock.x < RADIUS || dimBlock.y < RADIUS) {
|
||||
printf("invalid block size, x (%d) and y (%d) must be >= radius (%d).\n",
|
||||
dimBlock.x, dimBlock.y, RADIUS);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
// Check the block size is valid
|
||||
if (dimBlock.x < RADIUS || dimBlock.y < RADIUS) {
|
||||
printf("invalid block size, x (%d) and y (%d) must be >= radius (%d).\n", dimBlock.x, dimBlock.y, RADIUS);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
// Copy the input to the device input buffer
|
||||
checkCudaErrors(cudaMemcpy(bufferIn + padding, input,
|
||||
volumeSize * sizeof(float),
|
||||
cudaMemcpyHostToDevice));
|
||||
// Copy the input to the device input buffer
|
||||
checkCudaErrors(cudaMemcpy(bufferIn + padding, input, volumeSize * sizeof(float), cudaMemcpyHostToDevice));
|
||||
|
||||
// Copy the input to the device output buffer (actually only need the halo)
|
||||
checkCudaErrors(cudaMemcpy(bufferOut + padding, input,
|
||||
volumeSize * sizeof(float),
|
||||
cudaMemcpyHostToDevice));
|
||||
// Copy the input to the device output buffer (actually only need the halo)
|
||||
checkCudaErrors(cudaMemcpy(bufferOut + padding, input, volumeSize * sizeof(float), cudaMemcpyHostToDevice));
|
||||
|
||||
// Copy the coefficients to the device coefficient buffer
|
||||
checkCudaErrors(
|
||||
cudaMemcpyToSymbol(stencil, (void *)coeff, (radius + 1) * sizeof(float)));
|
||||
// Copy the coefficients to the device coefficient buffer
|
||||
checkCudaErrors(cudaMemcpyToSymbol(stencil, (void *)coeff, (radius + 1) * sizeof(float)));
|
||||
|
||||
#ifdef GPU_PROFILING
|
||||
|
||||
// Create the events
|
||||
checkCudaErrors(cudaEventCreate(&profileStart));
|
||||
checkCudaErrors(cudaEventCreate(&profileEnd));
|
||||
// Create the events
|
||||
checkCudaErrors(cudaEventCreate(&profileStart));
|
||||
checkCudaErrors(cudaEventCreate(&profileEnd));
|
||||
|
||||
#endif
|
||||
|
||||
// Execute the FDTD
|
||||
float *bufferSrc = bufferIn + padding;
|
||||
float *bufferDst = bufferOut + padding;
|
||||
printf(" GPU FDTD loop\n");
|
||||
// Execute the FDTD
|
||||
float *bufferSrc = bufferIn + padding;
|
||||
float *bufferDst = bufferOut + padding;
|
||||
printf(" GPU FDTD loop\n");
|
||||
|
||||
#ifdef GPU_PROFILING
|
||||
// Enqueue start event
|
||||
checkCudaErrors(cudaEventRecord(profileStart, 0));
|
||||
// Enqueue start event
|
||||
checkCudaErrors(cudaEventRecord(profileStart, 0));
|
||||
#endif
|
||||
|
||||
for (int it = 0; it < timesteps; it++) {
|
||||
printf("\tt = %d ", it);
|
||||
for (int it = 0; it < timesteps; it++) {
|
||||
printf("\tt = %d ", it);
|
||||
|
||||
// Launch the kernel
|
||||
printf("launch kernel\n");
|
||||
FiniteDifferencesKernel<<<dimGrid, dimBlock>>>(bufferDst, bufferSrc, dimx,
|
||||
dimy, dimz);
|
||||
// Launch the kernel
|
||||
printf("launch kernel\n");
|
||||
FiniteDifferencesKernel<<<dimGrid, dimBlock>>>(bufferDst, bufferSrc, dimx, dimy, dimz);
|
||||
|
||||
// Toggle the buffers
|
||||
// Visual Studio 2005 does not like std::swap
|
||||
// std::swap<float *>(bufferSrc, bufferDst);
|
||||
float *tmp = bufferDst;
|
||||
bufferDst = bufferSrc;
|
||||
bufferSrc = tmp;
|
||||
}
|
||||
// Toggle the buffers
|
||||
// Visual Studio 2005 does not like std::swap
|
||||
// std::swap<float *>(bufferSrc, bufferDst);
|
||||
float *tmp = bufferDst;
|
||||
bufferDst = bufferSrc;
|
||||
bufferSrc = tmp;
|
||||
}
|
||||
|
||||
printf("\n");
|
||||
printf("\n");
|
||||
|
||||
#ifdef GPU_PROFILING
|
||||
// Enqueue end event
|
||||
checkCudaErrors(cudaEventRecord(profileEnd, 0));
|
||||
// Enqueue end event
|
||||
checkCudaErrors(cudaEventRecord(profileEnd, 0));
|
||||
#endif
|
||||
|
||||
// Wait for the kernel to complete
|
||||
checkCudaErrors(cudaDeviceSynchronize());
|
||||
// Wait for the kernel to complete
|
||||
checkCudaErrors(cudaDeviceSynchronize());
|
||||
|
||||
// Read the result back, result is in bufferSrc (after final toggle)
|
||||
checkCudaErrors(cudaMemcpy(output, bufferSrc, volumeSize * sizeof(float),
|
||||
cudaMemcpyDeviceToHost));
|
||||
// Read the result back, result is in bufferSrc (after final toggle)
|
||||
checkCudaErrors(cudaMemcpy(output, bufferSrc, volumeSize * sizeof(float), cudaMemcpyDeviceToHost));
|
||||
|
||||
// Report time
|
||||
#ifdef GPU_PROFILING
|
||||
float elapsedTimeMS = 0;
|
||||
float elapsedTimeMS = 0;
|
||||
|
||||
if (profileTimesteps > 0) {
|
||||
checkCudaErrors(
|
||||
cudaEventElapsedTime(&elapsedTimeMS, profileStart, profileEnd));
|
||||
}
|
||||
if (profileTimesteps > 0) {
|
||||
checkCudaErrors(cudaEventElapsedTime(&elapsedTimeMS, profileStart, profileEnd));
|
||||
}
|
||||
|
||||
if (profileTimesteps > 0) {
|
||||
// Convert milliseconds to seconds
|
||||
double elapsedTime = elapsedTimeMS * 1.0e-3;
|
||||
double avgElapsedTime = elapsedTime / (double)profileTimesteps;
|
||||
// Determine number of computations per timestep
|
||||
size_t pointsComputed = dimx * dimy * dimz;
|
||||
// Determine throughput
|
||||
double throughputM = 1.0e-6 * (double)pointsComputed / avgElapsedTime;
|
||||
printf(
|
||||
"FDTD3d, Throughput = %.4f MPoints/s, Time = %.5f s, Size = %u Points, "
|
||||
"NumDevsUsed = %u, Blocksize = %u\n",
|
||||
throughputM, avgElapsedTime, pointsComputed, 1,
|
||||
dimBlock.x * dimBlock.y);
|
||||
}
|
||||
if (profileTimesteps > 0) {
|
||||
// Convert milliseconds to seconds
|
||||
double elapsedTime = elapsedTimeMS * 1.0e-3;
|
||||
double avgElapsedTime = elapsedTime / (double)profileTimesteps;
|
||||
// Determine number of computations per timestep
|
||||
size_t pointsComputed = dimx * dimy * dimz;
|
||||
// Determine throughput
|
||||
double throughputM = 1.0e-6 * (double)pointsComputed / avgElapsedTime;
|
||||
printf("FDTD3d, Throughput = %.4f MPoints/s, Time = %.5f s, Size = %u Points, "
|
||||
"NumDevsUsed = %u, Blocksize = %u\n",
|
||||
throughputM,
|
||||
avgElapsedTime,
|
||||
pointsComputed,
|
||||
1,
|
||||
dimBlock.x * dimBlock.y);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
// Cleanup
|
||||
if (bufferIn) {
|
||||
checkCudaErrors(cudaFree(bufferIn));
|
||||
}
|
||||
// Cleanup
|
||||
if (bufferIn) {
|
||||
checkCudaErrors(cudaFree(bufferIn));
|
||||
}
|
||||
|
||||
if (bufferOut) {
|
||||
checkCudaErrors(cudaFree(bufferOut));
|
||||
}
|
||||
if (bufferOut) {
|
||||
checkCudaErrors(cudaFree(bufferOut));
|
||||
}
|
||||
|
||||
#ifdef GPU_PROFILING
|
||||
|
||||
if (profileStart) {
|
||||
checkCudaErrors(cudaEventDestroy(profileStart));
|
||||
}
|
||||
if (profileStart) {
|
||||
checkCudaErrors(cudaEventDestroy(profileStart));
|
||||
}
|
||||
|
||||
if (profileEnd) {
|
||||
checkCudaErrors(cudaEventDestroy(profileEnd));
|
||||
}
|
||||
if (profileEnd) {
|
||||
checkCudaErrors(cudaEventDestroy(profileEnd));
|
||||
}
|
||||
|
||||
#endif
|
||||
return true;
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -27,152 +27,165 @@
|
||||
|
||||
#include "FDTD3dReference.h"
|
||||
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
#include <iomanip>
|
||||
#include <iostream>
|
||||
#include <stdio.h>
|
||||
|
||||
void generateRandomData(float *data, const int dimx, const int dimy,
|
||||
const int dimz, const float lowerBound,
|
||||
const float upperBound) {
|
||||
srand(0);
|
||||
void generateRandomData(float *data,
|
||||
const int dimx,
|
||||
const int dimy,
|
||||
const int dimz,
|
||||
const float lowerBound,
|
||||
const float upperBound)
|
||||
{
|
||||
srand(0);
|
||||
|
||||
for (int iz = 0; iz < dimz; iz++) {
|
||||
for (int iy = 0; iy < dimy; iy++) {
|
||||
for (int ix = 0; ix < dimx; ix++) {
|
||||
*data = (float)(lowerBound +
|
||||
((float)rand() / (float)RAND_MAX) *
|
||||
(upperBound - lowerBound));
|
||||
++data;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void generatePatternData(float *data, const int dimx, const int dimy,
|
||||
const int dimz, const float lowerBound,
|
||||
const float upperBound) {
|
||||
for (int iz = 0; iz < dimz; iz++) {
|
||||
for (int iy = 0; iy < dimy; iy++) {
|
||||
for (int ix = 0; ix < dimx; ix++) {
|
||||
*data = (float)(lowerBound +
|
||||
((float)iz / (float)dimz) * (upperBound - lowerBound));
|
||||
++data;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
const int outerDimx = dimx + 2 * radius;
|
||||
const int outerDimy = dimy + 2 * radius;
|
||||
const int outerDimz = dimz + 2 * radius;
|
||||
const size_t volumeSize = outerDimx * outerDimy * outerDimz;
|
||||
const int stride_y = outerDimx;
|
||||
const int stride_z = stride_y * outerDimy;
|
||||
float *intermediate = 0;
|
||||
const float *bufsrc = 0;
|
||||
float *bufdst = 0;
|
||||
float *bufdstnext = 0;
|
||||
|
||||
// Allocate temporary buffer
|
||||
printf(" calloc intermediate\n");
|
||||
intermediate = (float *)calloc(volumeSize, sizeof(float));
|
||||
|
||||
// Decide which buffer to use first (result should end up in output)
|
||||
if ((timesteps % 2) == 0) {
|
||||
bufsrc = input;
|
||||
bufdst = intermediate;
|
||||
bufdstnext = output;
|
||||
} else {
|
||||
bufsrc = input;
|
||||
bufdst = output;
|
||||
bufdstnext = intermediate;
|
||||
}
|
||||
|
||||
// Run the FDTD (naive method)
|
||||
printf(" Host FDTD loop\n");
|
||||
|
||||
for (int it = 0; it < timesteps; it++) {
|
||||
printf("\tt = %d\n", it);
|
||||
const float *src = bufsrc;
|
||||
float *dst = bufdst;
|
||||
|
||||
for (int iz = -radius; iz < dimz + radius; iz++) {
|
||||
for (int iy = -radius; iy < dimy + radius; iy++) {
|
||||
for (int ix = -radius; ix < dimx + radius; ix++) {
|
||||
if (ix >= 0 && ix < dimx && iy >= 0 && iy < dimy && iz >= 0 &&
|
||||
iz < dimz) {
|
||||
float value = (*src) * coeff[0];
|
||||
|
||||
for (int ir = 1; ir <= radius; ir++) {
|
||||
value += coeff[ir] * (*(src + ir) + *(src - ir)); // horizontal
|
||||
value += coeff[ir] * (*(src + ir * stride_y) +
|
||||
*(src - ir * stride_y)); // vertical
|
||||
value +=
|
||||
coeff[ir] * (*(src + ir * stride_z) +
|
||||
*(src - ir * stride_z)); // in front & behind
|
||||
for (int iz = 0; iz < dimz; iz++) {
|
||||
for (int iy = 0; iy < dimy; iy++) {
|
||||
for (int ix = 0; ix < dimx; ix++) {
|
||||
*data = (float)(lowerBound + ((float)rand() / (float)RAND_MAX) * (upperBound - lowerBound));
|
||||
++data;
|
||||
}
|
||||
|
||||
*dst = value;
|
||||
} else {
|
||||
*dst = *src;
|
||||
}
|
||||
|
||||
++dst;
|
||||
++src;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Rotate buffers
|
||||
float *tmp = bufdst;
|
||||
bufdst = bufdstnext;
|
||||
bufdstnext = tmp;
|
||||
bufsrc = (const float *)tmp;
|
||||
}
|
||||
|
||||
printf("\n");
|
||||
|
||||
if (intermediate) free(intermediate);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool compareData(const float *output, const float *reference, const int dimx,
|
||||
const int dimy, const int dimz, const int radius,
|
||||
const float tolerance) {
|
||||
for (int iz = -radius; iz < dimz + radius; iz++) {
|
||||
for (int iy = -radius; iy < dimy + radius; iy++) {
|
||||
for (int ix = -radius; ix < dimx + radius; ix++) {
|
||||
if (ix >= 0 && ix < dimx && iy >= 0 && iy < dimy && iz >= 0 &&
|
||||
iz < dimz) {
|
||||
// Determine the absolute difference
|
||||
float difference = fabs(*reference - *output);
|
||||
float error;
|
||||
void generatePatternData(float *data,
|
||||
const int dimx,
|
||||
const int dimy,
|
||||
const int dimz,
|
||||
const float lowerBound,
|
||||
const float upperBound)
|
||||
{
|
||||
for (int iz = 0; iz < dimz; iz++) {
|
||||
for (int iy = 0; iy < dimy; iy++) {
|
||||
for (int ix = 0; ix < dimx; ix++) {
|
||||
*data = (float)(lowerBound + ((float)iz / (float)dimz) * (upperBound - lowerBound));
|
||||
++data;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Determine the relative error
|
||||
if (*reference != 0)
|
||||
error = difference / *reference;
|
||||
else
|
||||
error = difference;
|
||||
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)
|
||||
{
|
||||
const int outerDimx = dimx + 2 * radius;
|
||||
const int outerDimy = dimy + 2 * radius;
|
||||
const int outerDimz = dimz + 2 * radius;
|
||||
const size_t volumeSize = outerDimx * outerDimy * outerDimz;
|
||||
const int stride_y = outerDimx;
|
||||
const int stride_z = stride_y * outerDimy;
|
||||
float *intermediate = 0;
|
||||
const float *bufsrc = 0;
|
||||
float *bufdst = 0;
|
||||
float *bufdstnext = 0;
|
||||
|
||||
// Check the error is within the tolerance
|
||||
if (error > tolerance) {
|
||||
printf("Data error at point (%d,%d,%d)\t%f instead of %f\n", ix, iy,
|
||||
iz, *output, *reference);
|
||||
return false;
|
||||
}
|
||||
// Allocate temporary buffer
|
||||
printf(" calloc intermediate\n");
|
||||
intermediate = (float *)calloc(volumeSize, sizeof(float));
|
||||
|
||||
// Decide which buffer to use first (result should end up in output)
|
||||
if ((timesteps % 2) == 0) {
|
||||
bufsrc = input;
|
||||
bufdst = intermediate;
|
||||
bufdstnext = output;
|
||||
}
|
||||
else {
|
||||
bufsrc = input;
|
||||
bufdst = output;
|
||||
bufdstnext = intermediate;
|
||||
}
|
||||
|
||||
// Run the FDTD (naive method)
|
||||
printf(" Host FDTD loop\n");
|
||||
|
||||
for (int it = 0; it < timesteps; it++) {
|
||||
printf("\tt = %d\n", it);
|
||||
const float *src = bufsrc;
|
||||
float *dst = bufdst;
|
||||
|
||||
for (int iz = -radius; iz < dimz + radius; iz++) {
|
||||
for (int iy = -radius; iy < dimy + radius; iy++) {
|
||||
for (int ix = -radius; ix < dimx + radius; ix++) {
|
||||
if (ix >= 0 && ix < dimx && iy >= 0 && iy < dimy && iz >= 0 && iz < dimz) {
|
||||
float value = (*src) * coeff[0];
|
||||
|
||||
for (int ir = 1; ir <= radius; ir++) {
|
||||
value += coeff[ir] * (*(src + ir) + *(src - ir)); // horizontal
|
||||
value += coeff[ir] * (*(src + ir * stride_y) + *(src - ir * stride_y)); // vertical
|
||||
value += coeff[ir] * (*(src + ir * stride_z) + *(src - ir * stride_z)); // in front & behind
|
||||
}
|
||||
|
||||
*dst = value;
|
||||
}
|
||||
else {
|
||||
*dst = *src;
|
||||
}
|
||||
|
||||
++dst;
|
||||
++src;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
++output;
|
||||
++reference;
|
||||
}
|
||||
// Rotate buffers
|
||||
float *tmp = bufdst;
|
||||
bufdst = bufdstnext;
|
||||
bufdstnext = tmp;
|
||||
bufsrc = (const float *)tmp;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
printf("\n");
|
||||
|
||||
if (intermediate)
|
||||
free(intermediate);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool compareData(const float *output,
|
||||
const float *reference,
|
||||
const int dimx,
|
||||
const int dimy,
|
||||
const int dimz,
|
||||
const int radius,
|
||||
const float tolerance)
|
||||
{
|
||||
for (int iz = -radius; iz < dimz + radius; iz++) {
|
||||
for (int iy = -radius; iy < dimy + radius; iy++) {
|
||||
for (int ix = -radius; ix < dimx + radius; ix++) {
|
||||
if (ix >= 0 && ix < dimx && iy >= 0 && iy < dimy && iz >= 0 && iz < dimz) {
|
||||
// Determine the absolute difference
|
||||
float difference = fabs(*reference - *output);
|
||||
float error;
|
||||
|
||||
// Determine the relative error
|
||||
if (*reference != 0)
|
||||
error = difference / *reference;
|
||||
else
|
||||
error = difference;
|
||||
|
||||
// Check the error is within the tolerance
|
||||
if (error > tolerance) {
|
||||
printf("Data error at point (%d,%d,%d)\t%f instead of %f\n", ix, iy, iz, *output, *reference);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
++output;
|
||||
++reference;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user