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
@@ -29,19 +29,17 @@
|
||||
#include <cuda_runtime.h>
|
||||
|
||||
// Utilities and system includes
|
||||
#include <helper_functions.h>
|
||||
#include <helper_cuda.h>
|
||||
#include <helper_functions.h>
|
||||
|
||||
#include "quasirandomGenerator_common.h"
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// CPU code
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
extern "C" void initQuasirandomGenerator(
|
||||
unsigned int table[QRNG_DIMENSIONS][QRNG_RESOLUTION]);
|
||||
extern "C" void initQuasirandomGenerator(unsigned int table[QRNG_DIMENSIONS][QRNG_RESOLUTION]);
|
||||
|
||||
extern "C" float getQuasirandomValue(
|
||||
unsigned int table[QRNG_DIMENSIONS][QRNG_RESOLUTION], int i, int dim);
|
||||
extern "C" float getQuasirandomValue(unsigned int table[QRNG_DIMENSIONS][QRNG_RESOLUTION], int i, int dim);
|
||||
|
||||
extern "C" double getQuasirandomValue63(INT64 i, int dim);
|
||||
extern "C" double MoroInvCNDcpu(unsigned int p);
|
||||
@@ -49,135 +47,132 @@ extern "C" double MoroInvCNDcpu(unsigned int p);
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// GPU code
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
extern "C" void initTableGPU(
|
||||
unsigned int tableCPU[QRNG_DIMENSIONS][QRNG_RESOLUTION]);
|
||||
extern "C" void quasirandomGeneratorGPU(float *d_Output, unsigned int seed,
|
||||
unsigned int N);
|
||||
extern "C" void inverseCNDgpu(float *d_Output, unsigned int *d_Input,
|
||||
unsigned int N);
|
||||
extern "C" void initTableGPU(unsigned int tableCPU[QRNG_DIMENSIONS][QRNG_RESOLUTION]);
|
||||
extern "C" void quasirandomGeneratorGPU(float *d_Output, unsigned int seed, unsigned int N);
|
||||
extern "C" void inverseCNDgpu(float *d_Output, unsigned int *d_Input, unsigned int N);
|
||||
|
||||
const int N = 1048576;
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
// Start logs
|
||||
printf("%s Starting...\n\n", argv[0]);
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
// Start logs
|
||||
printf("%s Starting...\n\n", argv[0]);
|
||||
|
||||
unsigned int tableCPU[QRNG_DIMENSIONS][QRNG_RESOLUTION];
|
||||
unsigned int tableCPU[QRNG_DIMENSIONS][QRNG_RESOLUTION];
|
||||
|
||||
float *h_OutputGPU, *d_Output;
|
||||
float *h_OutputGPU, *d_Output;
|
||||
|
||||
int dim, pos;
|
||||
double delta, ref, sumDelta, sumRef, L1norm, gpuTime;
|
||||
int dim, pos;
|
||||
double delta, ref, sumDelta, sumRef, L1norm, gpuTime;
|
||||
|
||||
StopWatchInterface *hTimer = NULL;
|
||||
StopWatchInterface *hTimer = NULL;
|
||||
|
||||
if (sizeof(INT64) != 8) {
|
||||
printf("sizeof(INT64) != 8\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
sdkCreateTimer(&hTimer);
|
||||
|
||||
printf("Allocating GPU memory...\n");
|
||||
checkCudaErrors(
|
||||
cudaMalloc((void **)&d_Output, QRNG_DIMENSIONS * N * sizeof(float)));
|
||||
|
||||
printf("Allocating CPU memory...\n");
|
||||
h_OutputGPU = (float *)malloc(QRNG_DIMENSIONS * N * sizeof(float));
|
||||
|
||||
printf("Initializing QRNG tables...\n\n");
|
||||
initQuasirandomGenerator(tableCPU);
|
||||
|
||||
initTableGPU(tableCPU);
|
||||
|
||||
printf("Testing QRNG...\n\n");
|
||||
checkCudaErrors(cudaMemset(d_Output, 0, QRNG_DIMENSIONS * N * sizeof(float)));
|
||||
int numIterations = 20;
|
||||
|
||||
for (int i = -1; i < numIterations; i++) {
|
||||
if (i == 0) {
|
||||
checkCudaErrors(cudaDeviceSynchronize());
|
||||
sdkResetTimer(&hTimer);
|
||||
sdkStartTimer(&hTimer);
|
||||
if (sizeof(INT64) != 8) {
|
||||
printf("sizeof(INT64) != 8\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
quasirandomGeneratorGPU(d_Output, 0, N);
|
||||
}
|
||||
sdkCreateTimer(&hTimer);
|
||||
|
||||
checkCudaErrors(cudaDeviceSynchronize());
|
||||
sdkStopTimer(&hTimer);
|
||||
gpuTime = sdkGetTimerValue(&hTimer) / (double)numIterations * 1e-3;
|
||||
printf(
|
||||
"quasirandomGenerator, Throughput = %.4f GNumbers/s, Time = %.5f s, Size "
|
||||
"= %u Numbers, NumDevsUsed = %u, Workgroup = %u\n",
|
||||
(double)QRNG_DIMENSIONS * (double)N * 1.0E-9 / gpuTime, gpuTime,
|
||||
QRNG_DIMENSIONS * N, 1, 128 * QRNG_DIMENSIONS);
|
||||
printf("Allocating GPU memory...\n");
|
||||
checkCudaErrors(cudaMalloc((void **)&d_Output, QRNG_DIMENSIONS * N * sizeof(float)));
|
||||
|
||||
printf("\nReading GPU results...\n");
|
||||
checkCudaErrors(cudaMemcpy(h_OutputGPU, d_Output,
|
||||
QRNG_DIMENSIONS * N * sizeof(float),
|
||||
cudaMemcpyDeviceToHost));
|
||||
printf("Allocating CPU memory...\n");
|
||||
h_OutputGPU = (float *)malloc(QRNG_DIMENSIONS * N * sizeof(float));
|
||||
|
||||
printf("Comparing to the CPU results...\n\n");
|
||||
sumDelta = 0;
|
||||
sumRef = 0;
|
||||
printf("Initializing QRNG tables...\n\n");
|
||||
initQuasirandomGenerator(tableCPU);
|
||||
|
||||
for (dim = 0; dim < QRNG_DIMENSIONS; dim++)
|
||||
for (pos = 0; pos < N; pos++) {
|
||||
ref = getQuasirandomValue63(pos, dim);
|
||||
delta = (double)h_OutputGPU[dim * N + pos] - ref;
|
||||
sumDelta += fabs(delta);
|
||||
sumRef += fabs(ref);
|
||||
initTableGPU(tableCPU);
|
||||
|
||||
printf("Testing QRNG...\n\n");
|
||||
checkCudaErrors(cudaMemset(d_Output, 0, QRNG_DIMENSIONS * N * sizeof(float)));
|
||||
int numIterations = 20;
|
||||
|
||||
for (int i = -1; i < numIterations; i++) {
|
||||
if (i == 0) {
|
||||
checkCudaErrors(cudaDeviceSynchronize());
|
||||
sdkResetTimer(&hTimer);
|
||||
sdkStartTimer(&hTimer);
|
||||
}
|
||||
|
||||
quasirandomGeneratorGPU(d_Output, 0, N);
|
||||
}
|
||||
|
||||
printf("L1 norm: %E\n", sumDelta / sumRef);
|
||||
checkCudaErrors(cudaDeviceSynchronize());
|
||||
sdkStopTimer(&hTimer);
|
||||
gpuTime = sdkGetTimerValue(&hTimer) / (double)numIterations * 1e-3;
|
||||
printf("quasirandomGenerator, Throughput = %.4f GNumbers/s, Time = %.5f s, Size "
|
||||
"= %u Numbers, NumDevsUsed = %u, Workgroup = %u\n",
|
||||
(double)QRNG_DIMENSIONS * (double)N * 1.0E-9 / gpuTime,
|
||||
gpuTime,
|
||||
QRNG_DIMENSIONS * N,
|
||||
1,
|
||||
128 * QRNG_DIMENSIONS);
|
||||
|
||||
printf("\nTesting inverseCNDgpu()...\n\n");
|
||||
checkCudaErrors(cudaMemset(d_Output, 0, QRNG_DIMENSIONS * N * sizeof(float)));
|
||||
printf("\nReading GPU results...\n");
|
||||
checkCudaErrors(cudaMemcpy(h_OutputGPU, d_Output, QRNG_DIMENSIONS * N * sizeof(float), cudaMemcpyDeviceToHost));
|
||||
|
||||
for (int i = -1; i < numIterations; i++) {
|
||||
if (i == 0) {
|
||||
checkCudaErrors(cudaDeviceSynchronize());
|
||||
sdkResetTimer(&hTimer);
|
||||
sdkStartTimer(&hTimer);
|
||||
printf("Comparing to the CPU results...\n\n");
|
||||
sumDelta = 0;
|
||||
sumRef = 0;
|
||||
|
||||
for (dim = 0; dim < QRNG_DIMENSIONS; dim++)
|
||||
for (pos = 0; pos < N; pos++) {
|
||||
ref = getQuasirandomValue63(pos, dim);
|
||||
delta = (double)h_OutputGPU[dim * N + pos] - ref;
|
||||
sumDelta += fabs(delta);
|
||||
sumRef += fabs(ref);
|
||||
}
|
||||
|
||||
printf("L1 norm: %E\n", sumDelta / sumRef);
|
||||
|
||||
printf("\nTesting inverseCNDgpu()...\n\n");
|
||||
checkCudaErrors(cudaMemset(d_Output, 0, QRNG_DIMENSIONS * N * sizeof(float)));
|
||||
|
||||
for (int i = -1; i < numIterations; i++) {
|
||||
if (i == 0) {
|
||||
checkCudaErrors(cudaDeviceSynchronize());
|
||||
sdkResetTimer(&hTimer);
|
||||
sdkStartTimer(&hTimer);
|
||||
}
|
||||
|
||||
inverseCNDgpu(d_Output, NULL, QRNG_DIMENSIONS * N);
|
||||
}
|
||||
|
||||
inverseCNDgpu(d_Output, NULL, QRNG_DIMENSIONS * N);
|
||||
}
|
||||
checkCudaErrors(cudaDeviceSynchronize());
|
||||
sdkStopTimer(&hTimer);
|
||||
gpuTime = sdkGetTimerValue(&hTimer) / (double)numIterations * 1e-3;
|
||||
printf("quasirandomGenerator-inverse, Throughput = %.4f GNumbers/s, Time = %.5f "
|
||||
"s, Size = %u Numbers, NumDevsUsed = %u, Workgroup = %u\n",
|
||||
(double)QRNG_DIMENSIONS * (double)N * 1E-9 / gpuTime,
|
||||
gpuTime,
|
||||
QRNG_DIMENSIONS * N,
|
||||
1,
|
||||
128);
|
||||
|
||||
checkCudaErrors(cudaDeviceSynchronize());
|
||||
sdkStopTimer(&hTimer);
|
||||
gpuTime = sdkGetTimerValue(&hTimer) / (double)numIterations * 1e-3;
|
||||
printf(
|
||||
"quasirandomGenerator-inverse, Throughput = %.4f GNumbers/s, Time = %.5f "
|
||||
"s, Size = %u Numbers, NumDevsUsed = %u, Workgroup = %u\n",
|
||||
(double)QRNG_DIMENSIONS * (double)N * 1E-9 / gpuTime, gpuTime,
|
||||
QRNG_DIMENSIONS * N, 1, 128);
|
||||
printf("Reading GPU results...\n");
|
||||
checkCudaErrors(cudaMemcpy(h_OutputGPU, d_Output, QRNG_DIMENSIONS * N * sizeof(float), cudaMemcpyDeviceToHost));
|
||||
|
||||
printf("Reading GPU results...\n");
|
||||
checkCudaErrors(cudaMemcpy(h_OutputGPU, d_Output,
|
||||
QRNG_DIMENSIONS * N * sizeof(float),
|
||||
cudaMemcpyDeviceToHost));
|
||||
printf("\nComparing to the CPU results...\n");
|
||||
sumDelta = 0;
|
||||
sumRef = 0;
|
||||
unsigned int distance = ((unsigned int)-1) / (QRNG_DIMENSIONS * N + 1);
|
||||
|
||||
printf("\nComparing to the CPU results...\n");
|
||||
sumDelta = 0;
|
||||
sumRef = 0;
|
||||
unsigned int distance = ((unsigned int)-1) / (QRNG_DIMENSIONS * N + 1);
|
||||
for (pos = 0; pos < QRNG_DIMENSIONS * N; pos++) {
|
||||
unsigned int d = (pos + 1) * distance;
|
||||
ref = MoroInvCNDcpu(d);
|
||||
delta = (double)h_OutputGPU[pos] - ref;
|
||||
sumDelta += fabs(delta);
|
||||
sumRef += fabs(ref);
|
||||
}
|
||||
|
||||
for (pos = 0; pos < QRNG_DIMENSIONS * N; pos++) {
|
||||
unsigned int d = (pos + 1) * distance;
|
||||
ref = MoroInvCNDcpu(d);
|
||||
delta = (double)h_OutputGPU[pos] - ref;
|
||||
sumDelta += fabs(delta);
|
||||
sumRef += fabs(ref);
|
||||
}
|
||||
printf("L1 norm: %E\n\n", L1norm = sumDelta / sumRef);
|
||||
|
||||
printf("L1 norm: %E\n\n", L1norm = sumDelta / sumRef);
|
||||
printf("Shutting down...\n");
|
||||
sdkDeleteTimer(&hTimer);
|
||||
free(h_OutputGPU);
|
||||
checkCudaErrors(cudaFree(d_Output));
|
||||
|
||||
printf("Shutting down...\n");
|
||||
sdkDeleteTimer(&hTimer);
|
||||
free(h_OutputGPU);
|
||||
checkCudaErrors(cudaFree(d_Output));
|
||||
|
||||
exit(L1norm < 1e-6 ? EXIT_SUCCESS : EXIT_FAILURE);
|
||||
exit(L1norm < 1e-6 ? EXIT_SUCCESS : EXIT_FAILURE);
|
||||
}
|
||||
|
||||
@@ -35,6 +35,6 @@ typedef long long int INT64;
|
||||
|
||||
#define QRNG_DIMENSIONS 3
|
||||
#define QRNG_RESOLUTION 31
|
||||
#define INT_SCALE (1.0f / (float)0x80000001U)
|
||||
#define INT_SCALE (1.0f / (float)0x80000001U)
|
||||
|
||||
#endif
|
||||
|
||||
@@ -25,8 +25,8 @@
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "quasirandomGenerator_common.h"
|
||||
|
||||
@@ -36,69 +36,71 @@
|
||||
// Internal 64(63)-bit table
|
||||
static INT64 cjn[63][QRNG_DIMENSIONS];
|
||||
|
||||
static int GeneratePolynomials(int buffer[QRNG_DIMENSIONS], bool primitive) {
|
||||
int i, j, n, p1, p2, l;
|
||||
int e_p1, e_p2, e_b;
|
||||
static int GeneratePolynomials(int buffer[QRNG_DIMENSIONS], bool primitive)
|
||||
{
|
||||
int i, j, n, p1, p2, l;
|
||||
int e_p1, e_p2, e_b;
|
||||
|
||||
// generate all polynomials to buffer
|
||||
for (n = 1, buffer[0] = 0x2, p2 = 0, l = 0; n < QRNG_DIMENSIONS; ++n) {
|
||||
// search for the next irreducible polynomial
|
||||
for (p1 = buffer[n - 1] + 1;; ++p1) {
|
||||
// find degree of polynomial p1
|
||||
for (e_p1 = 30; (p1 & (1 << e_p1)) == 0; --e_p1) {
|
||||
}
|
||||
// generate all polynomials to buffer
|
||||
for (n = 1, buffer[0] = 0x2, p2 = 0, l = 0; n < QRNG_DIMENSIONS; ++n) {
|
||||
// search for the next irreducible polynomial
|
||||
for (p1 = buffer[n - 1] + 1;; ++p1) {
|
||||
// find degree of polynomial p1
|
||||
for (e_p1 = 30; (p1 & (1 << e_p1)) == 0; --e_p1) {
|
||||
}
|
||||
|
||||
// try to divide p1 by all polynomials in buffer
|
||||
for (i = 0; i < n; ++i) {
|
||||
// find the degree of buffer[i]
|
||||
for (e_b = e_p1; (buffer[i] & (1 << e_b)) == 0; --e_b) {
|
||||
// try to divide p1 by all polynomials in buffer
|
||||
for (i = 0; i < n; ++i) {
|
||||
// find the degree of buffer[i]
|
||||
for (e_b = e_p1; (buffer[i] & (1 << e_b)) == 0; --e_b) {
|
||||
}
|
||||
|
||||
// divide p2 by buffer[i] until the end
|
||||
for (p2 = (buffer[i] << ((e_p2 = e_p1) - e_b)) ^ p1; p2 >= buffer[i];
|
||||
p2 = (buffer[i] << (e_p2 - e_b)) ^ p2) {
|
||||
for (; (p2 & (1 << e_p2)) == 0; --e_p2) {
|
||||
}
|
||||
} // compute new degree of p2
|
||||
|
||||
// division without remainder!!! p1 is not irreducible
|
||||
if (p2 == 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// all divisions were with remainder - p1 is irreducible
|
||||
if (p2 != 0) {
|
||||
e_p2 = 0;
|
||||
|
||||
if (primitive) {
|
||||
// check that p1 has only one cycle (i.e. is monic, or primitive)
|
||||
j = ~(0xffffffff << (e_p1 + 1));
|
||||
e_b = (1 << e_p1) | 0x1;
|
||||
|
||||
for (p2 = e_b, e_p2 = (1 << e_p1) - 2; e_p2 > 0; --e_p2) {
|
||||
p2 <<= 1;
|
||||
i = p2 & p1;
|
||||
i = (i & 0x55555555) + ((i >> 1) & 0x55555555);
|
||||
i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
|
||||
i = (i & 0x07070707) + ((i >> 4) & 0x07070707);
|
||||
p2 |= (i % 255) & 1;
|
||||
|
||||
if ((p2 & j) == e_b)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// it is monic - add it to the list of polynomials
|
||||
if (e_p2 == 0) {
|
||||
buffer[n] = p1;
|
||||
l += e_p1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// divide p2 by buffer[i] until the end
|
||||
for (p2 = (buffer[i] << ((e_p2 = e_p1) - e_b)) ^ p1; p2 >= buffer[i];
|
||||
p2 = (buffer[i] << (e_p2 - e_b)) ^ p2) {
|
||||
for (; (p2 & (1 << e_p2)) == 0; --e_p2) {
|
||||
}
|
||||
} // compute new degree of p2
|
||||
|
||||
// division without remainder!!! p1 is not irreducible
|
||||
if (p2 == 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// all divisions were with remainder - p1 is irreducible
|
||||
if (p2 != 0) {
|
||||
e_p2 = 0;
|
||||
|
||||
if (primitive) {
|
||||
// check that p1 has only one cycle (i.e. is monic, or primitive)
|
||||
j = ~(0xffffffff << (e_p1 + 1));
|
||||
e_b = (1 << e_p1) | 0x1;
|
||||
|
||||
for (p2 = e_b, e_p2 = (1 << e_p1) - 2; e_p2 > 0; --e_p2) {
|
||||
p2 <<= 1;
|
||||
i = p2 & p1;
|
||||
i = (i & 0x55555555) + ((i >> 1) & 0x55555555);
|
||||
i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
|
||||
i = (i & 0x07070707) + ((i >> 4) & 0x07070707);
|
||||
p2 |= (i % 255) & 1;
|
||||
|
||||
if ((p2 & j) == e_b) break;
|
||||
}
|
||||
}
|
||||
|
||||
// it is monic - add it to the list of polynomials
|
||||
if (e_p2 == 0) {
|
||||
buffer[n] = p1;
|
||||
l += e_p1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return l + 1;
|
||||
return l + 1;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
@@ -112,214 +114,217 @@ static int GeneratePolynomials(int buffer[QRNG_DIMENSIONS], bool primitive) {
|
||||
// July 1992.",
|
||||
// year = "1992" }
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
static void GenerateCJ() {
|
||||
int buffer[QRNG_DIMENSIONS];
|
||||
int *polynomials;
|
||||
int n, p1, l, e_p1;
|
||||
static void GenerateCJ()
|
||||
{
|
||||
int buffer[QRNG_DIMENSIONS];
|
||||
int *polynomials;
|
||||
int n, p1, l, e_p1;
|
||||
|
||||
// Niederreiter (in contrast to Sobol) allows to use not primitive, but just
|
||||
// irreducible polynomials
|
||||
l = GeneratePolynomials(buffer, false);
|
||||
// Niederreiter (in contrast to Sobol) allows to use not primitive, but just
|
||||
// irreducible polynomials
|
||||
l = GeneratePolynomials(buffer, false);
|
||||
|
||||
// convert all polynomials from buffer to polynomials table
|
||||
polynomials = new int[l + 2 * QRNG_DIMENSIONS + 1];
|
||||
// convert all polynomials from buffer to polynomials table
|
||||
polynomials = new int[l + 2 * QRNG_DIMENSIONS + 1];
|
||||
|
||||
for (n = 0, l = 0; n < QRNG_DIMENSIONS; ++n) {
|
||||
// find degree of polynomial p1
|
||||
for (p1 = buffer[n], e_p1 = 30; (p1 & (1 << e_p1)) == 0; --e_p1) {
|
||||
}
|
||||
|
||||
// fill polynomials table with values for this polynomial
|
||||
polynomials[l++] = 1;
|
||||
|
||||
for (--e_p1; e_p1 >= 0; --e_p1) {
|
||||
polynomials[l++] = (p1 >> e_p1) & 1;
|
||||
}
|
||||
|
||||
polynomials[l++] = -1;
|
||||
}
|
||||
|
||||
polynomials[l] = -1;
|
||||
|
||||
// irreducible polynomial p
|
||||
int *p = polynomials, e, d;
|
||||
// polynomial b
|
||||
int b_arr[1024], *b, m;
|
||||
// v array
|
||||
int v_arr[1024], *v;
|
||||
// temporary polynomial, required to do multiplication of p and b
|
||||
int t_arr[1024], *t;
|
||||
// subsidiary variables
|
||||
int i, j, u, m1, ip, it;
|
||||
|
||||
// cycle over monic irreducible polynomials
|
||||
for (d = 0; p[0] != -1; p += e + 2) {
|
||||
// allocate memory for cj array for dimension (ip + 1)
|
||||
for (i = 0; i < 63; ++i) {
|
||||
cjn[i][d] = 0;
|
||||
}
|
||||
|
||||
// determine the power of irreducible polynomial
|
||||
for (e = 0; p[e + 1] != -1; ++e) {
|
||||
}
|
||||
|
||||
// polynomial b in the beginning is just '1'
|
||||
(b = b_arr + 1023)[m = 0] = 1;
|
||||
// v array needs only (63 + e - 2) length
|
||||
v = v_arr + 1023 - (63 + e - 2);
|
||||
|
||||
// cycle over all coefficients
|
||||
for (j = 63 - 1, u = e; j >= 0; --j, ++u) {
|
||||
if (u == e) {
|
||||
u = 0;
|
||||
|
||||
// multiply b by p (polynomials multiplication)
|
||||
for (i = 0, t = t_arr + 1023 - (m1 = m); i <= m; ++i) {
|
||||
t[i] = b[i];
|
||||
for (n = 0, l = 0; n < QRNG_DIMENSIONS; ++n) {
|
||||
// find degree of polynomial p1
|
||||
for (p1 = buffer[n], e_p1 = 30; (p1 & (1 << e_p1)) == 0; --e_p1) {
|
||||
}
|
||||
|
||||
b = b_arr + 1023 - (m += e);
|
||||
// fill polynomials table with values for this polynomial
|
||||
polynomials[l++] = 1;
|
||||
|
||||
for (i = 0; i <= m; ++i) {
|
||||
b[i] = 0;
|
||||
for (--e_p1; e_p1 >= 0; --e_p1) {
|
||||
polynomials[l++] = (p1 >> e_p1) & 1;
|
||||
}
|
||||
|
||||
for (ip = e - (m - i), it = m1; ip <= e && it >= 0; ++ip, --it) {
|
||||
if (ip >= 0) {
|
||||
b[i] ^= p[ip] & t[it];
|
||||
polynomials[l++] = -1;
|
||||
}
|
||||
|
||||
polynomials[l] = -1;
|
||||
|
||||
// irreducible polynomial p
|
||||
int *p = polynomials, e, d;
|
||||
// polynomial b
|
||||
int b_arr[1024], *b, m;
|
||||
// v array
|
||||
int v_arr[1024], *v;
|
||||
// temporary polynomial, required to do multiplication of p and b
|
||||
int t_arr[1024], *t;
|
||||
// subsidiary variables
|
||||
int i, j, u, m1, ip, it;
|
||||
|
||||
// cycle over monic irreducible polynomials
|
||||
for (d = 0; p[0] != -1; p += e + 2) {
|
||||
// allocate memory for cj array for dimension (ip + 1)
|
||||
for (i = 0; i < 63; ++i) {
|
||||
cjn[i][d] = 0;
|
||||
}
|
||||
|
||||
// determine the power of irreducible polynomial
|
||||
for (e = 0; p[e + 1] != -1; ++e) {
|
||||
}
|
||||
|
||||
// polynomial b in the beginning is just '1'
|
||||
(b = b_arr + 1023)[m = 0] = 1;
|
||||
// v array needs only (63 + e - 2) length
|
||||
v = v_arr + 1023 - (63 + e - 2);
|
||||
|
||||
// cycle over all coefficients
|
||||
for (j = 63 - 1, u = e; j >= 0; --j, ++u) {
|
||||
if (u == e) {
|
||||
u = 0;
|
||||
|
||||
// multiply b by p (polynomials multiplication)
|
||||
for (i = 0, t = t_arr + 1023 - (m1 = m); i <= m; ++i) {
|
||||
t[i] = b[i];
|
||||
}
|
||||
|
||||
b = b_arr + 1023 - (m += e);
|
||||
|
||||
for (i = 0; i <= m; ++i) {
|
||||
b[i] = 0;
|
||||
|
||||
for (ip = e - (m - i), it = m1; ip <= e && it >= 0; ++ip, --it) {
|
||||
if (ip >= 0) {
|
||||
b[i] ^= p[ip] & t[it];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// multiplication of polynomials finished
|
||||
|
||||
// calculate v
|
||||
for (i = 0; i < m1; ++i) {
|
||||
v[i] = 0;
|
||||
}
|
||||
|
||||
for (; i < m; ++i) {
|
||||
v[i] = 1;
|
||||
}
|
||||
|
||||
for (; i <= 63 + e - 2; ++i) {
|
||||
v[i] = 0;
|
||||
|
||||
for (it = 1; it <= m; ++it) {
|
||||
v[i] ^= v[i - it] & b[it];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// copy calculated v to cj
|
||||
for (i = 0; i < 63; i++) {
|
||||
cjn[i][d] |= (INT64)v[i + u] << j;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// multiplication of polynomials finished
|
||||
|
||||
// calculate v
|
||||
for (i = 0; i < m1; ++i) {
|
||||
v[i] = 0;
|
||||
}
|
||||
|
||||
for (; i < m; ++i) {
|
||||
v[i] = 1;
|
||||
}
|
||||
|
||||
for (; i <= 63 + e - 2; ++i) {
|
||||
v[i] = 0;
|
||||
|
||||
for (it = 1; it <= m; ++it) {
|
||||
v[i] ^= v[i - it] & b[it];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// copy calculated v to cj
|
||||
for (i = 0; i < 63; i++) {
|
||||
cjn[i][d] |= (INT64)v[i + u] << j;
|
||||
}
|
||||
++d;
|
||||
}
|
||||
|
||||
++d;
|
||||
}
|
||||
|
||||
delete[] polynomials;
|
||||
delete[] polynomials;
|
||||
}
|
||||
|
||||
// Generate 63-bit quasirandom number for given index and dimension and
|
||||
// normalize
|
||||
extern "C" double getQuasirandomValue63(INT64 i, int dim) {
|
||||
const double INT63_SCALE = (1.0 / (double)0x8000000000000001ULL);
|
||||
INT64 result = 0;
|
||||
extern "C" double getQuasirandomValue63(INT64 i, int dim)
|
||||
{
|
||||
const double INT63_SCALE = (1.0 / (double)0x8000000000000001ULL);
|
||||
INT64 result = 0;
|
||||
|
||||
for (int bit = 0; bit < 63; bit++, i >>= 1)
|
||||
if (i & 1) result ^= cjn[bit][dim];
|
||||
for (int bit = 0; bit < 63; bit++, i >>= 1)
|
||||
if (i & 1)
|
||||
result ^= cjn[bit][dim];
|
||||
|
||||
return (double)(result + 1) * INT63_SCALE;
|
||||
return (double)(result + 1) * INT63_SCALE;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Initialization (table setup)
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
extern "C" void initQuasirandomGenerator(
|
||||
unsigned int table[QRNG_DIMENSIONS][QRNG_RESOLUTION]) {
|
||||
GenerateCJ();
|
||||
extern "C" void initQuasirandomGenerator(unsigned int table[QRNG_DIMENSIONS][QRNG_RESOLUTION])
|
||||
{
|
||||
GenerateCJ();
|
||||
|
||||
for (int dim = 0; dim < QRNG_DIMENSIONS; dim++)
|
||||
for (int bit = 0; bit < QRNG_RESOLUTION; bit++)
|
||||
table[dim][bit] = (int)((cjn[bit][dim] >> 32) & 0x7FFFFFFF);
|
||||
for (int dim = 0; dim < QRNG_DIMENSIONS; dim++)
|
||||
for (int bit = 0; bit < QRNG_RESOLUTION; bit++)
|
||||
table[dim][bit] = (int)((cjn[bit][dim] >> 32) & 0x7FFFFFFF);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Generate 31-bit quasirandom number for given index and dimension
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
extern "C" float getQuasirandomValue(
|
||||
unsigned int table[QRNG_DIMENSIONS][QRNG_RESOLUTION], int i, int dim) {
|
||||
int result = 0;
|
||||
extern "C" float getQuasirandomValue(unsigned int table[QRNG_DIMENSIONS][QRNG_RESOLUTION], int i, int dim)
|
||||
{
|
||||
int result = 0;
|
||||
|
||||
for (int bit = 0; bit < QRNG_RESOLUTION; bit++, i >>= 1)
|
||||
if (i & 1) result ^= table[dim][bit];
|
||||
for (int bit = 0; bit < QRNG_RESOLUTION; bit++, i >>= 1)
|
||||
if (i & 1)
|
||||
result ^= table[dim][bit];
|
||||
|
||||
return (float)(result + 1) * INT_SCALE;
|
||||
return (float)(result + 1) * INT_SCALE;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Moro's Inverse Cumulative Normal Distribution function approximation
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
extern "C" double MoroInvCNDcpu(unsigned int x) {
|
||||
const double a1 = 2.50662823884;
|
||||
const double a2 = -18.61500062529;
|
||||
const double a3 = 41.39119773534;
|
||||
const double a4 = -25.44106049637;
|
||||
const double b1 = -8.4735109309;
|
||||
const double b2 = 23.08336743743;
|
||||
const double b3 = -21.06224101826;
|
||||
const double b4 = 3.13082909833;
|
||||
const double c1 = 0.337475482272615;
|
||||
const double c2 = 0.976169019091719;
|
||||
const double c3 = 0.160797971491821;
|
||||
const double c4 = 2.76438810333863E-02;
|
||||
const double c5 = 3.8405729373609E-03;
|
||||
const double c6 = 3.951896511919E-04;
|
||||
const double c7 = 3.21767881768E-05;
|
||||
const double c8 = 2.888167364E-07;
|
||||
const double c9 = 3.960315187E-07;
|
||||
extern "C" double MoroInvCNDcpu(unsigned int x)
|
||||
{
|
||||
const double a1 = 2.50662823884;
|
||||
const double a2 = -18.61500062529;
|
||||
const double a3 = 41.39119773534;
|
||||
const double a4 = -25.44106049637;
|
||||
const double b1 = -8.4735109309;
|
||||
const double b2 = 23.08336743743;
|
||||
const double b3 = -21.06224101826;
|
||||
const double b4 = 3.13082909833;
|
||||
const double c1 = 0.337475482272615;
|
||||
const double c2 = 0.976169019091719;
|
||||
const double c3 = 0.160797971491821;
|
||||
const double c4 = 2.76438810333863E-02;
|
||||
const double c5 = 3.8405729373609E-03;
|
||||
const double c6 = 3.951896511919E-04;
|
||||
const double c7 = 3.21767881768E-05;
|
||||
const double c8 = 2.888167364E-07;
|
||||
const double c9 = 3.960315187E-07;
|
||||
|
||||
double z;
|
||||
double z;
|
||||
|
||||
bool negate = false;
|
||||
bool negate = false;
|
||||
|
||||
// Ensure the conversion to floating point will give a value in the
|
||||
// range (0,0.5] by restricting the input to the bottom half of the
|
||||
// input domain. We will later reflect the result if the input was
|
||||
// originally in the top half of the input domain
|
||||
if (x >= 0x80000000UL) {
|
||||
x = 0xffffffffUL - x;
|
||||
negate = true;
|
||||
}
|
||||
// Ensure the conversion to floating point will give a value in the
|
||||
// range (0,0.5] by restricting the input to the bottom half of the
|
||||
// input domain. We will later reflect the result if the input was
|
||||
// originally in the top half of the input domain
|
||||
if (x >= 0x80000000UL) {
|
||||
x = 0xffffffffUL - x;
|
||||
negate = true;
|
||||
}
|
||||
|
||||
// x is now in the range [0,0x80000000) (i.e. [0,0x7fffffff])
|
||||
// Convert to floating point in (0,0.5]
|
||||
const double x1 = 1.0 / static_cast<double>(0xffffffffUL);
|
||||
const double x2 = x1 / 2.0;
|
||||
double p1 = x * x1 + x2;
|
||||
// Convert to floating point in (-0.5,0]
|
||||
double p2 = p1 - 0.5;
|
||||
// x is now in the range [0,0x80000000) (i.e. [0,0x7fffffff])
|
||||
// Convert to floating point in (0,0.5]
|
||||
const double x1 = 1.0 / static_cast<double>(0xffffffffUL);
|
||||
const double x2 = x1 / 2.0;
|
||||
double p1 = x * x1 + x2;
|
||||
// Convert to floating point in (-0.5,0]
|
||||
double p2 = p1 - 0.5;
|
||||
|
||||
// The input to the Moro inversion is p2 which is in the range
|
||||
// (-0.5,0]. This means that our output will be the negative side
|
||||
// of the bell curve (which we will reflect if "negate" is true).
|
||||
// The input to the Moro inversion is p2 which is in the range
|
||||
// (-0.5,0]. This means that our output will be the negative side
|
||||
// of the bell curve (which we will reflect if "negate" is true).
|
||||
|
||||
// Main body of the bell curve for |p| < 0.42
|
||||
if (p2 > -0.42) {
|
||||
z = p2 * p2;
|
||||
z = p2 * (((a4 * z + a3) * z + a2) * z + a1) /
|
||||
((((b4 * z + b3) * z + b2) * z + b1) * z + 1.0);
|
||||
}
|
||||
// Special case (Chebychev) for tail
|
||||
else {
|
||||
z = log(-log(p1));
|
||||
z = -(c1 + z * (c2 + z * (c3 + z * (c4 + z * (c5 + z * (c6 + z *
|
||||
(c7 + z * (c8 + z * c9))))))));
|
||||
}
|
||||
// Main body of the bell curve for |p| < 0.42
|
||||
if (p2 > -0.42) {
|
||||
z = p2 * p2;
|
||||
z = p2 * (((a4 * z + a3) * z + a2) * z + a1) / ((((b4 * z + b3) * z + b2) * z + b1) * z + 1.0);
|
||||
}
|
||||
// Special case (Chebychev) for tail
|
||||
else {
|
||||
z = log(-log(p1));
|
||||
z = -(c1 + z * (c2 + z * (c3 + z * (c4 + z * (c5 + z * (c6 + z * (c7 + z * (c8 + z * c9))))))));
|
||||
}
|
||||
|
||||
// If the original input (x) was in the top half of the range, reflect
|
||||
// to get the positive side of the bell curve
|
||||
return negate ? -z : z;
|
||||
// If the original input (x) was in the top half of the range, reflect
|
||||
// to get the positive side of the bell curve
|
||||
return negate ? -z : z;
|
||||
}
|
||||
|
||||
@@ -28,9 +28,10 @@
|
||||
#ifndef QUASIRANDOMGENERATOR_KERNEL_CUH
|
||||
#define QUASIRANDOMGENERATOR_KERNEL_CUH
|
||||
|
||||
#include <helper_cuda.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <helper_cuda.h>
|
||||
|
||||
#include "quasirandomGenerator_common.h"
|
||||
|
||||
// Fast integer multiplication
|
||||
@@ -41,138 +42,134 @@
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
static __constant__ unsigned int c_Table[QRNG_DIMENSIONS][QRNG_RESOLUTION];
|
||||
|
||||
static __global__ void quasirandomGeneratorKernel(float *d_Output,
|
||||
unsigned int seed,
|
||||
unsigned int N) {
|
||||
unsigned int *dimBase = &c_Table[threadIdx.y][0];
|
||||
unsigned int tid = MUL(blockDim.x, blockIdx.x) + threadIdx.x;
|
||||
unsigned int threadN = MUL(blockDim.x, gridDim.x);
|
||||
static __global__ void quasirandomGeneratorKernel(float *d_Output, unsigned int seed, unsigned int N)
|
||||
{
|
||||
unsigned int *dimBase = &c_Table[threadIdx.y][0];
|
||||
unsigned int tid = MUL(blockDim.x, blockIdx.x) + threadIdx.x;
|
||||
unsigned int threadN = MUL(blockDim.x, gridDim.x);
|
||||
|
||||
for (unsigned int pos = tid; pos < N; pos += threadN) {
|
||||
unsigned int result = 0;
|
||||
unsigned int data = seed + pos;
|
||||
for (unsigned int pos = tid; pos < N; pos += threadN) {
|
||||
unsigned int result = 0;
|
||||
unsigned int data = seed + pos;
|
||||
|
||||
for (int bit = 0; bit < QRNG_RESOLUTION; bit++, data >>= 1)
|
||||
if (data & 1) {
|
||||
result ^= dimBase[bit];
|
||||
}
|
||||
for (int bit = 0; bit < QRNG_RESOLUTION; bit++, data >>= 1)
|
||||
if (data & 1) {
|
||||
result ^= dimBase[bit];
|
||||
}
|
||||
|
||||
d_Output[MUL(threadIdx.y, N) + pos] = (float)(result + 1) * INT_SCALE;
|
||||
}
|
||||
d_Output[MUL(threadIdx.y, N) + pos] = (float)(result + 1) * INT_SCALE;
|
||||
}
|
||||
}
|
||||
|
||||
// Table initialization routine
|
||||
extern "C" void initTableGPU(
|
||||
unsigned int tableCPU[QRNG_DIMENSIONS][QRNG_RESOLUTION]) {
|
||||
checkCudaErrors(cudaMemcpyToSymbol(
|
||||
c_Table, tableCPU,
|
||||
QRNG_DIMENSIONS * QRNG_RESOLUTION * sizeof(unsigned int)));
|
||||
extern "C" void initTableGPU(unsigned int tableCPU[QRNG_DIMENSIONS][QRNG_RESOLUTION])
|
||||
{
|
||||
checkCudaErrors(cudaMemcpyToSymbol(c_Table, tableCPU, QRNG_DIMENSIONS * QRNG_RESOLUTION * sizeof(unsigned int)));
|
||||
}
|
||||
|
||||
// Host-side interface
|
||||
extern "C" void quasirandomGeneratorGPU(float *d_Output, unsigned int seed,
|
||||
unsigned int N) {
|
||||
dim3 threads(128, QRNG_DIMENSIONS);
|
||||
quasirandomGeneratorKernel<<<128, threads>>>(d_Output, seed, N);
|
||||
getLastCudaError("quasirandomGeneratorKernel() execution failed.\n");
|
||||
extern "C" void quasirandomGeneratorGPU(float *d_Output, unsigned int seed, unsigned int N)
|
||||
{
|
||||
dim3 threads(128, QRNG_DIMENSIONS);
|
||||
quasirandomGeneratorKernel<<<128, threads>>>(d_Output, seed, N);
|
||||
getLastCudaError("quasirandomGeneratorKernel() execution failed.\n");
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Moro's Inverse Cumulative Normal Distribution function approximation
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
__device__ inline float MoroInvCNDgpu(unsigned int x) {
|
||||
const float a1 = 2.50662823884f;
|
||||
const float a2 = -18.61500062529f;
|
||||
const float a3 = 41.39119773534f;
|
||||
const float a4 = -25.44106049637f;
|
||||
const float b1 = -8.4735109309f;
|
||||
const float b2 = 23.08336743743f;
|
||||
const float b3 = -21.06224101826f;
|
||||
const float b4 = 3.13082909833f;
|
||||
const float c1 = 0.337475482272615f;
|
||||
const float c2 = 0.976169019091719f;
|
||||
const float c3 = 0.160797971491821f;
|
||||
const float c4 = 2.76438810333863E-02f;
|
||||
const float c5 = 3.8405729373609E-03f;
|
||||
const float c6 = 3.951896511919E-04f;
|
||||
const float c7 = 3.21767881768E-05f;
|
||||
const float c8 = 2.888167364E-07f;
|
||||
const float c9 = 3.960315187E-07f;
|
||||
__device__ inline float MoroInvCNDgpu(unsigned int x)
|
||||
{
|
||||
const float a1 = 2.50662823884f;
|
||||
const float a2 = -18.61500062529f;
|
||||
const float a3 = 41.39119773534f;
|
||||
const float a4 = -25.44106049637f;
|
||||
const float b1 = -8.4735109309f;
|
||||
const float b2 = 23.08336743743f;
|
||||
const float b3 = -21.06224101826f;
|
||||
const float b4 = 3.13082909833f;
|
||||
const float c1 = 0.337475482272615f;
|
||||
const float c2 = 0.976169019091719f;
|
||||
const float c3 = 0.160797971491821f;
|
||||
const float c4 = 2.76438810333863E-02f;
|
||||
const float c5 = 3.8405729373609E-03f;
|
||||
const float c6 = 3.951896511919E-04f;
|
||||
const float c7 = 3.21767881768E-05f;
|
||||
const float c8 = 2.888167364E-07f;
|
||||
const float c9 = 3.960315187E-07f;
|
||||
|
||||
float z;
|
||||
float z;
|
||||
|
||||
bool negate = false;
|
||||
bool negate = false;
|
||||
|
||||
// Ensure the conversion to floating point will give a value in the
|
||||
// range (0,0.5] by restricting the input to the bottom half of the
|
||||
// input domain. We will later reflect the result if the input was
|
||||
// originally in the top half of the input domain
|
||||
if (x >= 0x80000000UL) {
|
||||
x = 0xffffffffUL - x;
|
||||
negate = true;
|
||||
}
|
||||
// Ensure the conversion to floating point will give a value in the
|
||||
// range (0,0.5] by restricting the input to the bottom half of the
|
||||
// input domain. We will later reflect the result if the input was
|
||||
// originally in the top half of the input domain
|
||||
if (x >= 0x80000000UL) {
|
||||
x = 0xffffffffUL - x;
|
||||
negate = true;
|
||||
}
|
||||
|
||||
// x is now in the range [0,0x80000000) (i.e. [0,0x7fffffff])
|
||||
// Convert to floating point in (0,0.5]
|
||||
const float x1 = 1.0f / static_cast<float>(0xffffffffUL);
|
||||
const float x2 = x1 / 2.0f;
|
||||
float p1 = x * x1 + x2;
|
||||
// Convert to floating point in (-0.5,0]
|
||||
float p2 = p1 - 0.5f;
|
||||
// x is now in the range [0,0x80000000) (i.e. [0,0x7fffffff])
|
||||
// Convert to floating point in (0,0.5]
|
||||
const float x1 = 1.0f / static_cast<float>(0xffffffffUL);
|
||||
const float x2 = x1 / 2.0f;
|
||||
float p1 = x * x1 + x2;
|
||||
// Convert to floating point in (-0.5,0]
|
||||
float p2 = p1 - 0.5f;
|
||||
|
||||
// The input to the Moro inversion is p2 which is in the range
|
||||
// (-0.5,0]. This means that our output will be the negative side
|
||||
// of the bell curve (which we will reflect if "negate" is true).
|
||||
// The input to the Moro inversion is p2 which is in the range
|
||||
// (-0.5,0]. This means that our output will be the negative side
|
||||
// of the bell curve (which we will reflect if "negate" is true).
|
||||
|
||||
// Main body of the bell curve for |p| < 0.42
|
||||
if (p2 > -0.42f) {
|
||||
z = p2 * p2;
|
||||
z = p2 * (((a4 * z + a3) * z + a2) * z + a1) /
|
||||
((((b4 * z + b3) * z + b2) * z + b1) * z + 1.0f);
|
||||
}
|
||||
// Special case (Chebychev) for tail
|
||||
else {
|
||||
z = __logf(-__logf(p1));
|
||||
z = -(c1 + z * (c2 + z * (c3 + z * (c4 + z * (c5 + z * (c6 + z * (c7 + z
|
||||
* (c8 + z * c9))))))));
|
||||
}
|
||||
// Main body of the bell curve for |p| < 0.42
|
||||
if (p2 > -0.42f) {
|
||||
z = p2 * p2;
|
||||
z = p2 * (((a4 * z + a3) * z + a2) * z + a1) / ((((b4 * z + b3) * z + b2) * z + b1) * z + 1.0f);
|
||||
}
|
||||
// Special case (Chebychev) for tail
|
||||
else {
|
||||
z = __logf(-__logf(p1));
|
||||
z = -(c1 + z * (c2 + z * (c3 + z * (c4 + z * (c5 + z * (c6 + z * (c7 + z * (c8 + z * c9))))))));
|
||||
}
|
||||
|
||||
// If the original input (x) was in the top half of the range, reflect
|
||||
// to get the positive side of the bell curve
|
||||
return negate ? -z : z;
|
||||
// If the original input (x) was in the top half of the range, reflect
|
||||
// to get the positive side of the bell curve
|
||||
return negate ? -z : z;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Main kernel. Choose between transforming
|
||||
// input sequence and uniform ascending (0, 1) sequence
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
static __global__ void inverseCNDKernel(float *d_Output, unsigned int *d_Input,
|
||||
unsigned int pathN) {
|
||||
unsigned int distance = ((unsigned int)-1) / (pathN + 1);
|
||||
unsigned int tid = MUL(blockDim.x, blockIdx.x) + threadIdx.x;
|
||||
unsigned int threadN = MUL(blockDim.x, gridDim.x);
|
||||
static __global__ void inverseCNDKernel(float *d_Output, unsigned int *d_Input, unsigned int pathN)
|
||||
{
|
||||
unsigned int distance = ((unsigned int)-1) / (pathN + 1);
|
||||
unsigned int tid = MUL(blockDim.x, blockIdx.x) + threadIdx.x;
|
||||
unsigned int threadN = MUL(blockDim.x, gridDim.x);
|
||||
|
||||
// Transform input number sequence if it's supplied
|
||||
if (d_Input) {
|
||||
for (unsigned int pos = tid; pos < pathN; pos += threadN) {
|
||||
unsigned int d = d_Input[pos];
|
||||
d_Output[pos] = (float)MoroInvCNDgpu(d);
|
||||
// Transform input number sequence if it's supplied
|
||||
if (d_Input) {
|
||||
for (unsigned int pos = tid; pos < pathN; pos += threadN) {
|
||||
unsigned int d = d_Input[pos];
|
||||
d_Output[pos] = (float)MoroInvCNDgpu(d);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Else generate input uniformly placed samples on the fly
|
||||
// and write to destination
|
||||
else {
|
||||
for (unsigned int pos = tid; pos < pathN; pos += threadN) {
|
||||
unsigned int d = (pos + 1) * distance;
|
||||
d_Output[pos] = (float)MoroInvCNDgpu(d);
|
||||
// Else generate input uniformly placed samples on the fly
|
||||
// and write to destination
|
||||
else {
|
||||
for (unsigned int pos = tid; pos < pathN; pos += threadN) {
|
||||
unsigned int d = (pos + 1) * distance;
|
||||
d_Output[pos] = (float)MoroInvCNDgpu(d);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extern "C" void inverseCNDgpu(float *d_Output, unsigned int *d_Input,
|
||||
unsigned int N) {
|
||||
inverseCNDKernel<<<128, 128>>>(d_Output, d_Input, N);
|
||||
getLastCudaError("inverseCNDKernel() execution failed.\n");
|
||||
extern "C" void inverseCNDgpu(float *d_Output, unsigned int *d_Input, unsigned int N)
|
||||
{
|
||||
inverseCNDKernel<<<128, 128>>>(d_Output, d_Input, N);
|
||||
getLastCudaError("inverseCNDKernel() execution failed.\n");
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user