mirror of
https://github.com/NVIDIA/cuda-samples.git
synced 2026-10-26 06:38:16 +08:00
Apply consistent code formatting across the repo. Add clang-format and pre-commit hooks.
This commit is contained in:
Rob Armstrong
@@ -32,18 +32,21 @@
|
||||
*/
|
||||
|
||||
#include <cuda_runtime.h>
|
||||
#include <helper_functions.h> // helper functions for string parsing
|
||||
#include <nvrtc_helper.h>
|
||||
|
||||
#include <helper_functions.h> // helper functions for string parsing
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Process an array of optN options on CPU
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
extern "C" void BlackScholesCPU(float *h_CallResult, float *h_PutResult,
|
||||
float *h_StockPrice, float *h_OptionStrike,
|
||||
float *h_OptionYears, float Riskfree,
|
||||
float Volatility, int optN);
|
||||
extern "C" void BlackScholesCPU(float *h_CallResult,
|
||||
float *h_PutResult,
|
||||
float *h_StockPrice,
|
||||
float *h_OptionStrike,
|
||||
float *h_OptionYears,
|
||||
float Riskfree,
|
||||
float Volatility,
|
||||
int optN);
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Process an array of OptN options on GPU
|
||||
@@ -54,216 +57,225 @@ extern "C" void BlackScholesCPU(float *h_CallResult, float *h_PutResult,
|
||||
// random float in [low, high] range
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
float RandFloat(float low, float high) {
|
||||
float t = (float)rand() / (float)RAND_MAX;
|
||||
return (1.0f - t) * low + t * high;
|
||||
float RandFloat(float low, float high)
|
||||
{
|
||||
float t = (float)rand() / (float)RAND_MAX;
|
||||
return (1.0f - t) * low + t * high;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Data configuration
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
const int OPT_N = 4000000;
|
||||
const int NUM_ITERATIONS = 512;
|
||||
const int OPT_SZ = OPT_N * sizeof(float);
|
||||
const float RISKFREE = 0.02f;
|
||||
const float VOLATILITY = 0.30f;
|
||||
const int OPT_N = 4000000;
|
||||
const int NUM_ITERATIONS = 512;
|
||||
const int OPT_SZ = OPT_N * sizeof(float);
|
||||
const float RISKFREE = 0.02f;
|
||||
const float VOLATILITY = 0.30f;
|
||||
|
||||
#define DIV_UP(a, b) (((a) + (b)-1) / (b))
|
||||
#define DIV_UP(a, b) (((a) + (b) - 1) / (b))
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Main program
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
// Start logs
|
||||
printf("[%s] - Starting...\n", argv[0]);
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
// Start logs
|
||||
printf("[%s] - Starting...\n", argv[0]);
|
||||
|
||||
//'h_' prefix - CPU (host) memory space
|
||||
float
|
||||
// Results calculated by CPU for reference
|
||||
*h_CallResultCPU,
|
||||
*h_PutResultCPU,
|
||||
// CPU copy of GPU results
|
||||
*h_CallResultGPU, *h_PutResultGPU,
|
||||
// CPU instance of input data
|
||||
*h_StockPrice, *h_OptionStrike, *h_OptionYears;
|
||||
//'h_' prefix - CPU (host) memory space
|
||||
float
|
||||
// Results calculated by CPU for reference
|
||||
*h_CallResultCPU,
|
||||
*h_PutResultCPU,
|
||||
// CPU copy of GPU results
|
||||
*h_CallResultGPU, *h_PutResultGPU,
|
||||
// CPU instance of input data
|
||||
*h_StockPrice, *h_OptionStrike, *h_OptionYears;
|
||||
|
||||
//'d_' prefix - GPU (device) memory space
|
||||
CUdeviceptr
|
||||
// Results calculated by GPU
|
||||
d_CallResult,
|
||||
d_PutResult,
|
||||
//'d_' prefix - GPU (device) memory space
|
||||
CUdeviceptr
|
||||
// Results calculated by GPU
|
||||
d_CallResult,
|
||||
d_PutResult,
|
||||
|
||||
// GPU instance of input data
|
||||
d_StockPrice, d_OptionStrike, d_OptionYears;
|
||||
// GPU instance of input data
|
||||
d_StockPrice, d_OptionStrike, d_OptionYears;
|
||||
|
||||
double delta, ref, sum_delta, sum_ref, max_delta, L1norm, gpuTime;
|
||||
double delta, ref, sum_delta, sum_ref, max_delta, L1norm, gpuTime;
|
||||
|
||||
StopWatchInterface *hTimer = NULL;
|
||||
int i;
|
||||
StopWatchInterface *hTimer = NULL;
|
||||
int i;
|
||||
|
||||
sdkCreateTimer(&hTimer);
|
||||
sdkCreateTimer(&hTimer);
|
||||
|
||||
printf("Initializing data...\n");
|
||||
printf("...allocating CPU memory for options.\n");
|
||||
printf("Initializing data...\n");
|
||||
printf("...allocating CPU memory for options.\n");
|
||||
|
||||
h_CallResultCPU = (float *)malloc(OPT_SZ);
|
||||
h_PutResultCPU = (float *)malloc(OPT_SZ);
|
||||
h_CallResultGPU = (float *)malloc(OPT_SZ);
|
||||
h_PutResultGPU = (float *)malloc(OPT_SZ);
|
||||
h_StockPrice = (float *)malloc(OPT_SZ);
|
||||
h_OptionStrike = (float *)malloc(OPT_SZ);
|
||||
h_OptionYears = (float *)malloc(OPT_SZ);
|
||||
h_CallResultCPU = (float *)malloc(OPT_SZ);
|
||||
h_PutResultCPU = (float *)malloc(OPT_SZ);
|
||||
h_CallResultGPU = (float *)malloc(OPT_SZ);
|
||||
h_PutResultGPU = (float *)malloc(OPT_SZ);
|
||||
h_StockPrice = (float *)malloc(OPT_SZ);
|
||||
h_OptionStrike = (float *)malloc(OPT_SZ);
|
||||
h_OptionYears = (float *)malloc(OPT_SZ);
|
||||
|
||||
char *cubin, *kernel_file;
|
||||
size_t cubinSize;
|
||||
kernel_file = sdkFindFilePath("BlackScholes_kernel.cuh", argv[0]);
|
||||
char *cubin, *kernel_file;
|
||||
size_t cubinSize;
|
||||
kernel_file = sdkFindFilePath("BlackScholes_kernel.cuh", argv[0]);
|
||||
|
||||
// Compile the kernel BlackScholes_kernel.
|
||||
compileFileToCUBIN(kernel_file, argc, argv, &cubin, &cubinSize, 0);
|
||||
CUmodule module = loadCUBIN(cubin, argc, argv);
|
||||
// Compile the kernel BlackScholes_kernel.
|
||||
compileFileToCUBIN(kernel_file, argc, argv, &cubin, &cubinSize, 0);
|
||||
CUmodule module = loadCUBIN(cubin, argc, argv);
|
||||
|
||||
CUfunction kernel_addr;
|
||||
checkCudaErrors(cuModuleGetFunction(&kernel_addr, module, "BlackScholesGPU"));
|
||||
CUfunction kernel_addr;
|
||||
checkCudaErrors(cuModuleGetFunction(&kernel_addr, module, "BlackScholesGPU"));
|
||||
|
||||
printf("...allocating GPU memory for options.\n");
|
||||
checkCudaErrors(cuMemAlloc(&d_CallResult, OPT_SZ));
|
||||
checkCudaErrors(cuMemAlloc(&d_PutResult, OPT_SZ));
|
||||
checkCudaErrors(cuMemAlloc(&d_StockPrice, OPT_SZ));
|
||||
checkCudaErrors(cuMemAlloc(&d_OptionStrike, OPT_SZ));
|
||||
checkCudaErrors(cuMemAlloc(&d_OptionYears, OPT_SZ));
|
||||
printf("...allocating GPU memory for options.\n");
|
||||
checkCudaErrors(cuMemAlloc(&d_CallResult, OPT_SZ));
|
||||
checkCudaErrors(cuMemAlloc(&d_PutResult, OPT_SZ));
|
||||
checkCudaErrors(cuMemAlloc(&d_StockPrice, OPT_SZ));
|
||||
checkCudaErrors(cuMemAlloc(&d_OptionStrike, OPT_SZ));
|
||||
checkCudaErrors(cuMemAlloc(&d_OptionYears, OPT_SZ));
|
||||
|
||||
printf("...generating input data in CPU mem.\n");
|
||||
srand(5347);
|
||||
printf("...generating input data in CPU mem.\n");
|
||||
srand(5347);
|
||||
|
||||
// Generate options set
|
||||
for (i = 0; i < OPT_N; i++) {
|
||||
h_CallResultCPU[i] = 0.0f;
|
||||
h_PutResultCPU[i] = -1.0f;
|
||||
h_StockPrice[i] = RandFloat(5.0f, 30.0f);
|
||||
h_OptionStrike[i] = RandFloat(1.0f, 100.0f);
|
||||
h_OptionYears[i] = RandFloat(0.25f, 10.0f);
|
||||
}
|
||||
|
||||
printf("...copying input data to GPU mem.\n");
|
||||
// Copy options data to GPU memory for further processing
|
||||
checkCudaErrors(cuMemcpyHtoD(d_StockPrice, h_StockPrice, OPT_SZ));
|
||||
checkCudaErrors(cuMemcpyHtoD(d_OptionStrike, h_OptionStrike, OPT_SZ));
|
||||
checkCudaErrors(cuMemcpyHtoD(d_OptionYears, h_OptionYears, OPT_SZ));
|
||||
|
||||
printf("Data init done.\n\n");
|
||||
printf("Executing Black-Scholes GPU kernel (%i iterations)...\n",
|
||||
NUM_ITERATIONS);
|
||||
|
||||
sdkResetTimer(&hTimer);
|
||||
sdkStartTimer(&hTimer);
|
||||
|
||||
dim3 cudaBlockSize(128, 1, 1);
|
||||
dim3 cudaGridSize(DIV_UP(OPT_N / 2, 128), 1, 1);
|
||||
|
||||
float risk = RISKFREE;
|
||||
float volatility = VOLATILITY;
|
||||
int optval = OPT_N;
|
||||
|
||||
void *arr[] = {(void *)&d_CallResult, (void *)&d_PutResult,
|
||||
(void *)&d_StockPrice, (void *)&d_OptionStrike,
|
||||
(void *)&d_OptionYears, (void *)&risk,
|
||||
(void *)&volatility, (void *)&optval};
|
||||
|
||||
for (i = 0; i < NUM_ITERATIONS; i++) {
|
||||
checkCudaErrors(cuLaunchKernel(kernel_addr, cudaGridSize.x, cudaGridSize.y,
|
||||
cudaGridSize.z, /* grid dim */
|
||||
cudaBlockSize.x, cudaBlockSize.y,
|
||||
cudaBlockSize.z, /* block dim */
|
||||
0, 0, /* shared mem, stream */
|
||||
&arr[0], /* arguments */
|
||||
0));
|
||||
}
|
||||
|
||||
checkCudaErrors(cuCtxSynchronize());
|
||||
|
||||
sdkStopTimer(&hTimer);
|
||||
gpuTime = sdkGetTimerValue(&hTimer) / NUM_ITERATIONS;
|
||||
|
||||
// Both call and put is calculated
|
||||
printf("Options count : %i \n", 2 * OPT_N);
|
||||
printf("BlackScholesGPU() time : %f msec\n", gpuTime);
|
||||
printf("Effective memory bandwidth: %f GB/s\n",
|
||||
((double)(5 * OPT_N * sizeof(float)) * 1E-9) / (gpuTime * 1E-3));
|
||||
printf("Gigaoptions per second : %f \n\n",
|
||||
((double)(2 * OPT_N) * 1E-9) / (gpuTime * 1E-3));
|
||||
printf(
|
||||
"BlackScholes, Throughput = %.4f GOptions/s, Time = %.5f s, Size = %u "
|
||||
"options, NumDevsUsed = %u, Workgroup = %u\n",
|
||||
(((double)(2.0 * OPT_N) * 1.0E-9) / (gpuTime * 1.0E-3)), gpuTime * 1e-3,
|
||||
(2 * OPT_N), 1, 128);
|
||||
|
||||
printf("\nReading back GPU results...\n");
|
||||
|
||||
// Read back GPU results to compare them to CPU results
|
||||
checkCudaErrors(cuMemcpyDtoH(h_CallResultGPU, d_CallResult, OPT_SZ));
|
||||
checkCudaErrors(cuMemcpyDtoH(h_PutResultGPU, d_PutResult, OPT_SZ));
|
||||
|
||||
printf("Checking the results...\n");
|
||||
printf("...running CPU calculations.\n\n");
|
||||
|
||||
// Calculate options values on CPU
|
||||
BlackScholesCPU(h_CallResultCPU, h_PutResultCPU, h_StockPrice, h_OptionStrike,
|
||||
h_OptionYears, RISKFREE, VOLATILITY, OPT_N);
|
||||
|
||||
printf("Comparing the results...\n");
|
||||
// Calculate max absolute difference and L1 distance
|
||||
// between CPU and GPU results
|
||||
sum_delta = 0;
|
||||
sum_ref = 0;
|
||||
max_delta = 0;
|
||||
|
||||
for (i = 0; i < OPT_N; i++) {
|
||||
ref = h_CallResultCPU[i];
|
||||
delta = fabs(h_CallResultCPU[i] - h_CallResultGPU[i]);
|
||||
|
||||
if (delta > max_delta) {
|
||||
max_delta = delta;
|
||||
// Generate options set
|
||||
for (i = 0; i < OPT_N; i++) {
|
||||
h_CallResultCPU[i] = 0.0f;
|
||||
h_PutResultCPU[i] = -1.0f;
|
||||
h_StockPrice[i] = RandFloat(5.0f, 30.0f);
|
||||
h_OptionStrike[i] = RandFloat(1.0f, 100.0f);
|
||||
h_OptionYears[i] = RandFloat(0.25f, 10.0f);
|
||||
}
|
||||
|
||||
sum_delta += delta;
|
||||
sum_ref += fabs(ref);
|
||||
}
|
||||
printf("...copying input data to GPU mem.\n");
|
||||
// Copy options data to GPU memory for further processing
|
||||
checkCudaErrors(cuMemcpyHtoD(d_StockPrice, h_StockPrice, OPT_SZ));
|
||||
checkCudaErrors(cuMemcpyHtoD(d_OptionStrike, h_OptionStrike, OPT_SZ));
|
||||
checkCudaErrors(cuMemcpyHtoD(d_OptionYears, h_OptionYears, OPT_SZ));
|
||||
|
||||
L1norm = sum_delta / sum_ref;
|
||||
printf("L1 norm: %E\n", L1norm);
|
||||
printf("Max absolute error: %E\n\n", max_delta);
|
||||
printf("Data init done.\n\n");
|
||||
printf("Executing Black-Scholes GPU kernel (%i iterations)...\n", NUM_ITERATIONS);
|
||||
|
||||
printf("Shutting down...\n");
|
||||
printf("...releasing GPU memory.\n");
|
||||
sdkResetTimer(&hTimer);
|
||||
sdkStartTimer(&hTimer);
|
||||
|
||||
checkCudaErrors(cuMemFree(d_OptionYears));
|
||||
checkCudaErrors(cuMemFree(d_OptionStrike));
|
||||
checkCudaErrors(cuMemFree(d_StockPrice));
|
||||
checkCudaErrors(cuMemFree(d_PutResult));
|
||||
checkCudaErrors(cuMemFree(d_CallResult));
|
||||
dim3 cudaBlockSize(128, 1, 1);
|
||||
dim3 cudaGridSize(DIV_UP(OPT_N / 2, 128), 1, 1);
|
||||
|
||||
printf("...releasing CPU memory.\n");
|
||||
float risk = RISKFREE;
|
||||
float volatility = VOLATILITY;
|
||||
int optval = OPT_N;
|
||||
|
||||
free(h_OptionYears);
|
||||
free(h_OptionStrike);
|
||||
free(h_StockPrice);
|
||||
free(h_PutResultGPU);
|
||||
free(h_CallResultGPU);
|
||||
free(h_PutResultCPU);
|
||||
free(h_CallResultCPU);
|
||||
void *arr[] = {(void *)&d_CallResult,
|
||||
(void *)&d_PutResult,
|
||||
(void *)&d_StockPrice,
|
||||
(void *)&d_OptionStrike,
|
||||
(void *)&d_OptionYears,
|
||||
(void *)&risk,
|
||||
(void *)&volatility,
|
||||
(void *)&optval};
|
||||
|
||||
sdkDeleteTimer(&hTimer);
|
||||
printf("Shutdown done.\n");
|
||||
for (i = 0; i < NUM_ITERATIONS; i++) {
|
||||
checkCudaErrors(cuLaunchKernel(kernel_addr,
|
||||
cudaGridSize.x,
|
||||
cudaGridSize.y,
|
||||
cudaGridSize.z, /* grid dim */
|
||||
cudaBlockSize.x,
|
||||
cudaBlockSize.y,
|
||||
cudaBlockSize.z, /* block dim */
|
||||
0,
|
||||
0, /* shared mem, stream */
|
||||
&arr[0], /* arguments */
|
||||
0));
|
||||
}
|
||||
|
||||
printf("\n[%s] - Test Summary\n", argv[0]);
|
||||
checkCudaErrors(cuCtxSynchronize());
|
||||
|
||||
if (L1norm > 1e-6) {
|
||||
printf("Test failed!\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
sdkStopTimer(&hTimer);
|
||||
gpuTime = sdkGetTimerValue(&hTimer) / NUM_ITERATIONS;
|
||||
|
||||
printf("Test passed\n");
|
||||
exit(EXIT_SUCCESS);
|
||||
// Both call and put is calculated
|
||||
printf("Options count : %i \n", 2 * OPT_N);
|
||||
printf("BlackScholesGPU() time : %f msec\n", gpuTime);
|
||||
printf("Effective memory bandwidth: %f GB/s\n", ((double)(5 * OPT_N * sizeof(float)) * 1E-9) / (gpuTime * 1E-3));
|
||||
printf("Gigaoptions per second : %f \n\n", ((double)(2 * OPT_N) * 1E-9) / (gpuTime * 1E-3));
|
||||
printf("BlackScholes, Throughput = %.4f GOptions/s, Time = %.5f s, Size = %u "
|
||||
"options, NumDevsUsed = %u, Workgroup = %u\n",
|
||||
(((double)(2.0 * OPT_N) * 1.0E-9) / (gpuTime * 1.0E-3)),
|
||||
gpuTime * 1e-3,
|
||||
(2 * OPT_N),
|
||||
1,
|
||||
128);
|
||||
|
||||
printf("\nReading back GPU results...\n");
|
||||
|
||||
// Read back GPU results to compare them to CPU results
|
||||
checkCudaErrors(cuMemcpyDtoH(h_CallResultGPU, d_CallResult, OPT_SZ));
|
||||
checkCudaErrors(cuMemcpyDtoH(h_PutResultGPU, d_PutResult, OPT_SZ));
|
||||
|
||||
printf("Checking the results...\n");
|
||||
printf("...running CPU calculations.\n\n");
|
||||
|
||||
// Calculate options values on CPU
|
||||
BlackScholesCPU(
|
||||
h_CallResultCPU, h_PutResultCPU, h_StockPrice, h_OptionStrike, h_OptionYears, RISKFREE, VOLATILITY, OPT_N);
|
||||
|
||||
printf("Comparing the results...\n");
|
||||
// Calculate max absolute difference and L1 distance
|
||||
// between CPU and GPU results
|
||||
sum_delta = 0;
|
||||
sum_ref = 0;
|
||||
max_delta = 0;
|
||||
|
||||
for (i = 0; i < OPT_N; i++) {
|
||||
ref = h_CallResultCPU[i];
|
||||
delta = fabs(h_CallResultCPU[i] - h_CallResultGPU[i]);
|
||||
|
||||
if (delta > max_delta) {
|
||||
max_delta = delta;
|
||||
}
|
||||
|
||||
sum_delta += delta;
|
||||
sum_ref += fabs(ref);
|
||||
}
|
||||
|
||||
L1norm = sum_delta / sum_ref;
|
||||
printf("L1 norm: %E\n", L1norm);
|
||||
printf("Max absolute error: %E\n\n", max_delta);
|
||||
|
||||
printf("Shutting down...\n");
|
||||
printf("...releasing GPU memory.\n");
|
||||
|
||||
checkCudaErrors(cuMemFree(d_OptionYears));
|
||||
checkCudaErrors(cuMemFree(d_OptionStrike));
|
||||
checkCudaErrors(cuMemFree(d_StockPrice));
|
||||
checkCudaErrors(cuMemFree(d_PutResult));
|
||||
checkCudaErrors(cuMemFree(d_CallResult));
|
||||
|
||||
printf("...releasing CPU memory.\n");
|
||||
|
||||
free(h_OptionYears);
|
||||
free(h_OptionStrike);
|
||||
free(h_StockPrice);
|
||||
free(h_PutResultGPU);
|
||||
free(h_CallResultGPU);
|
||||
free(h_PutResultCPU);
|
||||
free(h_CallResultCPU);
|
||||
|
||||
sdkDeleteTimer(&hTimer);
|
||||
printf("Shutdown done.\n");
|
||||
|
||||
printf("\n[%s] - Test Summary\n", argv[0]);
|
||||
|
||||
if (L1norm > 1e-6) {
|
||||
printf("Test failed!\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
printf("Test passed\n");
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
@@ -31,58 +31,70 @@
|
||||
// Polynomial approximation of cumulative normal distribution function
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
static double CND(double d) {
|
||||
const double A1 = 0.31938153;
|
||||
const double A2 = -0.356563782;
|
||||
const double A3 = 1.781477937;
|
||||
const double A4 = -1.821255978;
|
||||
const double A5 = 1.330274429;
|
||||
const double RSQRT2PI = 0.39894228040143267793994605993438;
|
||||
static double CND(double d)
|
||||
{
|
||||
const double A1 = 0.31938153;
|
||||
const double A2 = -0.356563782;
|
||||
const double A3 = 1.781477937;
|
||||
const double A4 = -1.821255978;
|
||||
const double A5 = 1.330274429;
|
||||
const double RSQRT2PI = 0.39894228040143267793994605993438;
|
||||
|
||||
double K = 1.0 / (1.0 + 0.2316419 * fabs(d));
|
||||
double K = 1.0 / (1.0 + 0.2316419 * fabs(d));
|
||||
|
||||
double cnd = RSQRT2PI * exp(-0.5 * d * d) *
|
||||
(K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5)))));
|
||||
double cnd = RSQRT2PI * exp(-0.5 * d * d) * (K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5)))));
|
||||
|
||||
if (d > 0) cnd = 1.0 - cnd;
|
||||
if (d > 0)
|
||||
cnd = 1.0 - cnd;
|
||||
|
||||
return cnd;
|
||||
return cnd;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Black-Scholes formula for both call and put
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
static void BlackScholesBodyCPU(float &callResult, float &putResult,
|
||||
float Sf, // Stock price
|
||||
float Xf, // Option strike
|
||||
float Tf, // Option years
|
||||
float Rf, // Riskless rate
|
||||
float Vf // Volatility rate
|
||||
) {
|
||||
double S = Sf, X = Xf, T = Tf, R = Rf, V = Vf;
|
||||
double sqrtT = sqrt(T);
|
||||
double d1 = (log(S / X) + (R + 0.5 * V * V) * T) / (V * sqrtT);
|
||||
double d2 = d1 - V * sqrtT;
|
||||
double CNDD1 = CND(d1);
|
||||
double CNDD2 = CND(d2);
|
||||
static void BlackScholesBodyCPU(float &callResult,
|
||||
float &putResult,
|
||||
float Sf, // Stock price
|
||||
float Xf, // Option strike
|
||||
float Tf, // Option years
|
||||
float Rf, // Riskless rate
|
||||
float Vf // Volatility rate
|
||||
)
|
||||
{
|
||||
double S = Sf, X = Xf, T = Tf, R = Rf, V = Vf;
|
||||
double sqrtT = sqrt(T);
|
||||
double d1 = (log(S / X) + (R + 0.5 * V * V) * T) / (V * sqrtT);
|
||||
double d2 = d1 - V * sqrtT;
|
||||
double CNDD1 = CND(d1);
|
||||
double CNDD2 = CND(d2);
|
||||
|
||||
// Calculate Call and Put simultaneously
|
||||
double expRT = exp(-R * T);
|
||||
// Calculate Call and Put simultaneously
|
||||
double expRT = exp(-R * T);
|
||||
|
||||
callResult = (float)(S * CNDD1 - X * expRT * CNDD2);
|
||||
putResult = (float)(X * expRT * (1.0 - CNDD2) - S * (1.0 - CNDD1));
|
||||
callResult = (float)(S * CNDD1 - X * expRT * CNDD2);
|
||||
putResult = (float)(X * expRT * (1.0 - CNDD2) - S * (1.0 - CNDD1));
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Process an array of optN options
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
extern "C" void BlackScholesCPU(float *h_CallResult, float *h_PutResult,
|
||||
float *h_StockPrice, float *h_OptionStrike,
|
||||
float *h_OptionYears, float Riskfree,
|
||||
float Volatility, int optN) {
|
||||
for (int opt = 0; opt < optN; opt++)
|
||||
BlackScholesBodyCPU(h_CallResult[opt], h_PutResult[opt], h_StockPrice[opt],
|
||||
h_OptionStrike[opt], h_OptionYears[opt], Riskfree,
|
||||
Volatility);
|
||||
extern "C" void BlackScholesCPU(float *h_CallResult,
|
||||
float *h_PutResult,
|
||||
float *h_StockPrice,
|
||||
float *h_OptionStrike,
|
||||
float *h_OptionYears,
|
||||
float Riskfree,
|
||||
float Volatility,
|
||||
int optN)
|
||||
{
|
||||
for (int opt = 0; opt < optN; opt++)
|
||||
BlackScholesBodyCPU(h_CallResult[opt],
|
||||
h_PutResult[opt],
|
||||
h_StockPrice[opt],
|
||||
h_OptionStrike[opt],
|
||||
h_OptionYears[opt],
|
||||
Riskfree,
|
||||
Volatility);
|
||||
}
|
||||
|
||||
@@ -29,75 +29,88 @@
|
||||
// Polynomial approximation of cumulative normal distribution function
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
__device__ inline float cndGPU(float d) {
|
||||
const float A1 = 0.31938153f;
|
||||
const float A2 = -0.356563782f;
|
||||
const float A3 = 1.781477937f;
|
||||
const float A4 = -1.821255978f;
|
||||
const float A5 = 1.330274429f;
|
||||
const float RSQRT2PI = 0.39894228040143267793994605993438f;
|
||||
__device__ inline float cndGPU(float d)
|
||||
{
|
||||
const float A1 = 0.31938153f;
|
||||
const float A2 = -0.356563782f;
|
||||
const float A3 = 1.781477937f;
|
||||
const float A4 = -1.821255978f;
|
||||
const float A5 = 1.330274429f;
|
||||
const float RSQRT2PI = 0.39894228040143267793994605993438f;
|
||||
|
||||
float K = __fdividef(1.0f, (1.0f + 0.2316419f * fabsf(d)));
|
||||
float K = __fdividef(1.0f, (1.0f + 0.2316419f * fabsf(d)));
|
||||
|
||||
float cnd = RSQRT2PI * __expf(-0.5f * d * d) *
|
||||
(K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5)))));
|
||||
float cnd = RSQRT2PI * __expf(-0.5f * d * d) * (K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5)))));
|
||||
|
||||
if (d > 0) cnd = 1.0f - cnd;
|
||||
if (d > 0)
|
||||
cnd = 1.0f - cnd;
|
||||
|
||||
return cnd;
|
||||
return cnd;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Black-Scholes formula for both call and put
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
__device__ inline void BlackScholesBodyGPU(float &CallResult, float &PutResult,
|
||||
float S, // Stock price
|
||||
float X, // Option strike
|
||||
float T, // Option years
|
||||
float R, // Riskless rate
|
||||
float V // Volatility rate
|
||||
) {
|
||||
float sqrtT, expRT;
|
||||
float d1, d2, CNDD1, CNDD2;
|
||||
__device__ inline void BlackScholesBodyGPU(float &CallResult,
|
||||
float &PutResult,
|
||||
float S, // Stock price
|
||||
float X, // Option strike
|
||||
float T, // Option years
|
||||
float R, // Riskless rate
|
||||
float V // Volatility rate
|
||||
)
|
||||
{
|
||||
float sqrtT, expRT;
|
||||
float d1, d2, CNDD1, CNDD2;
|
||||
|
||||
sqrtT = __fdividef(1.0F, rsqrtf(T));
|
||||
d1 = __fdividef(__logf(S / X) + (R + 0.5f * V * V) * T, V * sqrtT);
|
||||
d2 = d1 - V * sqrtT;
|
||||
sqrtT = __fdividef(1.0F, rsqrtf(T));
|
||||
d1 = __fdividef(__logf(S / X) + (R + 0.5f * V * V) * T, V * sqrtT);
|
||||
d2 = d1 - V * sqrtT;
|
||||
|
||||
CNDD1 = cndGPU(d1);
|
||||
CNDD2 = cndGPU(d2);
|
||||
CNDD1 = cndGPU(d1);
|
||||
CNDD2 = cndGPU(d2);
|
||||
|
||||
// Calculate Call and Put simultaneously
|
||||
expRT = __expf(-R * T);
|
||||
CallResult = S * CNDD1 - X * expRT * CNDD2;
|
||||
PutResult = X * expRT * (1.0f - CNDD2) - S * (1.0f - CNDD1);
|
||||
// Calculate Call and Put simultaneously
|
||||
expRT = __expf(-R * T);
|
||||
CallResult = S * CNDD1 - X * expRT * CNDD2;
|
||||
PutResult = X * expRT * (1.0f - CNDD2) - S * (1.0f - CNDD1);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Process an array of optN options on GPU
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
extern "C" __launch_bounds__(128) __global__
|
||||
void BlackScholesGPU(float2 *__restrict d_CallResult,
|
||||
float2 *__restrict d_PutResult,
|
||||
float2 *__restrict d_StockPrice,
|
||||
float2 *__restrict d_OptionStrike,
|
||||
float2 *__restrict d_OptionYears, float Riskfree,
|
||||
float Volatility, int optN) {
|
||||
////Thread index
|
||||
const int opt = blockDim.x * blockIdx.x + threadIdx.x;
|
||||
extern "C" __launch_bounds__(128) __global__ void BlackScholesGPU(float2 *__restrict d_CallResult,
|
||||
float2 *__restrict d_PutResult,
|
||||
float2 *__restrict d_StockPrice,
|
||||
float2 *__restrict d_OptionStrike,
|
||||
float2 *__restrict d_OptionYears,
|
||||
float Riskfree,
|
||||
float Volatility,
|
||||
int optN)
|
||||
{
|
||||
////Thread index
|
||||
const int opt = blockDim.x * blockIdx.x + threadIdx.x;
|
||||
|
||||
// Calculating 2 options per thread to increase ILP (instruction level
|
||||
// parallelism)
|
||||
if (opt < (optN / 2)) {
|
||||
float callResult1, callResult2;
|
||||
float putResult1, putResult2;
|
||||
BlackScholesBodyGPU(callResult1, putResult1, d_StockPrice[opt].x,
|
||||
d_OptionStrike[opt].x, d_OptionYears[opt].x, Riskfree,
|
||||
Volatility);
|
||||
BlackScholesBodyGPU(callResult2, putResult2, d_StockPrice[opt].y,
|
||||
d_OptionStrike[opt].y, d_OptionYears[opt].y, Riskfree,
|
||||
Volatility);
|
||||
d_CallResult[opt] = make_float2(callResult1, callResult2);
|
||||
d_PutResult[opt] = make_float2(putResult1, putResult2);
|
||||
}
|
||||
// Calculating 2 options per thread to increase ILP (instruction level
|
||||
// parallelism)
|
||||
if (opt < (optN / 2)) {
|
||||
float callResult1, callResult2;
|
||||
float putResult1, putResult2;
|
||||
BlackScholesBodyGPU(callResult1,
|
||||
putResult1,
|
||||
d_StockPrice[opt].x,
|
||||
d_OptionStrike[opt].x,
|
||||
d_OptionYears[opt].x,
|
||||
Riskfree,
|
||||
Volatility);
|
||||
BlackScholesBodyGPU(callResult2,
|
||||
putResult2,
|
||||
d_StockPrice[opt].y,
|
||||
d_OptionStrike[opt].y,
|
||||
d_OptionYears[opt].y,
|
||||
Riskfree,
|
||||
Volatility);
|
||||
d_CallResult[opt] = make_float2(callResult1, callResult2);
|
||||
d_PutResult[opt] = make_float2(putResult1, putResult2);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user