////////////////////////////////////////////////////////////////////////////////
//! RestoreContextResources
// - this function restores all of the CUDA/D3D resources and contexts
////////////////////////////////////////////////////////////////////////////////
HRESULT RestoreContextResources()
{
// Reinitialize D3D9 resources, CUDA resources/contexts
InitCUDA();
InitTextures();
RegisterD3D9ResourceWithCUDA();
return S_OK;
}
int main(int argc, char** argv)
{
#ifdef _DEBUG
cout << "***DEBUG BUILD***" << endl;
#endif
ncc::whoami();
InitRun(argc,argv);
InitGlut(argc,argv);
InitHUD();
InitDevIL();
InitPhysX();
InitCUDA();
InitExperiment();
glutMainLoop(); // enter event processing
return 0; // never actually reached.
}
void main( int argc, char** argv)
{
if(!InitCUDA()) {
printf( "Init CUDA failure ! \n");
system("pause");
return ;
}
// initial data
int data_size = 50;
float *dataA = new float[data_size],
*dataB = new float[data_size],
*dataC = new float[data_size],
*dataD = new float[data_size];
for( int i = 0; i < data_size; ++ i )
{
dataA[i] = i;
dataB[i] = -1 * i;
}
// run CPU program
add_vector_cpu( dataA, dataB, dataC, data_size );
// run GPU program
cuda_add_vector( dataA, dataB, dataD, data_size );
// compare the result
for( int i = 0; i < data_size; ++ i )
{
// if( dataC[i] != dataD[i] )
printf( "Error!! (%f & %f)\n", dataC[i], dataD[i] );
}
system("pause");
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char *argv[])
{
char device_name[NAME_LEN];
char *ref_file = NULL;
pArgc = &argc;
pArgv = argv;
printf("[%s] - Starting...\n", SDK_name);
if (!findGraphicsGPU(device_name))
{
printf("> %s not supported on \"%s\" exiting...\n", SDK_name, device_name);
exit(EXIT_SUCCESS);
}
// command line options
if (argc > 1)
{
// automatied build testing harness
if (checkCmdLineFlag(argc, (const char **)argv, "file"))
getCmdLineArgumentString(argc, (const char **)argv, "file", &ref_file);
}
//
// create window
//
// Register the window class
#if 1
WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
"CUDA/D3D9 Texture InterOP", NULL
};
RegisterClassEx(&wc);
int xBorder = ::GetSystemMetrics(SM_CXSIZEFRAME);
int yMenu = ::GetSystemMetrics(SM_CYMENU);
int yBorder = ::GetSystemMetrics(SM_CYSIZEFRAME);
// Create the application's window (padding by window border for uniform BB sizes across OSs)
HWND hWnd = CreateWindow(wc.lpszClassName, "CUDA/D3D9 Texture InterOP",
WS_OVERLAPPEDWINDOW, 0, 0, g_WindowWidth + 2*xBorder, g_WindowHeight+ 2*yBorder+yMenu,
NULL, NULL, wc.hInstance, NULL);
#else
static WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L, GetModuleHandle(NULL), NULL, NULL, NULL, NULL, "CudaD3D9Tex", NULL };
RegisterClassEx(&wc);
HWND hWnd = CreateWindow(
"CudaD3D9Tex", "CUDA D3D9 Texture Interop",
WS_OVERLAPPEDWINDOW,
0, 0, 800, 320,
GetDesktopWindow(),
NULL,
wc.hInstance,
NULL);
#endif
ShowWindow(hWnd, SW_SHOWDEFAULT);
UpdateWindow(hWnd);
// Initialize Direct3D
if (SUCCEEDED(InitD3D9(hWnd)) &&
SUCCEEDED(InitCUDA()) &&
SUCCEEDED(InitTextures()))
{
if (!g_bDeviceLost)
{
RegisterD3D9ResourceWithCUDA();
}
}
//
// the main loop
//
while (false == g_bDone)
{
RunCUDA();
DrawScene();
//
// handle I/O
//
MSG msg;
ZeroMemory(&msg, sizeof(msg));
while (msg.message!=WM_QUIT)
{
if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
RunCUDA();
DrawScene();
if (ref_file)
{
for (int count=0; count<g_iFrameToCompare; count++)
{
RunCUDA();
DrawScene();
}
const char *cur_image_path = "simpleD3D9Texture.ppm";
// Save a reference of our current test run image
CheckRenderD3D9::BackbufferToPPM(g_pD3DDevice, cur_image_path);
// compare to offical reference image, printing PASS or FAIL.
g_bPassed = CheckRenderD3D9::PPMvsPPM(cur_image_path, ref_file, argv[0], MAX_EPSILON, 0.15f);
g_bDone = true;
Cleanup();
PostQuitMessage(0);
}
}
}
};
// Unregister windows class
UnregisterClass(wc.lpszClassName, wc.hInstance);
//
// and exit
//
printf("> %s running on %s exiting...\n", SDK_name, device_name);
exit(g_bPassed ? EXIT_SUCCESS : EXIT_FAILURE);
}
void InitGPU(int device)
{
InitCUDA(device);
}
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;
}
int main(int argc, char* argv[]){
//float beta;
//int row,col;
string file_name = FILE_NAME;
HostMatrix<float> X;
HostMatrix<float> X_test;
HostMatrix<float> Y;
HostMatrix<float> Y_test;
HostMatrix<float> Input;
HostMatrix<float> Target;
std::map<string,int> Classes;
std::map<int,string> ClassesLookup;
readFile(file_name,Input,Target,Classes,ClassesLookup);
int kfold = 1;
int correct_instances = 0;
int incorrect_instances = 0;
int total_instances = 0;
int **confusionMatrix;
confusionMatrix = (int**) malloc(sizeof(int*)*Classes.size());
for(int i = 0; i < (int)Classes.size(); i++){
confusionMatrix[i] = (int*) malloc(sizeof(int)*Classes.size());
memset(confusionMatrix[i],0,sizeof(int)*Classes.size());
}
float Pet_mean = 0;
float Ped_mean = 0;
unsigned int seed = (unsigned)time(0);
/***************RUN INFORMATION*************/
writeHeader(Input,Classes.size(),seed);
/*******************************************/
if(!InitCUDA()) {
return 1;
}
culaStatus status;
status = culaInitialize();
std::cout << "Starting " << std::endl;
float center_time = 0;
float width_time = 0;
float weight_time = 0;
float scaling_time = 0;
unsigned int time_total = 0;
unsigned int testing_time = 0;
unsigned int training_time = 0;
clock_t initialTimeTotal = clock();
do{
X = crossvalidationTrain(Input,KFOLDS,kfold);
X_test = crossvalidationTest(Input,KFOLDS,kfold);
Y = crossvalidationTrain(Target,KFOLDS,kfold);
Y_test = crossvalidationTest(Target,KFOLDS,kfold);
HostMatrix<float> Weights;
HostMatrix<float> Centers;
/*Train Network*/
clock_t initialTime = clock();
RadialBasisFunction RBF(NETWORK_SIZE,RNEIGHBOURS,SCALING_FACTOR,Classes.size());
RBF.SetSeed(seed);
RBF.Train(X,Y);
training_time = (clock() - initialTime);
center_time += RBF.times[0];
width_time += RBF.times[1];
weight_time += RBF.times[2];
scaling_time += RBF.times[3];
/*Test Network*/
initialTime = clock();
std::cout << "Testing" << std::endl;
HostMatrix<float> out_test;
out_test = RBF.Test(X_test);
for(int i = 0; i< X_test.Rows();i++){
float max = 0;
float out_class = 0;
for(int j = 0; j < (int) Classes.size(); j++){
if(out_test(i,j) > max){
out_class = (float)j;
max = out_test(i,j);
}
}
out_test(i,0) = out_class+1;
}
for (int i = 0; i < out_test.Rows(); i++)
{
out_test(i,0) = (float)round(out_test(i,0));
if(out_test(i,0) <= 0) out_test(i,0) = 1;
if(out_test(i,0) > Classes.size()) out_test(i,0) = (float)Classes.size();
std::cout << Y_test(i,0) << " " << out_test(i,0) << std::endl;
}
correct_instances += out_test.Rows() - error_calc(Y_test,out_test);
incorrect_instances += error_calc(Y_test,out_test);
total_instances += out_test.Rows();
/*Add values to Confusion Matrix*/
for(int i = 0; i < Y_test.Rows(); i++){
confusionMatrix[((int)Y_test(i,0))-1][((int)out_test(i,0))-1] = confusionMatrix[((int)Y_test(i,0))-1][((int)out_test(i,0))-1] + 1;
}
testing_time = (clock() - initialTime);
/*Increment fold number, for use in crossvalidation*/
kfold++;
}while(kfold <= KFOLDS);
time_total = (clock() - initialTimeTotal);
/*****************MEASURES****************/
measures(correct_instances,total_instances,incorrect_instances,confusionMatrix,Classes,ClassesLookup);
writeFooter(center_time,width_time,weight_time,scaling_time,training_time,testing_time,time_total);
culaShutdown();
cudaThreadExit();
return 0;
}
