//////////////////////////////////////////////////////////////////////////////// // 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; }
int main(int argc, char **argv) { testLibmemcachedCompat(); testAddMultipleTimes(); testRemoveNode(); testRingSorted(); testKnownNextHighestItemOnRing(); testEmptyRingItemSearchReturnsNull(); testEmptyRingSearchReturnsNull(); testKnownSlotsOnRing(); testKnownMultipleSlotsOnRing(); runBenchmark(); return 0; }
//////////////////////////////////////////////////////////////////////////////// // Program main //////////////////////////////////////////////////////////////////////////////// int main(int argc, char **argv) { // Write the xyz file char outfile[256]; sprintf(outfile, "outfile.xyz"); if ((fpout = fopen(outfile, "w")) == NULL) { printf("Cannot Open File\n"); exit(1); } printf("%s Starting...\n\n", sSDKsample); numParticles = NUM_PARTICLES; uint gridDim = GRID_SIZE; numIterations = 0; 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); printf("particles: %d\n", numParticles); cudaInit(argc, argv); initParticleSystem(numParticles, gridSize); printf("%e\n", timestep); //psystem->dumpParticles(0, numParticles-1, 0); if (numIterations <= 0) { numIterations = (int)(2.0/timestep); } std::cout << "1. I am here \n"; runBenchmark(numIterations, argv[0]); std::cout << "2. I am here \n"; if (psystem) { delete psystem; cleanup(); } cudaDeviceReset(); exit(g_TotalErrors > 0 ? EXIT_FAILURE : EXIT_SUCCESS); }
int main(int argc, char* argv[]){ int nrows = 300; int ncols = 300; int rank = 4; int numIter = 10; double tau = 1.5*nrows; double delta = 1.4; double tol = 0.1; // terrible choice of value, but this isn't implemented yet anyways char* file_out = "test.txt"; int ku = 3; // Number of unknown values. int omega_c[] = {0, 5, 7}; // places of unknown values. int kn = (nrows*ncols)-ku; // Number of known values. int omega[kn]; // places of known values. create_omega(omega_c, ku, omega, kn, nrows*ncols); double *Y = alloc_array_z(nrows, ncols); double *Z = alloc_array_z(nrows, ncols); double *dummyMatrix = alloc_array_z(nrows, ncols); double *dummy2 = alloc_array_z(nrows,ncols); double *M = test_mat(rank, nrows, ncols); printf("Number of elements in matrix : %d\n",nrows*ncols); // Number of threads to use. // Run ./a.out 3 for three threads. int num_of_threads = atoi(argv[1]); printf("Asked for %d threads\n", num_of_threads); omp_set_num_threads(num_of_threads); printf("Elapsed time : %1.4f sec\n", runBenchmark( 'P', nrows, ncols, rank, ku, omega_c, kn, omega, numIter, tol, file_out, tau, delta, Y, Z, M, dummyMatrix, dummy2)); printf("RMSE : %1.2g\n", RMSE2(M, Z, omega_c, ku)); // Cleaning up free_array(Y); free_array(M); free_array(dummy2); free_array(Z); free_array(dummyMatrix); return 0; }
//////////////////////////////////////////////////////////////////////////////// // Program main //////////////////////////////////////////////////////////////////////////////// int main(int argc, char **argv) { numParticles = NUM_PARTICLES; uint gridDim = GRID_SIZE; numIterations = 0; if (argc > 1) { if (checkCmdLineFlag(argc, (const char **) argv, "n")) { numParticles = getCmdLineArgumentInt(argc, (const char **)argv, "n"); } if (checkCmdLineFlag(argc, (const char **) argv, "grid")) { gridDim = getCmdLineArgumentInt(argc, (const char **) argv, "grid"); } } 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); printf("particles: %d\n", numParticles); if (checkCmdLineFlag(argc, (const char **) argv, "i")) { numIterations = getCmdLineArgumentInt(argc, (const char **) argv, "i"); } cudaInit(argc, argv); initParticleSystem(numParticles, gridSize); initParams(); if (numIterations <= 0) numIterations = 300; runBenchmark(numIterations, argv[0]); if (psystem) { delete psystem; } exit(g_TotalErrors > 0 ? EXIT_FAILURE : EXIT_SUCCESS); }
void keyboard(unsigned char key, int /*x*/, int /*y*/) { switch (key) { case 27: #if defined(__APPLE__) || defined(MACOSX) exit(EXIT_SUCCESS); #else glutDestroyWindow(glutGetWindow()); return; #endif case '1': g_FilterMode = MODE_NEAREST; break; case '2': g_FilterMode = MODE_BILINEAR; break; case '3': g_FilterMode = MODE_BICUBIC; break; case '4': g_FilterMode = MODE_FAST_BICUBIC; break; case '5': g_FilterMode = MODE_CATMULL_ROM; break; case '=': case '+': scale *= 0.5f; break; case '-': scale *= 2.0f; break; case 'r': scale = 1.0f; tx = ty = 0.0f; break; case 'd': printf("%f, %f, %f\n", tx, ty, scale); break; case 'b': runBenchmark(500); break; case 'c': drawCurves ^= 1; break; default: break; } if (key >= '1' && key <= '5') { printf("> FilterMode[%d] = %s\n", g_FilterMode+1, sFilterMode[g_FilterMode]); } }
//////////////////////////////////////////////////////////////////////////////// // Program main //////////////////////////////////////////////////////////////////////////////// int main(int argc, char **argv) { printf("%s Starting...\n\n", sSDKsample); numParticles = NUM_PARTICLES; maxNumParticles = MAX_NUM_PARTICLES; uint gridDim = GRID_SIZE; numIterations = 0; printf("Surely I can get this far\n"); if (argc > 1) { if (checkCmdLineFlag(argc, (const char **) argv, "n")) { numParticles = getCmdLineArgumentInt(argc, (const char **)argv, "n"); } if (checkCmdLineFlag(argc, (const char **) argv, "grid")) { gridDim = getCmdLineArgumentInt(argc, (const char **) argv, "grid"); } if (checkCmdLineFlag(argc, (const char **)argv, "file")) { getCmdLineArgumentString(argc, (const char **)argv, "file", &g_refFile); fpsLimit = frameCheckNumber; numIterations = 1; } } //******************************************************* // RMK Hard code for cylindrical coords (y=theta=1) // DomainSize //char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-nothot/ZVert.txt"; //char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-nothot/RVert.txt"; //char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-nothot-big/ZVert.txt"; //char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-nothot-big/RVert.txt"; //char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-big/ZVert.txt"; //char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-big/RVert.txt"; //char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-nothot-big-refine/ZVert.txt"; //char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-nothot-big-refine/RVert.txt"; char Zfile[] = "/home/rkeedy/CFD/BuoyantStrumJet85-big-refine-lighter/ZVert.txt"; char Rfile[] = "/home/rkeedy/CFD/BuoyantStrumJet85-big-refine-lighter/RVert.txt"; //char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet62-big-refine-lighter/ZVert.txt"; //char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet62-big-refine-lighter/RVert.txt"; //char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-big-refine/ZVert.txt"; //char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet85-big-refine/RVert.txt"; //char Zfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet63-big-refine/ZVert.txt"; //char Rfile[] = "/home/rkeedy/Dropbox/CFD/BuoyantStrumJet63-big-refine/RVert.txt"; numVelNodes.x = filecount(Rfile); //-1; numVelNodes.z = filecount(Zfile); //-1; numVelNodes.y = 1; numCells.x = 80; //47; //24; //29; numCells.y = 1; numCells.z = 160; //188; //95; //88; numParticles = numCells.x*numCells.z*20; //avgnumparticles = 40 srand( time( NULL ) ); //numParticles = numCells.x*numCells.z*40; printf("vel grid: %d x %d x %d = %d cells\n", numVelNodes.x, numVelNodes.y, numVelNodes.z, numVelNodes.x*numVelNodes.y*numVelNodes.z); printf(" grid: %d x %d x %d = %d cells\n", numCells.x, numCells.y, numCells.z, numCells.x*numCells.y*numCells.z); //printf("vel grid: %d x %d x %d = %d cells\n", gridSize.x, gridSize.y, gridSize.z, gridSize.x*gridSize.y*gridSize.z); bool benchmark = checkCmdLineFlag(argc, (const char **) argv, "benchmark") != 0; if (checkCmdLineFlag(argc, (const char **) argv, "i")) { numIterations = getCmdLineArgumentInt(argc, (const char **) argv, "i"); } if (g_refFile) { cudaInit(argc, argv); } else { if (checkCmdLineFlag(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 -file=<*.bin>\n", argv[0]); printf("exiting...\n"); exit(EXIT_SUCCESS); } initGL(&argc, argv); cudaGLInit(argc, argv); } // Moved code snippet to CellSystem //initCellSystem(gridSize); // now moved to particlesystem printf("Begin initialization\n"); //initParticleSystem(numParticles, gridSize, g_refFile==NULL); initParticleSystem(maxNumParticles, numParticles, numVelNodes, numCells, g_refFile==NULL); //printf("Finished with initParticleSystem, %d\n",g_refFile==NULL); //cin.ignore(); initParams(); printf("Finished with initialization\n"); if (!g_refFile) { initMenus(); } if (benchmark || g_refFile) { if (numIterations <= 0) { numIterations = 300; } runBenchmark(numIterations, argv[0]); } else { glutDisplayFunc(display); glutReshapeFunc(reshape); glutMouseFunc(mouse); glutMotionFunc(motion); glutKeyboardFunc(key); glutSpecialFunc(special); glutIdleFunc(idle); atexit(cleanup); glutMainLoop(); } if (psystem) { delete psystem; } cudaDeviceReset(); exit(g_TotalErrors > 0 ? EXIT_FAILURE : EXIT_SUCCESS); }
//////////////////////////////////////////////////////////////////////////////// // 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(); } }
//////////////////////////////////////////////////////////////////////////////// // 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) { 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; }
//////////////////////////////////////////////////////////////////////////////// // 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); } }
//////////////////////////////////////////////////////////////////////////////// // Program main //////////////////////////////////////////////////////////////////////////////// int main(int argc, char **argv) { #if defined(__linux__) setenv ("DISPLAY", ":0", 0); #endif printf("%s Starting...\n\n", sSDKsample); printf("NOTE: The CUDA Samples are not meant for performance measurements. Results may vary when GPU Boost is enabled.\n\n"); numParticles = NUM_PARTICLES; uint gridDim = GRID_SIZE; numIterations = 0; if (argc > 1) { if (checkCmdLineFlag(argc, (const char **) argv, "n")) { numParticles = getCmdLineArgumentInt(argc, (const char **)argv, "n"); } if (checkCmdLineFlag(argc, (const char **) argv, "grid")) { gridDim = getCmdLineArgumentInt(argc, (const char **) argv, "grid"); } if (checkCmdLineFlag(argc, (const char **)argv, "file")) { getCmdLineArgumentString(argc, (const char **)argv, "file", &g_refFile); fpsLimit = frameCheckNumber; numIterations = 1; } } 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); printf("particles: %d\n", numParticles); bool benchmark = checkCmdLineFlag(argc, (const char **) argv, "benchmark") != 0; if (checkCmdLineFlag(argc, (const char **) argv, "i")) { numIterations = getCmdLineArgumentInt(argc, (const char **) argv, "i"); } if (g_refFile) { cudaInit(argc, argv); } else { if (checkCmdLineFlag(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 -file=<*.bin>\n", argv[0]); printf("exiting...\n"); exit(EXIT_SUCCESS); } initGL(&argc, argv); cudaGLInit(argc, argv); } initParticleSystem(numParticles, gridSize, g_refFile==NULL); initParams(); if (!g_refFile) { initMenus(); } if (benchmark || g_refFile) { if (numIterations <= 0) { numIterations = 300; } runBenchmark(numIterations, argv[0]); } else { glutDisplayFunc(display); glutReshapeFunc(reshape); glutMouseFunc(mouse); glutMotionFunc(motion); glutKeyboardFunc(key); glutSpecialFunc(special); glutIdleFunc(idle); glutCloseFunc(cleanup); glutMainLoop(); } if (psystem) { delete psystem; } // 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_FAILURE : EXIT_SUCCESS); }
void keyboard(unsigned char key, int /*x*/, int /*y*/) { switch (key) { case 27: cleanup(); exit(EXIT_SUCCESS); break; case '1': g_FilterMode = MODE_NEAREST; break; case '2': g_FilterMode = MODE_BILINEAR; break; case '3': g_FilterMode = MODE_BICUBIC; break; case '4': g_FilterMode = MODE_FAST_BICUBIC; break; case '5': g_FilterMode = MODE_CATMULL_ROM; break; case '=': case '+': scale *= 0.5f; break; case '-': scale *= 2.0f; break; case 'r': scale = 1.0f; tx = ty = 0.0f; break; case 'd': printf("%f, %f, %f\n", tx, ty, scale); break; case 'b': runBenchmark(500); break; case 'c': drawCurves ^= 1; break; default: break; } if (key >= '1' && key <= '5') { printf("> FilterMode[%d] = %s\n", g_FilterMode+1, sFilterMode[g_FilterMode]); } }
int main(int argc, char** argv) { int ret = 0, minpw = 0, maxpw = 32; struct sigaction act1, act2; FILE *file = NULL, *wordlist = NULL; bool recovery = false, quiet = false, work_with_user = true, permutation = false; uint8_t *userpassword = NULL; char *charset = NULL, *inputfile = NULL, *wordlistfile = NULL; EncData *e; /** Parse arguments */ while(true) { int c, option_index; static struct option long_options[] = { {"bench", no_argument , 0, 'b'}, {"charset", required_argument, 0, 'c'}, {"file", required_argument, 0, 'f'}, {"loadState",required_argument, 0, 'l'}, {"maxpw", required_argument, 0, 'm'}, {"minpw", required_argument, 0, 'n'}, {"owner", no_argument , 0, 'o'}, {"password", required_argument, 0, 'p'}, {"quiet", required_argument, 0, 'q'}, {"permutate",no_argument, 0, 's'}, {"user", no_argument , 0, 'u'}, {"wordlist", required_argument, 0, 'w'}, {"version", no_argument , 0, 'v'}, {0, 0, 0, 0}}; /* getopt_long stores the option index here. */ option_index = 0; c = getopt_long(argc, argv, "bc:f:l:m:n:op:qsuw:v", long_options, &option_index); /* Detect the end of the options. */ if(c == -1) break; switch(c) { case 'b': runBenchmark(); return 0; case 'c': if(charset) fprintf(stderr,"Charset already set\n"); else charset = strdup(optarg); break; case 'f': if(!recovery) inputfile = strdup(optarg); break; case 'l': if(inputfile) { free(inputfile); inputfile = NULL; } inputfile = strdup(optarg); recovery = true; break; case 'm': maxpw = atoi(optarg); break; case 'n': minpw = atoi(optarg); break; case 'o': work_with_user = false; break; case 'p': userpassword = (uint8_t*)strdup(optarg); work_with_user = false; break; case 'q': quiet = true; break; case 'u': if(!work_with_user) { fprintf(stderr, "Cannot work with both user- and owner-password\n"); exit(1); } work_with_user = true; break; case 's': permutation = true; break; case 'w': if(wordlistfile) fprintf(stderr, "Wordlist already set\n"); else wordlistfile = strdup(optarg); break; case 'v': printf("pdfcrack version %d.%d\n", VERSION_MAJOR, VERSION_MINOR); return 0; default: printHelp(argv[0]); ret = 1; goto out3; } } /** If there are any unhandled arguments and the filename and/or wordlist is not set: try to match the first as the filename and the second as wordlist. */ { int i = optind; if(i > 0) { if(i < argc && !inputfile) inputfile = strdup(argv[i++]); if(i < argc && !wordlistfile) wordlistfile = strdup(argv[i++]); if(i < argc) while(i<argc) { fprintf(stderr,"Non-option argument %s\n", argv[i++]); } } } if(!inputfile || minpw < 0 || maxpw < 0) { printHelp(argv[0]); ret = 1; goto out3; } if((file = fopen(inputfile, "r")) == 0) { fprintf(stderr,"Error: file %s not found\n", inputfile); ret = 2; goto out3; } e = calloc(1,sizeof(EncData)); if(recovery) { if(wordlistfile) { free(wordlistfile); wordlistfile = NULL; } if(!loadState(file, e, &wordlistfile, &work_with_user)) { fprintf(stderr, "Error: Not a savefile or savefile is damaged\n"); ret = 3; goto out1; } if(!quiet) printf("Loaded state for %s\n", inputfile); } else { /** !recovery */ if(!openPDF(file,e)) { fprintf(stderr, "Error: Not a valid PDF\n"); ret = 3; goto out1; } ret = getEncryptedInfo(file, e); if(ret) { if(ret == EENCNF) fprintf(stderr, "Error: Could not extract encryption information\n"); else if(ret == ETRANF || ret == ETRENF || ret == ETRINF) fprintf(stderr, "Error: Encryption not detected (is the document password protected?)\n"); ret = 4; goto out1; } else if(e->revision < 2 || (strcmp(e->s_handler,"Standard") != 0)) { fprintf(stderr, "The specific version is not supported (%s - %d)\n", e->s_handler, e->revision); ret = 5; goto out1; } } if(fclose(file)) { fprintf(stderr, "Error: closing file %s\n", inputfile); } if(minpw > maxpw) { fprintf(stderr, "Warning: minimum pw-length bigger than max\n"); } if(wordlistfile) { if((wordlist = fopen(wordlistfile, "r")) == 0) { fprintf(stderr,"Error: file %s not found\n", wordlistfile); ret = 6; goto out2; } } act2.sa_handler = autoSave; sigfillset(&act2.sa_mask); act2.sa_flags = 0; sigaction(SIGINT, &act2, 0); if(!quiet) { printEncData(e); act1.sa_handler = alarmInterrupt; sigemptyset(&act1.sa_mask); act1.sa_flags = 0; sigaction(SIGALRM, &act1, 0); alarm(PRINTERVAL); } /** Try to initialize the cracking-engine */ if(!initPDFCrack(e, userpassword, work_with_user, wordlistfile, wordlistfile?Wordlist:Generative, wordlist, charset, (unsigned int)minpw, (unsigned int)maxpw, permutation)) { cleanPDFCrack(); fprintf(stderr, "Wrong userpassword, '%s'\n", userpassword); ret = 7; goto out2; } /** Do the actual crunching */ runCrack(); /** cleanup */ cleanPDFCrack(); freeEncData(e); if(wordlistfile) { fclose(wordlist); free(wordlistfile); } if(inputfile) free(inputfile); if(charset) free(charset); if(userpassword) free(userpassword); return 0; out1: if(fclose(file)) fprintf(stderr, "Error: closing file %s\n", inputfile); out2: freeEncData(e); out3: if(inputfile) free(inputfile); if(charset) free(charset); if(userpassword) free(userpassword); exit(ret); }