mirror of
https://github.com/NVIDIA/cuda-samples.git
synced 2025-04-24 11:02:22 +08:00
250 lines
8.4 KiB
C++
250 lines
8.4 KiB
C++
/* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of NVIDIA CORPORATION nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
|
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Monte Carlo: Single Asian Option
|
|
// ================================
|
|
//
|
|
// This sample demonstrates pricing a single European-exercise average-price
|
|
// Asian option (arithmetic discrete average).
|
|
//
|
|
// This file, main.cpp, contains the setup information to run the test, for
|
|
// example parsing the command line and integrating this sample with the
|
|
// samples framework. As such it is perhaps less interesting than the guts of
|
|
// the sample. Readers wishing to skip the clutter are advised to skip straight
|
|
// to Test.operator() in test.cpp.
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
#include <iostream>
|
|
#include <iomanip>
|
|
#include <stdexcept>
|
|
#include <cuda_runtime.h>
|
|
#include <helper_timer.h>
|
|
#include <helper_cuda.h>
|
|
|
|
#include "../inc/test.h"
|
|
|
|
// Forward declarations
|
|
void showHelp(const int argc, const char **argv);
|
|
template <typename Real>
|
|
void runTest(int argc, const char **argv);
|
|
|
|
int main(int argc, char **argv) {
|
|
using std::invalid_argument;
|
|
using std::string;
|
|
|
|
// Open the log file
|
|
printf("Monte Carlo Single Asian Option (with PRNG)\n");
|
|
printf("===========================================\n\n");
|
|
|
|
// If help flag is set, display help and exit immediately
|
|
if (checkCmdLineFlag(argc, (const char **)argv, "help")) {
|
|
printf("Displaying help on console\n");
|
|
showHelp(argc, (const char **)argv);
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
|
|
// Check the precision (checked against the device capability later)
|
|
try {
|
|
char *value;
|
|
|
|
if (getCmdLineArgumentString(argc, (const char **)argv, "precision",
|
|
&value)) {
|
|
// Check requested precision is valid
|
|
string prec(value);
|
|
|
|
if (prec.compare("single") == 0 || prec.compare("\"single\"") == 0) {
|
|
runTest<float>(argc, (const char **)argv);
|
|
} else if (prec.compare("double") == 0 ||
|
|
prec.compare("\"double\"") == 0) {
|
|
runTest<double>(argc, (const char **)argv);
|
|
} else {
|
|
printf(
|
|
"specified precision (%s) is invalid, must be \"single\" or "
|
|
"\"double\".\n",
|
|
value);
|
|
throw invalid_argument("precision");
|
|
}
|
|
} else {
|
|
runTest<float>(argc, (const char **)argv);
|
|
}
|
|
} catch (invalid_argument &e) {
|
|
printf("invalid command line argument (%s)\n", e.what());
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
// Finish
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
|
|
template <typename Real>
|
|
void runTest(int argc, const char **argv) {
|
|
using std::invalid_argument;
|
|
using std::runtime_error;
|
|
|
|
try {
|
|
Test<Real> test;
|
|
int deviceCount = 0;
|
|
cudaError_t cudaResult = cudaSuccess;
|
|
|
|
// by default specify GPU Device == 0
|
|
test.device = 0;
|
|
|
|
// Get number of available devices
|
|
cudaResult = cudaGetDeviceCount(&deviceCount);
|
|
|
|
if (cudaResult != cudaSuccess) {
|
|
printf("could not get device count.\n");
|
|
throw runtime_error("cudaGetDeviceCount");
|
|
}
|
|
|
|
// (default parameters)
|
|
test.numSims = k_sims_qa;
|
|
test.threadBlockSize = k_bsize_qa;
|
|
test.seed = k_seed_qa;
|
|
|
|
{
|
|
char *value = 0;
|
|
|
|
if (getCmdLineArgumentString(argc, argv, "device", &value)) {
|
|
test.device = (int)atoi(value);
|
|
|
|
if (test.device >= deviceCount) {
|
|
printf(
|
|
"invalid target device specified on command line (device %d does "
|
|
"not exist).\n",
|
|
test.device);
|
|
throw invalid_argument("device");
|
|
}
|
|
} else {
|
|
test.device = gpuGetMaxGflopsDeviceId();
|
|
}
|
|
|
|
if (getCmdLineArgumentString(argc, argv, "sims", &value)) {
|
|
test.numSims = (unsigned int)atoi(value);
|
|
|
|
if (test.numSims < k_sims_min || test.numSims > k_sims_max) {
|
|
printf(
|
|
"specified number of simulations (%d) is invalid, must be "
|
|
"between %d and %d.\n",
|
|
test.numSims, k_sims_min, k_sims_max);
|
|
throw invalid_argument("sims");
|
|
}
|
|
} else {
|
|
test.numSims = k_sims_def;
|
|
}
|
|
|
|
if (getCmdLineArgumentString(argc, argv, "block-size", &value)) {
|
|
// Determine max threads per block
|
|
cudaDeviceProp deviceProperties;
|
|
cudaResult = cudaGetDeviceProperties(&deviceProperties, test.device);
|
|
|
|
if (cudaResult != cudaSuccess) {
|
|
printf("cound not get device properties for device %d.\n",
|
|
test.device);
|
|
throw runtime_error("cudaGetDeviceProperties");
|
|
}
|
|
|
|
// Check requested size is valid
|
|
test.threadBlockSize = (unsigned int)atoi(value);
|
|
|
|
if (test.threadBlockSize < k_bsize_min ||
|
|
test.threadBlockSize > static_cast<unsigned int>(
|
|
deviceProperties.maxThreadsPerBlock)) {
|
|
printf(
|
|
"specified block size (%d) is invalid, must be between %d and %d "
|
|
"for device %d.\n",
|
|
test.threadBlockSize, k_bsize_min,
|
|
deviceProperties.maxThreadsPerBlock, test.device);
|
|
throw invalid_argument("block-size");
|
|
}
|
|
|
|
if (test.threadBlockSize & test.threadBlockSize - 1) {
|
|
printf(
|
|
"specified block size (%d) is invalid, must be a power of two "
|
|
"(see reduction function).\n",
|
|
test.threadBlockSize);
|
|
throw invalid_argument("block-size");
|
|
}
|
|
} else {
|
|
test.threadBlockSize = k_bsize_def;
|
|
}
|
|
|
|
if (getCmdLineArgumentString(argc, argv, "seed", &value)) {
|
|
// Check requested seed is valid
|
|
test.seed = (unsigned int)atoi(value);
|
|
|
|
if (test.seed == 0) {
|
|
printf("specified seed (%d) is invalid, must be non-zero.\n",
|
|
test.seed);
|
|
throw invalid_argument("seed");
|
|
}
|
|
} else {
|
|
test.seed = k_seed_def;
|
|
}
|
|
}
|
|
// Execute
|
|
test();
|
|
} catch (invalid_argument &e) {
|
|
printf("invalid command line argument (%s)\n", e.what());
|
|
exit(EXIT_FAILURE);
|
|
} catch (runtime_error &e) {
|
|
printf("runtime error (%s)\n", e.what());
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
void showHelp(int argc, const char **argv) {
|
|
using std::cout;
|
|
using std::endl;
|
|
using std::left;
|
|
using std::setw;
|
|
|
|
if (argc > 0) {
|
|
cout << endl << argv[0] << endl;
|
|
}
|
|
|
|
cout << endl << "Syntax:" << endl;
|
|
cout << left;
|
|
cout << " " << setw(20) << "--device=<device>"
|
|
<< "Specify device to use for execution" << endl;
|
|
cout << " " << setw(20) << "--sims=<N>"
|
|
<< "Specify number of Monte Carlo simulations" << endl;
|
|
cout << " " << setw(20) << "--block-size=<N>"
|
|
<< "Specify number of threads per block" << endl;
|
|
cout << " " << setw(20) << "--seed=<N>"
|
|
<< "Specify the seed to use for the random number generator" << endl;
|
|
cout << " " << setw(20) << "--precision=<P>"
|
|
<< "Specify the precision (\"single\" or \"double\")" << endl;
|
|
cout << endl;
|
|
cout << " " << setw(20) << "--noprompt"
|
|
<< "Skip prompt before exit" << endl;
|
|
cout << endl;
|
|
}
|