int
main(int argc, char **argv)
{
pArgc = &argc;
pArgv = argv;
char *ref_file = NULL;
printf("%s Starting...\n\n", sSDKsample);
//start logs
if (checkCmdLineFlag(argc, (const char **)argv, "help"))
{
printHelp();
exit(EXIT_SUCCESS);
}
if (checkCmdLineFlag(argc, (const char **)argv, "file"))
{
fpsLimit = frameCheckNumber;
getCmdLineArgumentString(argc, (const char **)argv, "file", &ref_file);
}
if (ref_file)
{
if (checkCmdLineFlag(argc, (const char **)argv, "device"))
{
int device = findCudaDevice(argc, (const char **)argv);
if (device < 0)
{
printf("No CUDA Capable devices found, exiting...\n");
exit(EXIT_SUCCESS);
}
checkDeviceMeetComputeSpec(argc, argv);
}
else
{
int dev = findCapableDevice(argc, argv);
if (dev != -1)
{
cudaSetDevice(dev);
}
else
{
cudaDeviceReset();
exit(EXIT_SUCCESS);
}
}
}
else
{
if (checkCmdLineFlag(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 -file=output.bin\n\n", argv[0]);
printf("exiting...\n");
exit(EXIT_SUCCESS);
}
// 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
{
exit(EXIT_SUCCESS);
}
}
// load volume data
initData(argc, argv);
printf(
"Press \n"
" 'SPACE' to toggle animation\n"
" 'p' to toggle pre-integrated transfer function\n"
" '+' and '-' to change density (0.01 increments)\n"
" ']' and '[' to change brightness\n"
" ';' and ''' to modify transfer function offset\n"
" '.' and ',' to modify transfer function scale\n\n");
if (ref_file)
{
runSingleTest(ref_file, argv[0]);
}
else
{
// This is the normal rendering path for VolumeRender
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
initPixelBuffer();
atexit(cleanup);
glutMainLoop();
}
cudaDeviceReset();
}
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);
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{
// start logs
int devID;
char *ref_file = NULL;
printf("%s Starting...\n\n", argv[0]);
#if defined(__linux__)
setenv ("DISPLAY", ":0", 0);
#endif
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
if (argc > 1)
{
if (checkCmdLineFlag(argc, (const char **)argv, "radius"))
{
filter_radius = getCmdLineArgumentInt(argc, (const char **) argv, "radius");
}
if (checkCmdLineFlag(argc, (const char **)argv, "passes"))
{
iterations = getCmdLineArgumentInt(argc, (const char **)argv, "passes");
}
if (checkCmdLineFlag(argc, (const char **)argv, "file"))
{
getCmdLineArgumentString(argc, (const char **)argv, "file", (char **)&ref_file);
}
}
// load image to process
loadImageData(argc, argv);
if (checkCmdLineFlag(argc, (const char **)argv, "benchmark"))
{
// This is a separate mode of the sample, where we are benchmark the kernels for performance
devID = findCudaDevice(argc, (const char **)argv);
// Running CUDA kernels (bilateralfilter) in Benchmarking mode
g_TotalErrors += runBenchmark(argc, argv);
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
cudaDeviceReset();
exit(g_TotalErrors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
else if (checkCmdLineFlag(argc, (const char **)argv, "radius") ||
checkCmdLineFlag(argc, (const char **)argv, "passes"))
{
// This overrides the default mode. Users can specify the radius used by the filter kernel
devID = findCudaDevice(argc, (const char **)argv);
g_TotalErrors += runSingleTest(ref_file, argv[0]);
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
cudaDeviceReset();
exit(g_TotalErrors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
else
{
// Default mode running with OpenGL visualization and in automatic mode
// the output automatically changes animation
printf("\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, (char **)argv);
int dev = findCapableDevice(argc, argv);
if (dev != -1)
{
dev = gpuGLDeviceInit(argc, (const char **)argv);
if (dev == -1)
{
exit(EXIT_FAILURE);
}
}
else
{
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
cudaDeviceReset();
exit(EXIT_SUCCESS);
}
// Now we can create a CUDA context and bind it to the OpenGL context
initCuda();
initGLResources();
// sets the callback function so it will call cleanup upon exit
#if defined (__APPLE__) || defined(MACOSX)
atexit(cleanup);
#else
glutCloseFunc(cleanup);
#endif
printf("Running Standard Demonstration with GLUT loop...\n\n");
printf("Press '+' and '-' to change filter width\n"
"Press ']' and '[' to change number of iterations\n"
"Press 'e' and 'E' to change Euclidean delta\n"
"Press 'g' and 'G' to changle Gaussian delta\n"
"Press 'a' or 'A' to change Animation mode ON/OFF\n\n");
// Main OpenGL loop that will run visualization for every vsync
glutMainLoop();
}
}
void runAutoTest(int argc, char **argv)
{
printf("[%s] (automated testing w/ readback)\n", sSDKsample);
if( cutCheckCmdLineFlag(argc, (const char**)argv, "device") ) {
cutilDeviceInit(argc, argv);
int device;
cudaGetDevice( &device );
if( checkCUDAProfile( device ) == false ) {
cudaThreadExit();
cutilExit(argc, argv);
}
} else {
int dev = findCapableDevice(argc, argv);
if( dev != -1 )
cudaSetDevice( dev );
else {
cudaThreadExit();
cutilExit(argc, argv);
}
}
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( 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("PASSED\n");
else
printf("FAILED\n");
}
////////////////////////////////////////////////////////////////////////////////
// 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));
}
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);
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main(int argc, char **argv)
{
int devID = 0;
char *ref_file = NULL;
pArgc = &argc;
pArgv = argv;
// start logs
printf("%s Starting...\n\n", argv[0]);
if (checkCmdLineFlag(argc, (const char **)argv, "help"))
{
printHelp();
exit(EXIT_SUCCESS);
}
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
if (argc > 1)
{
if (checkCmdLineFlag(argc, (const char **)argv, "threads"))
{
nthreads = getCmdLineArgumentInt(argc, (const char **) argv, "threads");
}
if (checkCmdLineFlag(argc, (const char **)argv, "radius"))
{
filter_radius = getCmdLineArgumentInt(argc, (const char **) argv, "radius");
}
if (checkCmdLineFlag(argc, (const char **)argv, "passes"))
{
iterations = getCmdLineArgumentInt(argc, (const char **) argv, "passes");
}
if (checkCmdLineFlag(argc, (const char **)argv, "file"))
{
getCmdLineArgumentString(argc, (const char **)argv, "file", (char **)&ref_file);
}
}
// load image to process
loadImageData(argc, argv);
if (checkCmdLineFlag(argc, (const char **)argv, "benchmark"))
{
// This is a separate mode of the sample, where we are benchmark the kernels for performance
devID = findCudaDevice(argc, (const char **)argv);
// Running CUDA kernels (boxfilter) in Benchmarking mode
g_TotalErrors += runBenchmark();
exit(g_TotalErrors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
else if (checkCmdLineFlag(argc, (const char **)argv, "radius") ||
checkCmdLineFlag(argc, (const char **)argv, "passes"))
{
// This overrides the default mode. Users can specify the radius used by the filter kernel
devID = findCudaDevice(argc, (const char **)argv);
g_TotalErrors += runSingleTest(ref_file, argv[0]);
exit(g_TotalErrors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
else
{
// Default mode running with OpenGL visualization and in automatic mode
// the output automatically changes animation
printf("\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);
int dev = findCapableDevice(argc, argv);
if (dev != -1)
{
cudaGLSetGLDevice(dev);
}
else
{
cudaDeviceReset();
exit(EXIT_SUCCESS);
}
// Now we can create a CUDA context and bind it to the OpenGL context
initCuda();
initGLResources();
// sets the callback function so it will call cleanup upon exit
atexit(cleanup);
printf("Running Standard Demonstration with GLUT loop...\n\n");
printf("Press '+' and '-' to change filter width\n"
"Press ']' and '[' to change number of iterations\n"
"Press 'a' or 'A' to change animation ON/OFF\n\n");
// Main OpenGL loop that will run visualization for every vsync
glutMainLoop();
cudaDeviceReset();
exit(g_TotalErrors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
}
int main(int argc, char **argv)
{
pArgc = &argc;
pArgv = argv;
printf("%s Starting...\n\n", argv[0]);
if (checkCmdLineFlag(argc, (const char **)argv, "help"))
{
printf("\nUsage: FunctionPointers (SobelFilter) <options>\n");
printf("\t\t-mode=n (0=original, 1=texture, 2=smem + texture)\n");
printf("\t\t-file=ref_orig.pgm (ref_tex.pgm, ref_shared.pgm)\n\n");
exit(EXIT_WAIVED);
}
if (checkCmdLineFlag(argc, (const char **)argv, "file"))
{
g_bQAReadback = true;
runAutoTest(argc, argv);
}
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
if (checkCmdLineFlag(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\n\n", argv[0]);
printf("exiting...\n");
exit(EXIT_WAIVED);
}
if (!g_bQAReadback)
{
// 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);
checkDeviceMeetComputeSpec(argc, argv);
if (dev != -1)
{
cudaGLSetGLDevice(dev);
}
else
{
exit(EXIT_WAIVED);
}
sdkCreateTimer(&timer);
sdkResetTimer(&timer);
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutReshapeFunc(reshape);
loadDefaultImage(argv[0]);
// If code is not printing the USage, then we execute this path.
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();
}
cudaDeviceReset();
exit(EXIT_SUCCESS);
}
