////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main(int argc, char** argv)
{
if (cutCheckCmdLineFlag(argc, (const char **)argv, "qatest") ||
cutCheckCmdLineFlag(argc, (const char **)argv, "noprompt"))
{
g_bQAReadback = true;
g_bFBODisplay = false;
fpsLimit = frameCheckNumber;
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "glverify"))
{
g_bOpenGLQA = true;
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "fbo"))
{
g_bFBODisplay = true;
}
if (g_bQAReadback) {
runAutoTest(argc, argv);
} else {
runGraphicsTest(argc, argv);
}
cutilExit(argc, argv);
}
////////////////////////////////////////////////////////////////////////////////
//! Run a simple test for CUDA
////////////////////////////////////////////////////////////////////////////////
CUTBoolean runTest(int argc, char** argv)
{
if (!cutCheckCmdLineFlag(argc, (const char **)argv, "noqatest") ||
cutCheckCmdLineFlag(argc, (const char **)argv, "noprompt"))
{
g_bQAReadback = true;
fpsLimit = frameCheckNumber;
}
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with OpenGL/CUDA interop.
if (CUTFalse == initGL(argc, argv)) {
return CUTFalse;
}
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
if( cutCheckCmdLineFlag(argc, (const char**)argv, "device") )
cutilGLDeviceInit(argc, argv);
else {
cudaGLSetGLDevice( cutGetMaxGflopsDeviceId() );
}
// Create the CUTIL timer
cutilCheckError( cutCreateTimer( &timer));
// register callbacks
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMotionFunc(motion);
if (g_bQAReadback) {
g_CheckRender = new CheckBackBuffer(window_width, window_height, 4);
g_CheckRender->setPixelFormat(GL_RGBA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(true);
}
// create VBO
createVBO(&vbo);
// run the cuda part
runCuda(vbo);
// check result of Cuda step
checkResultCuda(argc, argv, vbo);
atexit(cleanup);
// start rendering mainloop
glutMainLoop();
cudaThreadExit();
return CUTTrue;
}
////////////////////////////////////////////////////////////////////////////////
//! Check if the result is correct or write data to file for external
//! regression testing
////////////////////////////////////////////////////////////////////////////////
void checkResultCuda(int argc, char** argv, const GLuint& vbo)
{
cutilSafeCall(cudaGLUnregisterBufferObject(vbo));
// map buffer object
glBindBuffer(GL_ARRAY_BUFFER_ARB, vbo );
float* data = (float*) glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
// check result
if(cutCheckCmdLineFlag(argc, (const char**) argv, "regression")) {
// write file for regression test
cutilCheckError(cutWriteFilef("./data/regression.dat",
data, mesh_width * mesh_height * 3, 0.0));
}
// unmap GL buffer object
if(! glUnmapBuffer(GL_ARRAY_BUFFER)) {
fprintf(stderr, "Unmap buffer failed.\n");
fflush(stderr);
}
cutilSafeCall(cudaGLRegisterBufferObject(vbo));
CUT_CHECK_ERROR_GL();
}
void runAutoTest(int argc, char **argv)
{
printf("[%s] (automated testing w/ readback)\n", sSDKsample);
if( cutCheckCmdLineFlag(argc, (const char**)argv, "device") ) {
cutilDeviceInit(argc, argv);
} else {
cudaSetDevice( cutGetMaxGflopsDeviceId() );
}
loadDefaultImage( argv[0] );
if (argc > 1) {
char *filename;
if (cutGetCmdLineArgumentstr(argc, (const char **)argv, "file", &filename)) {
initializeData(filename);
}
} else {
loadDefaultImage( argv[0]);
}
g_CheckRender = new CheckBackBuffer(imWidth, imHeight, sizeof(Pixel), false);
g_CheckRender->setExecPath(argv[0]);
Pixel *d_result;
cutilSafeCall( cudaMalloc( (void **)&d_result, imWidth*imHeight*sizeof(Pixel)) );
while (g_SobelDisplayMode <= 2)
{
printf("AutoTest: %s <%s>\n", sSDKsample, filterMode[g_SobelDisplayMode]);
sobelFilter(d_result, imWidth, imHeight, g_SobelDisplayMode, imageScale );
cutilSafeCall( cudaThreadSynchronize() );
cudaMemcpy(g_CheckRender->imageData(), d_result, imWidth*imHeight*sizeof(Pixel), cudaMemcpyDeviceToHost);
g_CheckRender->savePGM(sOriginal[g_Index], false, NULL);
if (!g_CheckRender->PGMvsPGM(sOriginal[g_Index], sReference[g_Index], MAX_EPSILON_ERROR, 0.15f)) {
g_TotalErrors++;
}
g_Index++;
g_SobelDisplayMode = (SobelDisplayMode)g_Index;
}
cutilSafeCall( cudaFree( d_result ) );
delete g_CheckRender;
if (!g_TotalErrors)
printf("TEST PASSED!\n");
else
printf("TEST FAILED!\n");
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main(int argc, char** argv)
{
numParticles = 1024;
uint gridDim = 64;
numIterations = 1;
cutGetCmdLineArgumenti( argc, (const char**) argv, "n", (int *) &numParticles);
cutGetCmdLineArgumenti( argc, (const char**) argv, "grid", (int *) &gridDim);
gridSize.x = gridSize.y = gridSize.z = gridDim;
printf("grid: %d x %d x %d = %d cells\n", gridSize.x, gridSize.y, gridSize.z, gridSize.x*gridSize.y*gridSize.z);
bool benchmark = !cutCheckCmdLineFlag(argc, (const char**) argv, "noqatest") != 0;
cutGetCmdLineArgumenti( argc, (const char**) argv, "i", &numIterations);
cudaInit(argc, argv);
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutInitWindowSize(640, 480);
glutCreateWindow("CUDA particles");
initGL();
init(numParticles, gridSize);
initParams();
initMenus();
if (benchmark)
{
if (numIterations <= 0)
numIterations = 300;
runBenchmark(numIterations);
}
else
{
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(key);
glutSpecialFunc(special);
glutIdleFunc(idle);
glutMainLoop();
}
if (psystem)
delete psystem;
cudaThreadExit();
return 0;
}
bool initCUDA( int argc, char **argv)
{
return true;
if ( cutCheckCmdLineFlag(argc, (const char **)argv, "device"))
{
cutilGLDeviceInit(argc, argv);
}
else
{
cudaGLSetGLDevice (cutGetMaxGflopsDeviceId());
}
return true;
}
void
runGraphicsTest(int argc, char** argv)
{
printf("MarchingCubes ");
if (g_bFBODisplay) printf("[w/ FBO] ");
if (g_bOpenGLQA) printf("[Readback Comparisons] ");
printf("\n");
if ( cutCheckCmdLineFlag(argc, (const char **)argv, "device")) {
printf("[%s]\n", argv[0]);
printf(" Does not explicitly support -device=n in OpenGL mode\n");
printf(" To use -device=n, the sample must be running w/o OpenGL\n\n");
printf(" > %s -device=n -qatest\n", argv[0]);
printf("exiting...\n");
exit(0);
}
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with OpenGL/CUDA interop.
if(CUTFalse == initGL(&argc, argv)) {
return;
}
cudaGLSetGLDevice( cutGetMaxGflopsDeviceId() );
// register callbacks
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutIdleFunc(idle);
glutReshapeFunc(reshape);
initMenus();
// Initialize CUDA buffers for Marching Cubes
initMC(argc, argv);
cutilCheckError( cutCreateTimer( &timer));
if (g_bOpenGLQA) {
g_CheckRender = new CheckBackBuffer(window_width, window_height, 4);
g_CheckRender->setPixelFormat(GL_RGBA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(true);
}
// start rendering mainloop
glutMainLoop();
cudaThreadExit();
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char** argv)
{
// check for command line arguments
if (argc > 1) {
if (cutCheckCmdLineFlag(argc, (const char **)argv, "qatest") ||
cutCheckCmdLineFlag(argc, (const char **)argv, "noprompt"))
{
g_bQAReadback = true;
animate = false;
fpsLimit = frameCheckNumber;
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "glverify")) {
g_bOpenGLQA = true;
animate = false;
fpsLimit = frameCheckNumber;
}
}
if (g_bQAReadback)
{
// Automated testing
runAutoTest(argc, argv);
}
else
{
printf("[%s]\n\n"
"Left mouse button - rotate\n"
"Middle mouse button - pan\n"
"Left + middle mouse button - zoom\n"
"'w' key - toggle wireframe\n", sSDKsample);
runGraphicsTest(argc, argv);
}
cutilExit(argc, argv);
}
//////////////////////////////////////////////////////////////////////////////
// Program main
//////////////////////////////////////////////////////////////////////////////
int
main( int argc, char** argv)
{
printf("Run \"nbody -benchmark [-n=<numBodies>]\" to measure perfomance.\n\n");
bool benchmark =
(cutCheckCmdLineFlag(argc, (const char**) argv, "benchmark") != 0);
bool compareToCPU =
((cutCheckCmdLineFlag(argc, (const char**) argv, "compare") != 0) ||
!(cutCheckCmdLineFlag(argc, (const char**) argv, "noqatest") != 0));
bool regression =
(cutCheckCmdLineFlag(argc, (const char**) argv, "regression") != 0);
int devID;
cudaDeviceProp props;
// nBody has a mode that allows it to be run without using GL interop
if (benchmark || compareToCPU || regression) {
/*
if( cutCheckCmdLineFlag(argc, (const char**)argv, "device") ) {
cutilDeviceInit(argc, argv);
} else {
devID = cutGetMaxGflopsDeviceId();
cudaSetDevice( devID );
} */
}
else
{
// This mode shows the OpenGL results rendered
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with OpenGL/CUDA interop.
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutInitWindowSize(720, 480);
glutCreateWindow("CUDA n-body system");
GLenum err = glewInit();
if (GLEW_OK != err)
{
printf("GLEW Error: %s\n", glewGetErrorString(err));
}
else
{
#if defined(WIN32)
wglSwapIntervalEXT(0);
#elif defined(LINUX)
glxSwapIntervalSGI(0);
#endif
}
initGL();
initParameters();
if( cutCheckCmdLineFlag(argc, (const char**)argv, "device") ) {
cutilGLDeviceInit(argc, argv);
} else {
devID = cutGetMaxGflopsDeviceId();
cudaGLSetGLDevice( devID );
}
}
// get number of SMs on this GPU
cutilSafeCall(cudaGetDevice(&devID));
cutilSafeCall(cudaGetDeviceProperties(&props, devID));
numIterations = 0;
int p = 256;
int q = 1;
cutGetCmdLineArgumenti(argc, (const char**) argv, "i", &numIterations);
cutGetCmdLineArgumenti(argc, (const char**) argv, "p", &p);
cutGetCmdLineArgumenti(argc, (const char**) argv, "q", &q);
// default number of bodies is #SMs * 4 * CTA size
numBodies = compareToCPU ? 4096 : p*q*4*props.multiProcessorCount;
cutGetCmdLineArgumenti(argc, (const char**) argv, "n", &numBodies);
switch (numBodies)
{
case 1024:
activeParams.m_clusterScale = 1.52f;
activeParams.m_velocityScale = 2.f;
break;
case 2048:
activeParams.m_clusterScale = 1.56f;
activeParams.m_velocityScale = 2.64f;
break;
case 4096:
activeParams.m_clusterScale = 1.68f;
activeParams.m_velocityScale = 2.98f;
break;
case 8192:
activeParams.m_clusterScale = 1.98f;
activeParams.m_velocityScale = 2.9f;
break;
default:
case 16384:
activeParams.m_clusterScale = 1.54f;
activeParams.m_velocityScale = 8.f;
break;
case 32768:
activeParams.m_clusterScale = 1.44f;
activeParams.m_velocityScale = 11.f;
break;
}
if (q * p > 256)
{
p = 256 / q;
printf("Setting p=%d, q=%d to maintain %d threads per block\n", p, q, 256);
}
if (q == 1 && numBodies < p)
{
p = numBodies;
}
init(numBodies, p, q, !(benchmark || compareToCPU));
reset(nbody, numBodies, NBODY_CONFIG_SHELL, !(benchmark || compareToCPU));
if (benchmark)
{
if (numIterations <= 0)
numIterations = 100;
runBenchmark(numIterations);
}
else if (compareToCPU || regression)
{
compareResults(regression, numBodies);
}
else
{
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(key);
glutSpecialFunc(special);
glutIdleFunc(idle);
cutilSafeCall(cudaEventRecord(startEvent, 0));
glutMainLoop();
}
if (nbodyCPU)
delete nbodyCPU;
if (nbodyCUDA)
delete nbodyCUDA;
if (hPos)
delete [] hPos;
if (hVel)
delete [] hVel;
if (hColor)
delete [] hColor;
cutilSafeCall(cudaEventDestroy(startEvent));
cutilSafeCall(cudaEventDestroy(stopEvent));
cutilCheckError(cutDeleteTimer(demoTimer));
return 0;
}
int main(int argc, char **argv)
{
GpuProfiling::initProf();
// Start logs
shrSetLogFileName ("scan.txt");
shrLog("%s Starting...\n\n", argv[0]);
//Use command-line specified CUDA device, otherwise use device with highest Gflops/s
if( cutCheckCmdLineFlag(argc, (const char**)argv, "device") )
cutilDeviceInit(argc, argv);
else
cudaSetDevice( cutGetMaxGflopsDeviceId() );
uint *d_Input, *d_Output;
uint *h_Input, *h_OutputCPU, *h_OutputGPU;
uint hTimer;
const uint N = 13 * 1048576 / 2;
shrLog("Allocating and initializing host arrays...\n");
cutCreateTimer(&hTimer);
h_Input = (uint *)malloc(N * sizeof(uint));
h_OutputCPU = (uint *)malloc(N * sizeof(uint));
h_OutputGPU = (uint *)malloc(N * sizeof(uint));
srand(2009);
for(uint i = 0; i < N; i++)
h_Input[i] = rand();
shrLog("Allocating and initializing CUDA arrays...\n");
cutilSafeCall( cudaMalloc((void **)&d_Input, N * sizeof(uint)) );
cutilSafeCall( cudaMalloc((void **)&d_Output, N * sizeof(uint)) );
cutilSafeCall( cudaMemcpy(d_Input, h_Input, N * sizeof(uint), cudaMemcpyHostToDevice) );
shrLog("Initializing CUDA-C scan...\n\n");
initScan();
int globalFlag = 1;
size_t szWorkgroup;
const int iCycles = 100;
shrLog("*** Running GPU scan for short arrays (%d identical iterations)...\n\n", iCycles);
for(uint arrayLength = MIN_SHORT_ARRAY_SIZE; arrayLength <= MAX_SHORT_ARRAY_SIZE; arrayLength <<= 1){
shrLog("Running scan for %u elements (%u arrays)...\n", arrayLength, N / arrayLength);
cutilSafeCall( cudaThreadSynchronize() );
cutResetTimer(hTimer);
cutStartTimer(hTimer);
for(int i = 0; i < iCycles; i++)
{
szWorkgroup = scanExclusiveShort(d_Output, d_Input, N / arrayLength, arrayLength);
}
cutilSafeCall( cudaThreadSynchronize());
cutStopTimer(hTimer);
double timerValue = 1.0e-3 * cutGetTimerValue(hTimer) / iCycles;
shrLog("Validating the results...\n");
shrLog("...reading back GPU results\n");
cutilSafeCall( cudaMemcpy(h_OutputGPU, d_Output, N * sizeof(uint), cudaMemcpyDeviceToHost) );
shrLog(" ...scanExclusiveHost()\n");
scanExclusiveHost(h_OutputCPU, h_Input, N / arrayLength, arrayLength);
// Compare GPU results with CPU results and accumulate error for this test
shrLog(" ...comparing the results\n");
int localFlag = 1;
for(uint i = 0; i < N; i++)
{
if(h_OutputCPU[i] != h_OutputGPU[i])
{
localFlag = 0;
break;
}
}
// Log message on individual test result, then accumulate to global flag
shrLog(" ...Results %s\n\n", (localFlag == 1) ? "Match" : "DON'T Match !!!");
globalFlag = globalFlag && localFlag;
// Data log
if (arrayLength == MAX_SHORT_ARRAY_SIZE)
{
shrLog("\n");
shrLogEx(LOGBOTH | MASTER, 0, "scan-Short, Throughput = %.4f MElements/s, Time = %.5f s, Size = %u Elements, NumDevsUsed = %u, Workgroup = %u\n",
(1.0e-6 * (double)arrayLength/timerValue), timerValue, arrayLength, 1, szWorkgroup);
shrLog("\n");
}
}
shrLog("***Running GPU scan for large arrays (%u identical iterations)...\n\n", iCycles);
for(uint arrayLength = MIN_LARGE_ARRAY_SIZE; arrayLength <= MAX_LARGE_ARRAY_SIZE; arrayLength <<= 1){
shrLog("Running scan for %u elements (%u arrays)...\n", arrayLength, N / arrayLength);
cutilSafeCall( cudaThreadSynchronize() );
cutResetTimer(hTimer);
cutStartTimer(hTimer);
for(int i = 0; i < iCycles; i++)
{
szWorkgroup = scanExclusiveLarge(d_Output, d_Input, N / arrayLength, arrayLength);
}
cutilSafeCall( cudaThreadSynchronize() );
cutStopTimer(hTimer);
double timerValue = 1.0e-3 * cutGetTimerValue(hTimer) / iCycles;
shrLog("Validating the results...\n");
shrLog("...reading back GPU results\n");
cutilSafeCall( cudaMemcpy(h_OutputGPU, d_Output, N * sizeof(uint), cudaMemcpyDeviceToHost) );
shrLog("...scanExclusiveHost()\n");
scanExclusiveHost(h_OutputCPU, h_Input, N / arrayLength, arrayLength);
// Compare GPU results with CPU results and accumulate error for this test
shrLog(" ...comparing the results\n");
int localFlag = 1;
for(uint i = 0; i < N; i++)
{
if(h_OutputCPU[i] != h_OutputGPU[i])
{
localFlag = 0;
break;
}
}
// Log message on individual test result, then accumulate to global flag
shrLog(" ...Results %s\n\n", (localFlag == 1) ? "Match" : "DON'T Match !!!");
globalFlag = globalFlag && localFlag;
// Data log
if (arrayLength == MAX_LARGE_ARRAY_SIZE)
{
shrLog("\n");
shrLogEx(LOGBOTH | MASTER, 0, "scan-Large, Throughput = %.4f MElements/s, Time = %.5f s, Size = %u Elements, NumDevsUsed = %u, Workgroup = %u\n",
(1.0e-6 * (double)arrayLength/timerValue), timerValue, arrayLength, 1, szWorkgroup);
shrLog("\n");
}
}
// pass or fail (cumulative... all tests in the loop)
shrLog(globalFlag ? "PASSED\n\n" : "FAILED\n\n");
GpuProfiling::printResults();
shrLog("Shutting down...\n");
closeScan();
cutilSafeCall( cudaFree(d_Output));
cutilSafeCall( cudaFree(d_Input));
cutilCheckError( cutDeleteTimer(hTimer) );
cudaThreadExit();
exit(0);
shrEXIT(argc, (const char**)argv);
}
int main(int argc, char** argv)
{
printf("[%s]\n", sSDKsample);
if (argc > 1) {
if (cutCheckCmdLineFlag(argc, (const char **)argv, "help")) {
printHelp();
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "qatest") ||
cutCheckCmdLineFlag(argc, (const char **)argv, "noprompt"))
{
g_bQAReadback = true;
fpsLimit = frameCheckNumber;
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "glverify"))
{
g_bOpenGLQA = true;
fpsLimit = frameCheckNumber;
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "fbo")) {
g_bFBODisplay = true;
fpsLimit = frameCheckNumber;
}
}
if (g_bQAReadback)
{
runAutoTest(argc, argv);
}
else
{
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with OpenGL/CUDA interop.
initGL( &argc, argv );
// use command-line specified CUDA device if possible, otherwise search for capable device
if( cutCheckCmdLineFlag(argc, (const char**)argv, "device") ) {
cutilGLDeviceInit(argc, argv);
int device;
cudaGetDevice( &device );
if( checkCUDAProfile( device ) == false ) {
cudaThreadExit();
cutilExit(argc, argv);
}
} else {
//cudaGLSetGLDevice (cutGetMaxGflopsDeviceId() );
int dev = findCapableDevice(argc, argv);
if( dev != -1 )
cudaGLSetGLDevice( dev );
else {
cudaThreadExit();
cutilExit(argc, argv);
}
}
cutilCheckError(cutCreateTimer(&timer));
cutilCheckError(cutResetTimer(timer));
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
if (g_bOpenGLQA) {
loadDefaultImage( argc, argv );
}
if (argc > 1) {
char *filename;
if (cutGetCmdLineArgumentstr(argc, (const char **)argv, "file", &filename)) {
initializeData(filename, argc, argv);
}
} else {
loadDefaultImage( argc, argv );
}
// If code is not printing the USage, then we execute this path.
if (!bQuit) {
if (g_bOpenGLQA) {
g_CheckRender = new CheckBackBuffer(wWidth, wHeight, 4);
g_CheckRender->setPixelFormat(GL_BGRA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(true);
}
printf("I: display image\n");
printf("T: display Sobel edge detection (computed with tex)\n");
printf("S: display Sobel edge detection (computed with tex+shared memory)\n");
printf("Use the '-' and '=' keys to change the brightness.\n");
printf("b: switch block filter operation (mean/Sobel)\n");
printf("p: swtich point filter operation (threshold on/off)\n");
fflush(stdout);
atexit(cleanup);
glutMainLoop();
}
}
cudaThreadExit();
cutilExit(argc, argv);
}
int main(int argc, char** argv)
{
ModelParameters model_params;
fillCalculationParameters(model_params);
fillDerivedParameters(model_params, params);
if (CUTFalse == initGL(argc, argv, params))
return CUTFalse;
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
if(cutCheckCmdLineFlag(argc, (const char**)argv, "device"))
cutilDeviceInit(argc, argv);
else
cudaSetDevice(cutGetMaxGflopsDeviceId());
// initialize calculations
initConstants(params);
timeval init_start, init_stop;
// calculate steady state
value_pair *steady_state = new value_pair[params.cells];
initSpectre();
initWaveVectors(params);
gettimeofday(&init_start, NULL);
calculateSteadyState(steady_state, params);
gettimeofday(&init_stop, NULL);
printf("Steady state calculation: %.3f s\n", time_diff(init_start, init_stop));
/*
FILE *f = fopen("plot_gs_mu.txt", "w");
int shift = (params.nvz / 2) * params.nvx * params.nvy + (params.nvy / 2) * params.nvx;
for(int i = 0; i < params.nvx; i++)
{
value_pair val = steady_state[shift + i];
fprintf(f, "%f %f\n", (-params.xmax + params.dx * i) * 1000000, (val.x * val.x + val.y * val.y));
}
fclose(f);
*/
gettimeofday(&init_start, NULL);
state.init(params);
initEvolution(steady_state, params, state);
gettimeofday(&init_stop, NULL);
printf("Evolution init: %.3f s\n", time_diff(init_start, init_stop));
delete[] steady_state;
// measure propagation time, for testing purposes
calculateEvolution(params, state, 0.0); // warm-up
gettimeofday(&init_start, NULL);
calculateEvolution(params, state, 0.0); // zero time step - because we are just measuring speed here
gettimeofday(&init_stop, NULL);
printf("Propagation time: %.3f ms\n", time_diff(init_start, init_stop) * 1000.0f);
// prepare textures
a_xy.init(params.nvx, params.nvy);
b_xy.init(params.nvx, params.nvy);
a_zy.init(params.nvz, params.nvy);
b_zy.init(params.nvz, params.nvy);
// remember starting time
gettimeofday(&time_start, NULL);
// start main application cycle
atexit(cleanup);
glutMainLoop();
return 0;
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main( int argc, char** argv)
{
pArgc = &argc;
pArgv = argv;
shrQAStart(argc, argv);
// start logs
shrSetLogFileName ("boxFilter.txt");
shrLog("%s Starting...\n\n", argv[0]);
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
if (argc > 1) {
cutGetCmdLineArgumenti( argc, (const char**) argv, "threads", &nthreads );
cutGetCmdLineArgumenti( argc, (const char**) argv, "radius", &filter_radius);
if (cutCheckCmdLineFlag(argc, (const char **)argv, "glverify"))
{
g_bOpenGLQA = true;
fpsLimit = frameCheckNumber;
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "fbo")) {
g_bFBODisplay = true;
}
}
// load image to process
loadImageData(argc, argv);
if (cutCheckCmdLineFlag(argc, (const char **)argv, "qatest") ||
cutCheckCmdLineFlag(argc, (const char **)argv, "noprompt"))
{
// Running CUDA kernel (boxFilter) without visualization (QA Testing/Verification)
runAutoTest(argc, argv);
shrQAFinishExit(argc, (const char **)argv, (g_TotalErrors == 0 ? QA_PASSED : QA_FAILED));
}
else if (cutCheckCmdLineFlag(argc, (const char **)argv, "benchmark"))
{
// Running CUDA kernels (boxfilter) in Benchmarking mode
runBenchmark(argc, argv);
shrQAFinishExit(argc, (const char **)argv, (g_TotalErrors == 0 ? QA_PASSED : QA_FAILED));
}
else
{
// Running CUDA kernels (boxFilter) with OpenGL visualization
if (g_bFBODisplay) shrLog("[FBO Display] ");
if (g_bOpenGLQA) shrLog("[OpenGL Readback Comparisons] ");
shrLog("\n");
if ( cutCheckCmdLineFlag(argc, (const char **)argv, "device")) {
printf(" This SDK does not explicitly support -device=n when running with OpenGL.\n");
printf(" When specifying -device=n (n=0,1,2,....) the sample must not use OpenGL.\n");
printf(" See details below to run without OpenGL:\n\n");
printf(" > %s -device=n -qatest\n\n", argv[0]);
printf("exiting...\n");
shrQAFinishExit(argc, (const char **)argv, QA_WAIVED);
}
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with OpenGL/CUDA interop.
initGL( &argc, argv );
int dev = findCapableDevice(argc, argv);
if( dev != -1 ) {
cudaGLSetGLDevice( dev );
} else {
cutilDeviceReset();
shrQAFinishExit(argc, (const char **)argv, QA_WAIVED);
}
// Now we can create a CUDA context and bind it to the OpenGL context
initCuda();
initGLResources();
if (g_bOpenGLQA) {
if (g_bFBODisplay) {
g_CheckRender = new CheckFBO(width, height, 4, g_FrameBufferObject);
} else {
g_CheckRender = new CheckBackBuffer(width, height, 4);
}
g_CheckRender->setPixelFormat(GL_RGBA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(true);
}
}
// sets the callback function so it will call cleanup upon exit
atexit(cleanup);
shrLog("Running Standard Demonstration with GLUT loop...\n\n");
shrLog("Press '+' and '-' to change filter width\n"
"Press ']' and '[' to change number of iterations\n\n");
// Main OpenGL loop that will run visualization for every vsync
glutMainLoop();
cutilDeviceReset();
shrQAFinishExit(argc, (const char **)argv, (g_TotalErrors == 0 ? QA_PASSED : QA_FAILED));
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int main( int argc, char** argv)
{
shrQAStart(argc, argv);
// start logs
shrSetLogFileName ("bilateralFilter.txt");
shrLog("%s Starting...\n\n", argv[0]);
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
cutGetCmdLineArgumenti( argc, (const char**) argv, "threads", &nthreads );
cutGetCmdLineArgumenti( argc, (const char**) argv, "radius", &filter_radius);
// load image to process
loadImageData(argc, argv);
if (cutCheckCmdLineFlag(argc, (const char **)argv, "qatest") ||
cutCheckCmdLineFlag(argc, (const char **)argv, "noprompt"))
{
// Running CUDA kernel (bilateralFilter) without visualization (QA Testing/Verification)
runAutoTest(argc, argv);
shrQAFinishExit(argc, (const char **)argv, (g_TotalErrors == 0 ? QA_PASSED : QA_FAILED));
}
else if (cutCheckCmdLineFlag(argc, (const char **)argv, "benchmark"))
{
// Running CUDA kernel (bilateralFilter) in Benchmarking Mode
runBenchmark(argc, argv);
shrQAFinishExit(argc, (const char **)argv, (g_TotalErrors == 0 ? QA_PASSED : QA_FAILED));
}
else
{
// Running CUDA kernel (bilateralFilter) in CUDA + OpenGL Visualization Mode
if ( cutCheckCmdLineFlag(argc, (const char **)argv, "device")) {
printf("[%s]\n", argv[0]);
printf(" Does not explicitly support -device=n in OpenGL mode\n");
printf(" To use -device=n, the sample must be running w/o OpenGL\n\n");
printf(" > %s -device=n -qatest\n", argv[0]);
printf("exiting...\n");
exit(0);
}
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with OpenGL/CUDA interop.
initGL( argc, argv );
if ( cutCheckCmdLineFlag(argc, (const char **)argv, "device")) {
cutilGLDeviceInit(argc, argv);
} else {
cudaGLSetGLDevice (cutGetMaxGflopsDeviceId() );
}
initCuda();
initOpenGL();
}
atexit(cleanup);
printf("Running Standard Demonstration with GLUT loop...\n\n");
printf("Press '+' and '-' to change number of iterations\n"
"Press LEFT and RIGHT change euclidean delta\n"
"Press UP and DOWN to change gaussian delta\n"
"Press '1' to show original image\n"
"Press '2' to show result\n\n");
glutMainLoop();
cutilDeviceReset();
shrQAFinishExit(argc, (const char **)argv, (g_TotalErrors == 0 ? QA_PASSED : QA_FAILED));
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main(int argc, char** argv)
{
int retVal = 0;
retVal = xnInit( argc, argv );
printf("[ %s ]\n", sSDKsample);
if (argc > 1) {
cutGetCmdLineArgumenti( argc, (const char**) argv, "n", (int *) &numParticles);
if (cutCheckCmdLineFlag(argc, (const char **)argv, "qatest") ||
cutCheckCmdLineFlag(argc, (const char **)argv, "noprompt")
)
{
g_bQAReadback = true;
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "glverify"))
{
g_bQAGLVerify = true;
}
}
if (g_bQAReadback) {
// For Automated testing, we do not use OpenGL/CUDA interop
if ( cutCheckCmdLineFlag(argc, (const char **)argv, "device")) {
cutilDeviceInit (argc, argv);
} else {
cudaSetDevice (cutGetMaxGflopsDeviceId() );
}
g_CheckRender = new CheckBackBuffer(winWidth, winHeight, 4, false);
g_CheckRender->setPixelFormat(GL_RGBA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(true);
// This code path is used for Automated Testing
initParticles(numParticles, false, false);
initParams();
if (emitterOn) {
runEmitter();
}
SimParams ¶ms = psystem->getParams();
params.cursorPos = make_float3(cursorPosLag.x, cursorPosLag.y, cursorPosLag.z);
psystem->step(timestep);
float4 *pos = NULL, *vel = NULL;
int g_TotalErrors = 0;
psystem->dumpBin(&pos, &vel);
g_CheckRender->dumpBin(pos, numParticles*sizeof(float4), "smokeParticles_pos.bin");
g_CheckRender->dumpBin(vel, numParticles*sizeof(float4), "smokeParticles_vel.bin");
if (!g_CheckRender->compareBin2BinFloat("smokeParticles_pos.bin", sRefBin[0], numParticles*sizeof(float4), MAX_EPSILON_ERROR, THRESHOLD))
g_TotalErrors++;
if (!g_CheckRender->compareBin2BinFloat("smokeParticles_vel.bin", sRefBin[1], numParticles*sizeof(float4), MAX_EPSILON_ERROR, THRESHOLD))
g_TotalErrors++;
delete psystem;
delete g_CheckRender;
printf("%s\n", (g_TotalErrors > 0) ? "FAILED" : "PASSED");
cudaThreadExit();
} else {
// Normal smokeParticles rendering path
// 1st initialize OpenGL context, so we can properly set the GL for CUDA.
// This is needed to achieve optimal performance with OpenGL/CUDA interop.
initGL( &argc, argv );
if ( cutCheckCmdLineFlag(argc, (const char **)argv, "device")) {
cutilGLDeviceInit (argc, argv);
} else {
cudaGLSetGLDevice (cutGetMaxGflopsDeviceId() );
}
if (g_bQAGLVerify) {
g_CheckRender = new CheckBackBuffer(winWidth, winHeight, 4);
g_CheckRender->setPixelFormat(GL_RGBA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(true);
}
// This is the normal code path for SmokeParticles
initParticles(numParticles, true, true);
initParams();
initMenus();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(key);
glutKeyboardUpFunc(keyUp);
glutSpecialFunc(special);
glutIdleFunc(idle);
glutMainLoop();
}
cutilExit(argc, argv);
return retVal;
}
void runAutoTest(int argc, char **argv)
{
printf("[%s] (automated testing w/ readback)\n", sSDKsample);
if( cutCheckCmdLineFlag(argc, (const char**)argv, "device") )
{
int device = cutilDeviceInit(argc, argv);
if (device < 0) {
printf("No CUDA Capable devices found, exiting...\n");
shrQAFinishExit(argc, (const char **)argv, QA_WAIVED);
}
checkDeviceMeetComputeSpec( argc, argv );
} else {
int dev = findCapableDevice(argc, argv);
if( dev != -1 )
cudaSetDevice( dev );
else {
cutilDeviceReset();
shrQAFinishExit2(g_bQAReadback, *pArgc, (const char **)pArgv, QA_PASSED);
}
}
loadDefaultImage( argc, argv );
if (argc > 1) {
char *filename;
if (cutGetCmdLineArgumentstr(argc, (const char **)argv, "file", &filename)) {
initializeData(filename, argc, argv);
}
} else {
loadDefaultImage( argc, argv );
}
g_CheckRender = new CheckBackBuffer(imWidth, imHeight, sizeof(Pixel), false);
g_CheckRender->setExecPath(argv[0]);
Pixel *d_result;
cutilSafeCall( cudaMalloc( (void **)&d_result, imWidth*imHeight*sizeof(Pixel)) );
while (g_SobelDisplayMode <= 2)
{
printf("AutoTest: %s <%s>\n", sSDKsample, filterMode[g_SobelDisplayMode]);
sobelFilter(d_result, imWidth, imHeight, g_SobelDisplayMode, imageScale, blockOp, pointOp );
cutilSafeCall( cutilDeviceSynchronize() );
cudaMemcpy(g_CheckRender->imageData(), d_result, imWidth*imHeight*sizeof(Pixel), cudaMemcpyDeviceToHost);
g_CheckRender->savePGM(sOriginal[g_Index], false, NULL);
if (!g_CheckRender->PGMvsPGM(sOriginal[g_Index], sReference[g_Index], MAX_EPSILON_ERROR, 0.15f)) {
g_TotalErrors++;
}
g_Index++;
g_SobelDisplayMode = (SobelDisplayMode)g_Index;
}
cutilSafeCall( cudaFree( d_result ) );
delete g_CheckRender;
shrQAFinishExit(argc, (const char **)argv, (!g_TotalErrors ? QA_PASSED : QA_FAILED) );
}
int main(int argc, char** argv)
{
pArgc = &argc;
pArgv = argv;
shrQAStart(argc, argv);
if (argc > 1) {
if (cutCheckCmdLineFlag(argc, (const char **)argv, "help")) {
printHelp();
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "qatest") ||
cutCheckCmdLineFlag(argc, (const char **)argv, "noprompt"))
{
g_bQAReadback = true;
fpsLimit = frameCheckNumber;
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "glverify"))
{
g_bOpenGLQA = true;
fpsLimit = frameCheckNumber;
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "fbo")) {
g_bFBODisplay = true;
fpsLimit = frameCheckNumber;
}
}
if (g_bQAReadback)
{
runAutoTest(argc, argv);
}
else
{
if ( cutCheckCmdLineFlag(argc, (const char **)argv, "device")) {
printf(" This SDK does not explicitly support -device=n when running with OpenGL.\n");
printf(" When specifying -device=n (n=0,1,2,....) the sample must not use OpenGL.\n");
printf(" See details below to run without OpenGL:\n\n");
printf(" > %s -device=n -qatest\n\n", argv[0]);
printf("exiting...\n");
shrQAFinishExit(argc, (const char **)argv, QA_PASSED);
}
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with OpenGL/CUDA interop.
initGL( &argc, argv );
//cudaGLSetGLDevice (cutGetMaxGflopsDeviceId() );
int dev = findCapableDevice(argc, argv);
if( dev != -1 ) {
cudaGLSetGLDevice( dev );
} else {
shrQAFinishExit2(g_bQAReadback, *pArgc, (const char **)pArgv, QA_PASSED);
}
cutilCheckError(cutCreateTimer(&timer));
cutilCheckError(cutResetTimer(timer));
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutReshapeFunc(reshape);
if (g_bOpenGLQA) {
loadDefaultImage( argc, argv );
}
if (argc > 1) {
char *filename;
if (cutGetCmdLineArgumentstr(argc, (const char **)argv, "file", &filename)) {
initializeData(filename, argc, argv);
}
} else {
loadDefaultImage( argc, argv );
}
// If code is not printing the USage, then we execute this path.
if (!bQuit) {
if (g_bOpenGLQA) {
g_CheckRender = new CheckBackBuffer(wWidth, wHeight, 4);
g_CheckRender->setPixelFormat(GL_BGRA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(true);
}
printf("I: display Image (no filtering)\n");
printf("T: display Sobel Edge Detection (Using Texture)\n");
printf("S: display Sobel Edge Detection (Using SMEM+Texture)\n");
printf("Use the '-' and '=' keys to change the brightness.\n");
printf("b: switch block filter operation (mean/Sobel)\n");
printf("p: switch point filter operation (threshold on/off)\n");
fflush(stdout);
atexit(cleanup);
glutTimerFunc(REFRESH_DELAY, timerEvent,0);
glutMainLoop();
}
}
cutilDeviceReset();
shrQAFinishExit(argc, (const char **)argv, QA_PASSED);
}
int main(int argc, char **argv)
{
shrQAStart(argc, argv);
if (argc > 1) {
if (cutCheckCmdLineFlag(argc, (const char **)argv, "qatest") ||
cutCheckCmdLineFlag(argc, (const char **)argv, "noprompt"))
{
g_bQAReadback = true;
fpsLimit = frameCheckNumber;
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "glverify"))
{
g_bOpenGLQA = true;
g_bFBODisplay = false;
fpsLimit = frameCheckNumber;
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "fbo")) {
g_bFBODisplay = true;
fpsLimit = frameCheckNumber;
}
}
if (g_bQAReadback) {
runAutoTest(argc, argv);
} else {
printf("[%s] ", sSDKsample);
if (g_bFBODisplay) printf("[FBO Display] ");
if (g_bOpenGLQA) printf("[OpenGL Readback Comparisons] ");
printf("\n");
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
if ( cutCheckCmdLineFlag(argc, (const char **)argv, "device")) {
printf("[%s]\n", argv[0]);
printf(" Does not explicitly support -device=n in OpenGL mode\n");
printf(" To use -device=n, the sample must be running w/o OpenGL\n\n");
printf(" > %s -device=n -qatest\n", argv[0]);
printf("exiting...\n");
exit(0);
}
// First load the image, so we know what the size of the image (imageW and imageH)
printf("Allocating host and CUDA memory and loading image file...\n");
const char *image_path = cutFindFilePath("portrait_noise.bmp", argv[0]);
if (image_path == NULL) {
printf( "imageDenoisingGL was unable to find and load image file <portrait_noise.bmp>.\nExiting...\n");
shrQAFinishExit(argc, (const char **)argv, QA_FAILED);
}
LoadBMPFile(&h_Src, &imageW, &imageH, image_path);
printf("Data init done.\n");
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with OpenGL/CUDA interop.
initGL( &argc, argv );
cudaGLSetGLDevice( cutGetMaxGflopsDeviceId() );
cutilSafeCall( CUDA_MallocArray(&h_Src, imageW, imageH) );
initOpenGLBuffers();
// Creating the Auto-Validation Code
if (g_bOpenGLQA) {
if (g_bFBODisplay) {
g_CheckRender = new CheckFBO(imageW, imageH, 4);
} else {
g_CheckRender = new CheckBackBuffer(imageW, imageH, 4);
}
g_CheckRender->setPixelFormat(GL_RGBA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(g_bOpenGLQA);
}
}
printf("Starting GLUT main loop...\n");
printf("Press [1] to view noisy image\n");
printf("Press [2] to view image restored with knn filter\n");
printf("Press [3] to view image restored with nlm filter\n");
printf("Press [4] to view image restored with modified nlm filter\n");
printf("Press [ ] to view smooth/edgy areas [RED/BLUE] Ct's\n");
printf("Press [f] to print frame rate\n");
printf("Press [?] to print Noise and Lerp Ct's\n");
printf("Press [q] to exit\n");
glutDisplayFunc(displayFunc);
glutKeyboardFunc(shutDown);
cutilCheckError( cutCreateTimer(&hTimer) );
cutilCheckError( cutStartTimer(hTimer) );
glutTimerFunc(REFRESH_DELAY, timerEvent,0);
glutMainLoop();
cutilDeviceReset();
shrQAFinishExit(argc, (const char **)argv, QA_PASSED);
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main( int argc, char** argv)
{
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
if (!cutCheckCmdLineFlag(argc, (const char **)argv, "noqatest") ||
cutCheckCmdLineFlag(argc, (const char **)argv, "noprompt"))
{
g_bQAReadback = true;
fpsLimit = frameCheckNumber;
}
if (argc > 1) {
if (cutCheckCmdLineFlag(argc, (const char **)argv, "glverify")) {
g_bOpenGLQA = true;
fpsLimit = frameCheckNumber;
}
}
printf("[%s] ", sSDKsample);
if (g_bQAReadback) printf("(Automated Testing)\n");
if (g_bOpenGLQA) printf("(OpenGL Readback)\n");
// Get the path of the filename
char *filename;
if (cutGetCmdLineArgumentstr(argc, (const char**) argv, "image", &filename)) {
image_filename = filename;
}
// load image
char* image_path = cutFindFilePath(image_filename, argv[0]);
if (image_path == 0) {
fprintf(stderr, "Error finding image file '%s'\n", image_filename);
cudaThreadExit();
exit(EXIT_FAILURE);
}
cutilCheckError( cutLoadPPM4ub(image_path, (unsigned char **) &h_img, &width, &height));
if (!h_img) {
printf("Error opening file '%s'\n", image_path);
cudaThreadExit();
exit(-1);
}
printf("Loaded '%s', %d x %d pixels\n", image_path, width, height);
cutGetCmdLineArgumenti(argc, (const char**) argv, "threads", &nthreads);
cutGetCmdLineArgumentf(argc, (const char**) argv, "sigma", &sigma);
runBenchmark = cutCheckCmdLineFlag(argc, (const char**) argv, "bench");
int device;
struct cudaDeviceProp prop;
cudaGetDevice( &device );
cudaGetDeviceProperties( &prop, device );
if( !strncmp( "Tesla", prop.name, 5 ) ) {
printf("Tesla card detected, running the test in benchmark mode (no OpenGL display)\n");
// runBenchmark = CUTTrue;
g_bQAReadback = true;
}
// Benchmark or AutoTest mode detected, no OpenGL
if (runBenchmark == CUTTrue || g_bQAReadback) {
if( cutCheckCmdLineFlag( argc, (const char **)argv, "device" ) )
cutilDeviceInit( argc, argv );
else
cudaSetDevice( cutGetMaxGflopsDeviceId() );
} else {
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with OpenGL/CUDA interop.
initGL(argc, argv);
if( cutCheckCmdLineFlag( argc, (const char **)argv, "device" ) )
cutilGLDeviceInit( argc, argv );
else
cudaGLSetGLDevice( cutGetMaxGflopsDeviceId() );
}
initCudaBuffers();
if (g_bOpenGLQA) {
g_CheckRender = new CheckBackBuffer(width, height, 4);
g_CheckRender->setPixelFormat(GL_RGBA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(true);
}
if (g_bQAReadback) {
// This is the automated testing path
g_CheckRender = new CheckBackBuffer(width, height, 4, false);
g_CheckRender->setPixelFormat(GL_RGBA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(true);
runAutoTest(argc, argv);
cleanup();
cudaThreadExit();
cutilExit(argc, argv);
}
if (runBenchmark) {
benchmark(100);
cleanup();
cudaThreadExit();
exit(0);
}
initGLBuffers();
atexit(cleanup);
glutMainLoop();
cudaThreadExit();
cutilExit(argc, argv);
}
////////////////////////////////////////////////////////////////////////////////
//! Run test
////////////////////////////////////////////////////////////////////////////////
void runGraphicsTest(int argc, char** argv)
{
printf("[%s] ", sSDKsample);
if (g_bOpenGLQA) printf("[OpenGL Readback Comparisons] ");
printf("\n");
if ( cutCheckCmdLineFlag(argc, (const char **)argv, "device") ) {
printf("[%s]\n", argv[0]);
printf(" Does not explicitly support -device=n in OpenGL mode\n");
printf(" To use -device=n, the sample must be running w/o OpenGL\n\n");
printf(" > %s -device=n -qatest\n", argv[0]);
printf("exiting...\n");
exit(0);
}
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with OpenGL/CUDA interop.
if(CUTFalse == initGL( &argc, argv )) {
cudaThreadExit();
return;
}
cudaGLSetGLDevice( cutGetMaxGflopsDeviceId() );
// create FFT plan
CUFFT_SAFE_CALL(cufftPlan2d(&fftPlan, meshW, meshH, CUFFT_C2R) );
// allocate memory
fftInputW = (meshW / 2)+1;
fftInputH = meshH;
fftInputSize = (fftInputW*fftInputH)*sizeof(float2);
cutilSafeCall(cudaMalloc((void **)&d_h0, fftInputSize) );
cutilSafeCall(cudaMalloc((void **)&d_ht, fftInputSize) );
h_h0 = (float2 *) malloc(fftInputSize);
generate_h0();
cutilSafeCall(cudaMemcpy(d_h0, h_h0, fftInputSize, cudaMemcpyHostToDevice) );
cutilSafeCall(cudaMalloc((void **)&d_slope, meshW*meshH*sizeof(float2)) );
cutCreateTimer(&timer);
cutStartTimer(timer);
prevTime = cutGetTimerValue(timer);
// create vertex buffers and register with CUDA
createVBO(&heightVertexBuffer, meshW*meshH*sizeof(float));
// DEPRECATED: cutilSafeCall(cudaGLRegisterBufferObject(heightVertexBuffer));
cutilSafeCall(cudaGraphicsGLRegisterBuffer(&cuda_heightVB_resource, heightVertexBuffer, cudaGraphicsMapFlagsWriteDiscard));
createVBO(&slopeVertexBuffer, meshW*meshH*sizeof(float2));
// DEPRECATED: cutilSafeCall(cudaGLRegisterBufferObject(slopeVertexBuffer));
cutilSafeCall(cudaGraphicsGLRegisterBuffer(&cuda_slopeVB_resource, slopeVertexBuffer, cudaGraphicsMapFlagsWriteDiscard));
// create vertex and index buffer for mesh
createMeshPositionVBO(&posVertexBuffer, meshW, meshH);
createMeshIndexBuffer(&indexBuffer, meshW, meshH);
// Creating the Auto-Validation Code
if (g_bOpenGLQA) {
g_CheckRender = new CheckBackBuffer(windowH, windowH, 4);
g_CheckRender->setPixelFormat(GL_RGBA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(true);
}
runCuda();
// register callbacks
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
// start rendering mainloop
glutMainLoop();
cudaThreadExit();
}
int main(int argc, char** argv)
{
// EDISON //////////////////////////////////////////////////////////////////
sigmaS = 7.0f;
sigmaR = 6.5f;
edison.minRegion = 20.0f;
cutLoadPPMub("image.ppm", &edison.inputImage_, &width, &height);
edison.meanShift();
cutSavePPMub("segmimage.ppm", edison.segmImage_, width, height);
cutSavePPMub("filtimage.ppm", edison.filtImage_, width, height);
unsigned char data[height * width];
memset(data, 0, height * width * sizeof(unsigned char));
for(int i = 0; i < edison.numBoundaries_; i++) {
data[edison.boundaries_[i]] = 255;
}
cutSavePGMub("bndyimage.pgm", data, width, height);
//return 0;
// EDISON //////////////////////////////////////////////////////////////////
if (argc > 1) {
if (cutCheckCmdLineFlag(argc, (const char **)argv, "help")) {
printHelp();
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "qatest") ||
cutCheckCmdLineFlag(argc, (const char **)argv, "noprompt"))
{
g_bQAReadback = true;
fpsLimit = frameCheckNumber;
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "glverify"))
{
g_bOpenGLQA = true;
fpsLimit = frameCheckNumber;
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "fbo")) {
g_bFBODisplay = true;
fpsLimit = frameCheckNumber;
}
}
if (g_bQAReadback) {
runAutoTest(argc, argv);
} else {
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with OpenGL/CUDA interop.
initGL( argc, argv );
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
if( cutCheckCmdLineFlag(argc, (const char**)argv, "device") ) {
cutilGLDeviceInit(argc, argv);
} else {
cudaGLSetGLDevice (cutGetMaxGflopsDeviceId() );
}
int device;
struct cudaDeviceProp prop;
cudaGetDevice( &device );
cudaGetDeviceProperties( &prop, device );
if(!strncmp( "Tesla", prop.name, 5 )) {
printf("This sample needs a card capable of OpenGL and display.\n");
printf("Please choose a different device with the -device=x argument.\n");
cudaThreadExit();
cutilExit(argc, argv);
}
cutilCheckError(cutCreateTimer(&timer));
cutilCheckError(cutResetTimer(timer));
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
if (g_bOpenGLQA) {
loadDefaultImage( argv[0] );
}
if (argc > 1) {
char *filename;
if (cutGetCmdLineArgumentstr(argc, (const char **)argv, "file", &filename)) {
initializeData(filename);
}
} else {
loadDefaultImage( argv[0]);
}
// If code is not printing the USage, then we execute this path.
if (!bQuit) {
if (g_bOpenGLQA) {
g_CheckRender = new CheckBackBuffer(wWidth, wHeight, 4);
g_CheckRender->setPixelFormat(GL_BGRA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(true);
}
printf("I: display image\n");
printf("T: display Sobel edge detection (computed with tex)\n");
printf("S: display Sobel edge detection (computed with tex+shared memory)\n");
printf("Use the '-' and '=' keys to change the brightness.\n");
fflush(stdout);
atexit(cleanup);
glutMainLoop();
}
}
cudaThreadExit();
cutilExit(argc, argv);
}
int main(int argc, char **argv)
{
// Start logs
shrSetLogFileName ("quasirandomGenerator.txt");
shrLog("%s Starting...\n\n", argv[0]);
unsigned int useDoublePrecision;
char *precisionChoice;
cutGetCmdLineArgumentstr(argc, (const char **)argv, "type", &precisionChoice);
if(precisionChoice == NULL)
useDoublePrecision = 0;
else{
if(!strcasecmp(precisionChoice, "double"))
useDoublePrecision = 1;
else
useDoublePrecision = 0;
}
unsigned int tableCPU[QRNG_DIMENSIONS][QRNG_RESOLUTION];
float
*h_OutputGPU;
float
*d_Output;
int
dim, pos;
double
delta, ref, sumDelta, sumRef, L1norm, gpuTime;
unsigned int hTimer;
if(sizeof(INT64) != 8){
shrLog("sizeof(INT64) != 8\n");
return 0;
}
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
if( cutCheckCmdLineFlag(argc, (const char**)argv, "device") )
cutilDeviceInit(argc, argv);
else
cudaSetDevice( cutGetMaxGflopsDeviceId() );
cutilCheckError(cutCreateTimer(&hTimer));
int deviceIndex;
cutilSafeCall(cudaGetDevice(&deviceIndex));
cudaDeviceProp deviceProp;
cutilSafeCall(cudaGetDeviceProperties(&deviceProp, deviceIndex));
int version = deviceProp.major * 10 + deviceProp.minor;
if(useDoublePrecision && version < 13){
shrLog("Double precision not supported.\n");
cudaThreadExit();
return 0;
}
shrLog("Allocating GPU memory...\n");
cutilSafeCall( cudaMalloc((void **)&d_Output, QRNG_DIMENSIONS * N * sizeof(float)) );
shrLog("Allocating CPU memory...\n");
h_OutputGPU = (float *)malloc(QRNG_DIMENSIONS * N * sizeof(float));
shrLog("Initializing QRNG tables...\n\n");
initQuasirandomGenerator(tableCPU);
if(useDoublePrecision)
initTable_SM13(tableCPU);
else
initTable_SM10(tableCPU);
shrLog("Testing QRNG...\n\n");
cutilSafeCall( cudaMemset(d_Output, 0, QRNG_DIMENSIONS * N * sizeof(float)) );
int numIterations = 20;
for (int i = -1; i < numIterations; i++)
{
if (i == 0)
{
cutilSafeCall( cudaThreadSynchronize() );
cutilCheckError( cutResetTimer(hTimer) );
cutilCheckError( cutStartTimer(hTimer) );
}
if(useDoublePrecision)
quasirandomGenerator_SM13(d_Output, 0, N);
else
quasirandomGenerator_SM10(d_Output, 0, N);
}
cutilSafeCall( cudaThreadSynchronize() );
cutilCheckError(cutStopTimer(hTimer));
gpuTime = cutGetTimerValue(hTimer)/(double)numIterations*1e-3;
shrLogEx(LOGBOTH | MASTER, 0, "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);
shrLog("\nReading GPU results...\n");
cutilSafeCall( cudaMemcpy(h_OutputGPU, d_Output, QRNG_DIMENSIONS * N * sizeof(float), cudaMemcpyDeviceToHost) );
shrLog("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);
}
shrLog("L1 norm: %E\n", sumDelta / sumRef);
shrLog("\nTesting inverseCNDgpu()...\n\n");
cutilSafeCall( cudaMemset(d_Output, 0, QRNG_DIMENSIONS * N * sizeof(float)) );
for (int i = -1; i < numIterations; i++)
{
if (i == 0)
{
cutilSafeCall( cudaThreadSynchronize() );
cutilCheckError( cutResetTimer(hTimer) );
cutilCheckError( cutStartTimer(hTimer) );
}
if(useDoublePrecision)
inverseCND_SM13(d_Output, NULL, QRNG_DIMENSIONS * N);
else
inverseCND_SM10(d_Output, NULL, QRNG_DIMENSIONS * N);
}
cutilSafeCall( cudaThreadSynchronize() );
cutilCheckError(cutStopTimer(hTimer));
gpuTime = cutGetTimerValue(hTimer)/(double)numIterations*1e-3;
shrLogEx(LOGBOTH | MASTER, 0, "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);
shrLog("Reading GPU results...\n");
cutilSafeCall( cudaMemcpy(h_OutputGPU, d_Output, QRNG_DIMENSIONS * N * sizeof(float), cudaMemcpyDeviceToHost) );
shrLog("\nComparing to the CPU results...\n");
sumDelta = 0;
sumRef = 0;
for(pos = 0; pos < QRNG_DIMENSIONS * N; pos++){
double p = (double)(pos + 1) / (double)(QRNG_DIMENSIONS * N + 1);
ref = MoroInvCNDcpu(p);
delta = (double)h_OutputGPU[pos] - ref;
sumDelta += fabs(delta);
sumRef += fabs(ref);
}
shrLog("L1 norm: %E\n\n", L1norm = sumDelta / sumRef);
shrLog((L1norm < 1E-6) ? "PASSED\n\n" : "FAILED\n\n");
shrLog("Shutting down...\n");
cutilCheckError(cutDeleteTimer(hTimer));
free(h_OutputGPU);
cutilSafeCall( cudaFree(d_Output) );
cudaThreadExit();
shrEXIT(argc, (const char**)argv);
}
bool
runTestMax( int argc, char** argv, ReduceType datatype)
{
int size = 1<<24; // number of elements to reduce
int maxThreads = 256; // number of threads per block
int whichKernel = 6;
int maxBlocks = 64;
bool cpuFinalReduction = false;
int cpuFinalThreshold = 1;
cutGetCmdLineArgumenti( argc, (const char**) argv, "n", &size);
cutGetCmdLineArgumenti( argc, (const char**) argv, "threads", &maxThreads);
cutGetCmdLineArgumenti( argc, (const char**) argv, "kernel", &whichKernel);
cutGetCmdLineArgumenti( argc, (const char**) argv, "maxblocks", &maxBlocks);
shrLog("METHOD: MAX\n");
shrLog("%d elements\n", size);
shrLog("%d threads (max)\n", maxThreads);
cpuFinalReduction = (cutCheckCmdLineFlag( argc, (const char**) argv, "cpufinal") == CUTTrue);
cutGetCmdLineArgumenti( argc, (const char**) argv, "cputhresh", &cpuFinalThreshold);
bool runShmoo = (cutCheckCmdLineFlag(argc, (const char**) argv, "shmoo") == CUTTrue);
if (runShmoo)
{
shmoo<T>(1, 33554432, maxThreads, maxBlocks, datatype);
}
else
{
// create random input data on CPU
unsigned int bytes = size * sizeof(T);
T *h_idata = (T *) malloc(bytes);
for(int i=0; i<size; i++)
{
// Keep the numbers small so we don't get truncation error in the sum
if (datatype == REDUCE_INT)
h_idata[i] = (T)(rand() & 0xFF);
else
h_idata[i] = (rand() & 0xFF) / (T)RAND_MAX;
}
int numBlocks = 0;
int numThreads = 0;
getNumBlocksAndThreads(whichKernel, size, maxBlocks, maxThreads, numBlocks, numThreads);
if (numBlocks == 1) cpuFinalThreshold = 1;
// allocate mem for the result on host side
T* h_odata = (T*) malloc(numBlocks*sizeof(T));
shrLog("%d blocks\n\n", numBlocks);
// allocate device memory and data
T* d_idata = NULL;
T* d_odata = NULL;
cutilSafeCallNoSync( cudaMalloc((void**) &d_idata, bytes) );
cutilSafeCallNoSync( cudaMalloc((void**) &d_odata, numBlocks*sizeof(T)) );
// copy data directly to device memory
cutilSafeCallNoSync( cudaMemcpy(d_idata, h_idata, bytes, cudaMemcpyHostToDevice) );
cutilSafeCallNoSync( cudaMemcpy(d_odata, h_idata, numBlocks*sizeof(T), cudaMemcpyHostToDevice) );
// warm-up
maxreduce<T>(size, numThreads, numBlocks, whichKernel, d_idata, d_odata);
int testIterations = 100;
unsigned int timer = 0;
cutilCheckError( cutCreateTimer( &timer));
T gpu_result = 0;
gpu_result = benchmarkReduceMax<T>(size, numThreads, numBlocks, maxThreads, maxBlocks,
whichKernel, testIterations, cpuFinalReduction,
cpuFinalThreshold, timer,
h_odata, d_idata, d_odata);
double reduceTime = cutGetAverageTimerValue(timer) * 1e-3;
shrLogEx(LOGBOTH | MASTER, 0, "Reduction, Throughput = %.4f GB/s, Time = %.5f s, Size = %u Elements, NumDevsUsed = %d, Workgroup = %u\n",
1.0e-9 * ((double)bytes)/reduceTime, reduceTime, size, 1, numThreads);
// compute reference solution
T cpu_result = maxreduceCPU<T>(h_idata, size);
double threshold = 1e-12;
double diff = 0;
if (datatype == REDUCE_INT)
{
shrLog("\nGPU result = %d\n", gpu_result);
shrLog("CPU result = %d\n\n", cpu_result);
}
else
{
shrLog("\nGPU result = %f\n", gpu_result);
shrLog("CPU result = %f\n\n", cpu_result);
if (datatype == REDUCE_FLOAT)
threshold = 1e-8 * size;
diff = fabs((double)gpu_result - (double)cpu_result);
}
// cleanup
cutilCheckError( cutDeleteTimer(timer) );
free(h_idata);
free(h_odata);
cutilSafeCallNoSync(cudaFree(d_idata));
cutilSafeCallNoSync(cudaFree(d_odata));
if (datatype == REDUCE_INT) {
return (gpu_result == cpu_result);
} else {
return (diff < threshold);
}
}
return true;
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main( int argc, char** argv)
{
shrQAStart( argc, argv );
shrSetLogFileName ("reduction.txt");
char *reduceMethod;
cutGetCmdLineArgumentstr( argc, (const char**) argv, "method", &reduceMethod);
char *typeChoice;
cutGetCmdLineArgumentstr( argc, (const char**) argv, "type", &typeChoice);
if (0 == typeChoice)
{
typeChoice = (char*)malloc(4 * sizeof(char));
strcpy(typeChoice, "int");
}
ReduceType datatype = REDUCE_INT;
if (!strcasecmp(typeChoice, "float"))
datatype = REDUCE_FLOAT;
else if (!strcasecmp(typeChoice, "double"))
datatype = REDUCE_DOUBLE;
else
datatype = REDUCE_INT;
cudaDeviceProp deviceProp;
deviceProp.major = 1;
deviceProp.minor = 0;
int minimumComputeVersion = 10;
if (datatype == REDUCE_DOUBLE)
{
deviceProp.minor = 3;
minimumComputeVersion = 13;
}
int dev;
if(!cutCheckCmdLineFlag(argc, (const char**)argv, "method") )
{
fprintf(stderr, "MISSING --method FLAG.\nYou must provide --method={ SUM | MIN | MAX }.\n");
exit(1);
}
if( cutCheckCmdLineFlag(argc, (const char**)argv, "device") )
{
cutilDeviceInit(argc, argv);
cutilSafeCallNoSync(cudaGetDevice(&dev));
}
else
{
cutilSafeCallNoSync(cudaChooseDevice(&dev, &deviceProp));
}
cutilSafeCallNoSync(cudaGetDeviceProperties(&deviceProp, dev));
if((deviceProp.major * 10 + deviceProp.minor) >= minimumComputeVersion)
{
shrLog("Using Device %d: %s\n\n", dev, deviceProp.name);
cutilSafeCallNoSync(cudaSetDevice(dev));
}
else
{
shrLog("Error: the selected device does not support the minimum compute capability of %d.%d.\n\n",
minimumComputeVersion / 10, minimumComputeVersion % 10);
cutilDeviceReset();
shrQAFinishExit(argc, (const char **)argv, QA_WAIVED);
}
shrLog("Reducing array of type %s\n\n", typeChoice);
bool bResult = false;
switch (datatype)
{
default:
case REDUCE_INT:
if (strcmp("SUM", reduceMethod) == 0) {
bResult = runTestSum<int>( argc, argv, datatype);
} else if ( strcmp("MAX", reduceMethod) == 0 ) {
bResult = runTestMax<int>( argc, argv, datatype);
} else if ( strcmp("MIN", reduceMethod) == 0 ) {
bResult = runTestMin<int>( argc, argv, datatype);
} else {
fprintf(stderr, "No --method specified!\n");
exit(1);
}
break;
case REDUCE_FLOAT:
if (strcmp("SUM", reduceMethod) == 0) {
bResult = runTestSum<float>( argc, argv, datatype);
} else if ( strcmp("MAX", reduceMethod) == 0 ) {
bResult = runTestMax<float>( argc, argv, datatype);
} else if ( strcmp("MIN", reduceMethod) == 0 ) {
bResult = runTestMin<float>( argc, argv, datatype);
} else {
fprintf(stderr, "No --method specified!\n");
exit(1);
}
break;
case REDUCE_DOUBLE:
if (strcmp("SUM", reduceMethod) == 0) {
bResult = runTestSum<double>( argc, argv, datatype);
} else if ( strcmp("MAX", reduceMethod) == 0 ) {
bResult = runTestMax<double>( argc, argv, datatype);
} else if ( strcmp("MIN", reduceMethod) == 0 ) {
bResult = runTestMin<double>( argc, argv, datatype);
} else {
fprintf(stderr, "No --method specified!\n");
exit(1);
}
break;
}
cutilDeviceReset();
shrQAFinishExit(argc, (const char**)argv, (bResult ? QA_PASSED : QA_FAILED));
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main( int argc, char** argv)
{
//start logs
shrSetLogFileName ("volumeRender.txt");
shrLog("%s Starting...\n\n", argv[0]);
if (cutCheckCmdLineFlag(argc, (const char **)argv, "qatest") ||
cutCheckCmdLineFlag(argc, (const char **)argv, "noprompt"))
{
g_bQAReadback = true;
fpsLimit = frameCheckNumber;
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "glverify"))
{
g_bQAGLVerify = true;
fpsLimit = frameCheckNumber;
}
if (g_bQAReadback) {
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
if( cutCheckCmdLineFlag(argc, (const char**)argv, "device") ) {
cutilDeviceInit(argc, argv);
} else {
cudaSetDevice( cutGetMaxGflopsDeviceId() );
}
} else {
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with OpenGL/CUDA interop.
initGL( &argc, argv );
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
if( cutCheckCmdLineFlag(argc, (const char**)argv, "device") ) {
cutilGLDeviceInit(argc, argv);
} else {
cudaGLSetGLDevice( cutGetMaxGflopsDeviceId() );
}
/*
int device;
struct cudaDeviceProp prop;
cudaGetDevice( &device );
cudaGetDeviceProperties( &prop, device );
if( !strncmp( "Tesla", prop.name, 5 ) ) {
shrLog("This sample needs a card capable of OpenGL and display.\n");
shrLog("Please choose a different device with the -device=x argument.\n");
cutilExit(argc, argv);
}
*/
}
// parse arguments
char *filename;
if (cutGetCmdLineArgumentstr( argc, (const char**) argv, "file", &filename)) {
volumeFilename = filename;
}
int n;
if (cutGetCmdLineArgumenti( argc, (const char**) argv, "size", &n)) {
volumeSize.width = volumeSize.height = volumeSize.depth = n;
}
if (cutGetCmdLineArgumenti( argc, (const char**) argv, "xsize", &n)) {
volumeSize.width = n;
}
if (cutGetCmdLineArgumenti( argc, (const char**) argv, "ysize", &n)) {
volumeSize.height = n;
}
if (cutGetCmdLineArgumenti( argc, (const char**) argv, "zsize", &n)) {
volumeSize.depth = n;
}
// load volume data
char* path = shrFindFilePath(volumeFilename, argv[0]);
if (path == 0) {
shrLog("Error finding file '%s'\n", volumeFilename);
exit(EXIT_FAILURE);
}
size_t size = volumeSize.width*volumeSize.height*volumeSize.depth*sizeof(VolumeType);
void *h_volume = loadRawFile(path, size);
initCuda(h_volume, volumeSize);
free(h_volume);
cutilCheckError( cutCreateTimer( &timer));
shrLog("Press '=' and '-' to change density\n"
" ']' and '[' to change brightness\n"
" ';' and ''' to modify transfer function offset\n"
" '.' and ',' to modify transfer function scale\n\n");
// calculate new grid size
gridSize = dim3(iDivUp(width, blockSize.x), iDivUp(height, blockSize.y));
if (g_bQAReadback) {
g_CheckRender = new CheckBackBuffer(width, height, 4, false);
g_CheckRender->setPixelFormat(GL_RGBA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(true);
uint *d_output;
cutilSafeCall(cudaMalloc((void**)&d_output, width*height*sizeof(uint)));
cutilSafeCall(cudaMemset(d_output, 0, width*height*sizeof(uint)));
float modelView[16] =
{
1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 4.0f, 1.0f
};
invViewMatrix[0] = modelView[0]; invViewMatrix[1] = modelView[4]; invViewMatrix[2] = modelView[8]; invViewMatrix[3] = modelView[12];
invViewMatrix[4] = modelView[1]; invViewMatrix[5] = modelView[5]; invViewMatrix[6] = modelView[9]; invViewMatrix[7] = modelView[13];
invViewMatrix[8] = modelView[2]; invViewMatrix[9] = modelView[6]; invViewMatrix[10] = modelView[10]; invViewMatrix[11] = modelView[14];
// call CUDA kernel, writing results to PBO
copyInvViewMatrix(invViewMatrix, sizeof(float4)*3);
// Start timer 0 and process n loops on the GPU
int nIter = 10;
for (int i = -1; i < nIter; i++)
{
if( i == 0 ) {
cudaThreadSynchronize();
cutStartTimer(timer);
}
render_kernel(gridSize, blockSize, d_output, width, height, density, brightness, transferOffset, transferScale);
}
cudaThreadSynchronize();
cutStopTimer(timer);
// Get elapsed time and throughput, then log to sample and master logs
double dAvgTime = cutGetTimerValue(timer)/(nIter * 1000.0);
shrLogEx(LOGBOTH | MASTER, 0, "volumeRender, Throughput = %.4f MTexels/s, Time = %.5f s, Size = %u Texels, NumDevsUsed = %u, Workgroup = %u\n",
(1.0e-6 * width * height)/dAvgTime, dAvgTime, (width * height), 1, blockSize.x * blockSize.y);
cutilCheckMsg("Error: render_kernel() execution FAILED");
cutilSafeCall( cudaThreadSynchronize() );
cutilSafeCall( cudaMemcpy(g_CheckRender->imageData(), d_output, width*height*4, cudaMemcpyDeviceToHost) );
g_CheckRender->savePPM(sOriginal[g_Index], true, NULL);
if (!g_CheckRender->PPMvsPPM(sOriginal[g_Index], sReference[g_Index], MAX_EPSILON_ERROR, THRESHOLD)) {
shrLog("\nFAILED\n\n");
} else {
shrLog("\nPASSED\n\n");
}
cudaFree(d_output);
freeCudaBuffers();
if (g_CheckRender) {
delete g_CheckRender; g_CheckRender = NULL;
}
} else {
// This is the normal rendering path for VolumeRender
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
initPixelBuffer();
if (g_bQAGLVerify) {
g_CheckRender = new CheckBackBuffer(width, height, 4);
g_CheckRender->setPixelFormat(GL_RGBA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(true);
}
atexit(cleanup);
glutMainLoop();
}
cudaThreadExit();
shrEXIT(argc, (const char**)argv);
}
//////////////////////////////////////////////////////////////////////////////
// Program main
//////////////////////////////////////////////////////////////////////////////
int
main( int argc, char** argv)
{
bool bTestResults = true;
shrQAStart(argc, argv);
if( cutCheckCmdLineFlag(argc, (const char**)argv, "help") ) {
showHelp();
return 0;
}
shrLog("Run \"nbody -benchmark [-n=<numBodies>]\" to measure perfomance.\n");
shrLog("\t-fullscreen (run n-body simulation in fullscreen mode)\n");
shrLog("\t-fp64 (use double precision floating point values for simulation)\n");
shrLog("\t-numdevices=N (use first N CUDA devices for simulation)\n");
// shrLog("\t-hostmem (stores simulation data in host memory)\n");
// shrLog("\t-cpu (performs simulation on the host)\n");
shrLog("\n");
bFullscreen = (cutCheckCmdLineFlag(argc, (const char**) argv, "fullscreen") != 0);
if (bFullscreen)
bShowSliders = false;
benchmark = (cutCheckCmdLineFlag(argc, (const char**) argv, "benchmark") != 0);
compareToCPU = ((cutCheckCmdLineFlag(argc, (const char**) argv, "compare") != 0) ||
(cutCheckCmdLineFlag(argc, (const char**) argv, "qatest") != 0));
QATest = (cutCheckCmdLineFlag(argc, (const char**) argv, "qatest") != 0);
useHostMem = (cutCheckCmdLineFlag(argc, (const char**) argv, "hostmem") != 0);
fp64 = (cutCheckCmdLineFlag(argc, (const char**) argv, "fp64") != 0);
flopsPerInteraction = fp64 ? 30 : 20;
useCpu = (cutCheckCmdLineFlag(argc, (const char**) argv, "cpu") != 0);
cutGetCmdLineArgumenti(argc, (const char**) argv, "numdevices", &numDevsRequested);
// for multi-device we currently require using host memory -- the devices share
// data via the host
if (numDevsRequested > 1)
useHostMem = true;
int numDevsAvailable = 0;
bool customGPU = false;
cudaGetDeviceCount(&numDevsAvailable);
if (numDevsAvailable < numDevsRequested) {
shrLog("Error: only %d Devices available, %d requested. Exiting.\n", numDevsAvailable, numDevsRequested);
shrQAFinishExit(argc, (const char **)argv, QA_PASSED);
}
shrLog("> %s mode\n", bFullscreen ? "Fullscreen" : "Windowed");
shrLog("> Simulation data stored in %s memory\n", useHostMem ? "system" : "video" );
shrLog("> %s precision floating point simulation\n", fp64 ? "Double" : "Single");
shrLog("> %d Devices used for simulation\n", numDevsRequested);
int devID;
cudaDeviceProp props;
// Initialize GL and GLUT if necessary
if (!benchmark && !compareToCPU) {
initGL(&argc, argv);
initParameters();
}
if (useCpu) {
useHostMem = true;
compareToCPU = false;
bSupportDouble = true;
#ifdef OPENMP
shrLog("> Simulation with CPU using OpenMP\n");
#else
shrLog("> Simulation with CPU\n");
#endif
}
else
{
// Now choose the CUDA Device
// Either without GL interop:
if (benchmark || compareToCPU || useHostMem)
{
// Note if we are using host memory for the body system, we
// don't use CUDA-GL interop.
if( cutCheckCmdLineFlag(argc, (const char**)argv, "device") )
{
devID = cutilDeviceInit(argc, argv);
if (devID < 0) {
printf("exiting...\n");
shrQAFinishExit(argc, (const char **)argv, QA_PASSED);
}
customGPU = true;
}
else
{
devID = cutGetMaxGflopsDeviceId();
cudaSetDevice( devID );
}
}
else // or with GL interop:
{
if( cutCheckCmdLineFlag(argc, (const char**)argv, "device") ) {
cutilGLDeviceInit(argc, argv);
customGPU = true;
} else {
devID = cutGetMaxGflopsDeviceId();
cudaGLSetGLDevice( devID );
}
}
cutilSafeCall(cudaGetDevice(&devID));
cutilSafeCall(cudaGetDeviceProperties(&props, devID));
bSupportDouble = true;
#if CUDART_VERSION < 4000
if (numDevsRequested > 1)
{
shrLog("MultiGPU n-body requires CUDA 4.0 or later\n");
cutilDeviceReset();
shrQAFinishExit(argc, (const char**)argv, QA_PASSED);
}
#endif
// Initialize devices
if(numDevsRequested > 1 && customGPU)
{
printf("You can't use --numdevices and --device at the same time.\n");
shrQAFinishExit(argc, (const char**)argv, QA_PASSED);
}
if(customGPU) {
cudaDeviceProp props;
cutilSafeCall(cudaGetDeviceProperties(&props, devID));
shrLog("> Compute %d.%d CUDA device: [%s]\n", props.major, props.minor, props.name);
}
else
{
for (int i = 0; i < numDevsRequested; i++)
{
cudaDeviceProp props;
cutilSafeCall(cudaGetDeviceProperties(&props, i));
shrLog("> Compute %d.%d CUDA device: [%s]\n", props.major, props.minor, props.name);
if (useHostMem)
{
#if CUDART_VERSION >= 2020
if(!props.canMapHostMemory)
{
fprintf(stderr, "Device %d cannot map host memory!\n", devID);
cutilDeviceReset();
shrQAFinishExit(argc, (const char **)argv, QA_PASSED);
}
if (numDevsRequested > 1)
cutilSafeCall(cudaSetDevice(i));
cutilSafeCall(cudaSetDeviceFlags(cudaDeviceMapHost));
#else
fprintf(stderr, "This CUDART version does not support <cudaDeviceProp.canMapHostMemory> field\n");
cutilDeviceReset();
shrQAFinishExit(argc, (const char **)argv, QA_PASSED);
#endif
}
}
// CC 1.2 and earlier do not support double precision
if (props.major*10 + props.minor <= 12)
bSupportDouble = false;
}
//if(numDevsRequested > 1)
// cutilSafeCall(cudaSetDevice(devID));
if (fp64 && !bSupportDouble) {
fprintf(stderr, "One or more of the requested devices does not support double precision floating-point\n");
cutilDeviceReset();
shrQAFinishExit(argc, (const char **)argv, QA_PASSED);
}
}
numIterations = 0;
p = 0;
q = 1;
cutGetCmdLineArgumenti(argc, (const char**) argv, "i", &numIterations);
cutGetCmdLineArgumenti(argc, (const char**) argv, "p", &p);
cutGetCmdLineArgumenti(argc, (const char**) argv, "q", &q);
if (p == 0) // p not set on command line
{
p = 256;
if (q * p > 256)
{
p = 256 / q;
shrLog("Setting p=%d, q=%d to maintain %d threads per block\n", p, q, 256);
}
}
// default number of bodies is #SMs * 4 * CTA size
if (useCpu)
#ifdef OPENMP
numBodies = 8192;
#else
numBodies = 4096;
#endif
else if (numDevsRequested == 1)
