int
main( int argc,char** argv)
{
printf("hello world\n");
if (!InitCUDA())
{
return 0;
}
int iter = 1000;
int trainnum = 20;
bool isProfiler = false;
int intProfiler = 0;
int testnum = -1;
float maxtime = 0.0f;
cutGetCmdLineArgumenti(argc, (const char**) argv, "train", &trainnum);
cutGetCmdLineArgumenti(argc, (const char**) argv, "iter", &iter);
cutGetCmdLineArgumenti(argc, (const char**) argv, "profiler", &intProfiler);
cutGetCmdLineArgumenti(argc, (const char**) argv, "test", &testnum);
cutGetCmdLineArgumentf(argc, (const char**) argv, "maxtime", &maxtime);
printf("%d\n", intProfiler);
if(intProfiler)
{
isProfiler = true;
}
if(testnum == -1) testnum = trainnum /2;
printf("Iter = %d\n", iter);
printf("TrainNum = %d\n", trainnum);
printf("TestNum = %d\n", testnum);
CUT_DEVICE_INIT(argc, argv);
cublasStatus status;
status = cublasInit();
if(status != CUBLAS_STATUS_SUCCESS)
{
printf("Can't init cublas\n");
printf("%s\n", cudaGetErrorString(cudaGetLastError()));
return -1;
}
Image* imageList = new Image[trainnum+testnum];
read64("my_optdigits.tra", imageList, trainnum + testnum);
const int warmUpTime = 3;
if(!isProfiler)
{
freopen("verbose.txt", "w", stdout);
for(int i=0;i< warmUpTime;i++)
{
runImage(argc, argv, imageList, trainnum < warmUpTime ? trainnum : warmUpTime, 0, 10, false, 0.0f);
}
freopen("CON", "w", stdout);
printf("Warm-up complete.\n\n\n");
}
#ifdef _DEBUG
freopen("out.txt", "w", stdout);
#endif // _DEBUG
runImage(argc, argv, imageList, trainnum, testnum, iter, true, maxtime);
freopen("CON", "w", stdout);
delete[] imageList;
//TestReduce();
cublasShutdown();
if(!isProfiler)
{
CUT_EXIT(argc, argv);
}
//getchar();
return 0;
}
////////////////////////////////////////////////////////////////////////////////
// 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);
}
