////////////////////////////////////////////////////////////////////////////////
// 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);
}