////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{
    char device_name[256];
    char *ref_file = NULL;

    pArgc = &argc;
    pArgv = argv;

    printf("[%s] - Starting...\n", SDK_name);

    if (!findCUDADevice())               // Search for CUDA GPU
    {
        printf("> CUDA Device NOT found on \"%s\".. Exiting.\n", device_name);
        exit(EXIT_SUCCESS);
    }

    if (!dynlinkLoadD3D10API())              // Search for D3D API (locate drivers, does not mean device is found)
    {
        printf("> D3D10 API libraries NOT found.. Exiting.\n");
        dynlinkUnloadD3D10API();
        exit(EXIT_SUCCESS);
    }

    if (!findDXDevice(device_name))          // Search for D3D Hardware Device
    {
        printf("> D3D10 Graphics Device NOT found.. Exiting.\n");
        dynlinkUnloadD3D10API();
        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);
    }

    // run D3D10/CUDA test
    runTest(argc, argv, ref_file);

    //
    // and exit
    //
    printf("%s running on %s exiting...\n", SDK_name, device_name);

    // 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_bPassed ? EXIT_SUCCESS : EXIT_FAILURE);
}
Esempio n. 2
0
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{
    char device_name[256];
    char *ref_file = NULL;

    pArgc = &argc;
    pArgv = argv;

    printf("[%s] - Starting...\n", SDK_name);

    if (!findCUDADevice())               // Search for CUDA GPU
    {
        printf("> CUDA Device NOT found on \"%s\".. Exiting.\n", device_name);
        exit(EXIT_SUCCESS);
    }

    if (!dynlinkLoadD3D10API())              // Search for D3D API (locate drivers, does not mean device is found)
    {
        printf("> D3D10 API libraries NOT found.. Exiting.\n");
        dynlinkUnloadD3D10API();
        exit(EXIT_SUCCESS);
    }

    if (!findDXDevice(device_name))          // Search for D3D Hardware Device
    {
        printf("> D3D10 Graphics Device NOT found.. Exiting.\n");
        dynlinkUnloadD3D10API();
        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);
    }

    // run D3D10/CUDA test
    runTest(argc, argv, ref_file);

    //
    // and exit
    //
    printf("%s running on %s exiting...\n", SDK_name, device_name);

    cudaDeviceReset();
    exit(g_bPassed ? EXIT_SUCCESS : EXIT_FAILURE);
}
Esempio n. 3
0
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{
    char device_name[256];
    char *ref_file = NULL;

    pArgc = &argc;
    pArgv = argv;

    printf("> %s starting...\n", sSDKSample);

    if (!findCUDADevice())                   // Search for CUDA GPU
    {
        printf("> CUDA Device NOT found on \"%s\".. Exiting.\n", device_name);
        exit(EXIT_SUCCESS);
    }

    if (!dynlinkLoadD3D10API())                  // Search for D3D API (locate drivers, does not mean device is found)
    {
        printf("> D3D10 API libraries NOT found on.. Exiting.\n");
        dynlinkUnloadD3D10API();
        exit(EXIT_SUCCESS);
    }

    if (!findDXDevice(device_name))              // Search for D3D Hardware Device
    {
        printf("> D3D10 Graphics Device NOT found.. Exiting.\n");
        dynlinkUnloadD3D10API();
        exit(EXIT_SUCCESS);
    }

    if (argc > 1)
    {
        if (checkCmdLineFlag(argc, (const char **)argv, "file"))
        {
            getCmdLineArgumentString(argc, (const char **)argv, "file", (char **)&ref_file);
        }
    }

    runTest(argc, argv, ref_file);

    //
    // and exit
    //
    printf("%s running on %s exiting...\n", sSDKSample, device_name);
    printf("%s sample finished returned: %s\n", sSDKSample, (g_bPassed ? "OK" : "ERROR!"));
    exit(g_bPassed ? EXIT_SUCCESS : EXIT_FAILURE);
}
Esempio n. 4
0
////////////////////////////////////////////////////////////////////////////////
//! Run a simple test for CUDA
////////////////////////////////////////////////////////////////////////////////
void runTest(int argc, char **argv, char *ref_file)
{
    // Register the window class
    WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
                      GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
                      "CUDA/D3D10 simpleD3D10", NULL
                    };
    RegisterClassEx(&wc);

    // Create the application's window
    int xBorder = ::GetSystemMetrics(SM_CXSIZEFRAME);
    int yMenu = ::GetSystemMetrics(SM_CYMENU);
    int yBorder = ::GetSystemMetrics(SM_CYSIZEFRAME);
    HWND hWnd = CreateWindow(wc.lpszClassName, "CUDA/D3D10 simpleD3D10",
                             WS_OVERLAPPEDWINDOW, 0, 0, g_WindowWidth + 2*xBorder, g_WindowHeight+ 2*yBorder+yMenu,
                             NULL, NULL, wc.hInstance, NULL);

    // Initialize Direct3D
    if (SUCCEEDED(InitD3D(hWnd)))
    {
        // Create the scene geometry
        if (SUCCEEDED(InitGeometry()))
        {
            // Initialize interoperability between CUDA and Direct3D
            // Register vertex buffer with CUDA
            // DEPRECATED: cudaD3D10RegisterResource(g_pVB, cudaD3D10RegisterFlagsNone);
            cudaGraphicsD3D10RegisterResource(&cuda_VB_resource, g_pVB, cudaD3D10RegisterFlagsNone);
            getLastCudaError("cudaGraphicsD3D10RegisterResource (g_pVB) failed");

            // Initialize vertex buffer with CUDA
            runCuda();

            // Save result
            SaveResult(argc, argv);

            // Show the window
            ShowWindow(hWnd, SW_SHOWDEFAULT);
            UpdateWindow(hWnd);

            // Enter the message loop
            MSG msg;
            ZeroMemory(&msg, sizeof(msg));

            while (msg.message!=WM_QUIT)
            {
                if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
                {
                    TranslateMessage(&msg);
                    DispatchMessage(&msg);
                }
                else
                {
                    Render();

                    if (ref_file != NULL)
                    {
                        for (int count=0; count<g_iFrameToCompare; count++)
                        {
                            Render();
                        }

                        const char *cur_image_path = "simpleD3D10.ppm";

                        // Save a reference of our current test run image
                        CheckRenderD3D10::ActiveRenderTargetToPPM(g_pd3dDevice,cur_image_path);

                        // compare to offical reference image, printing PASS or FAIL.
                        g_bPassed = CheckRenderD3D10::PPMvsPPM(cur_image_path, ref_file, argv[0],MAX_EPSILON, 0.15f);

                        Cleanup();

                        PostQuitMessage(0);
                    }
                }
            }
        }
    }

    // Release D3D Library (after message loop)
    dynlinkUnloadD3D10API();

    UnregisterClass(wc.lpszClassName, wc.hInstance);
}
////////////////////////////////////////////////////////////////////////////////
//! Run a simple test for CUDA
////////////////////////////////////////////////////////////////////////////////
void runTest(int argc, char **argv, char *ref_file)
{
    // Register the window class
    WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
                      GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
                      "CUDA SDK", NULL
                    };
    RegisterClassEx(&wc);

    // Create the application's window
    HWND hWnd = CreateWindow(wc.lpszClassName, "CUDA/D3D10 RenderTarget InterOP",
                             WS_OVERLAPPEDWINDOW, 100, 100, g_WindowWidth, g_WindowHeight,
                             NULL, NULL, wc.hInstance, NULL);

    // Initialize Direct3D
    if (SUCCEEDED(InitD3D(hWnd)))
    {

        // Initialize interoperability between CUDA and Direct3D
        // Register vertex buffer with CUDA
        cudaGraphicsD3D10RegisterResource(&g_histogram.cudaResource, g_histogram.pBuffer, cudaGraphicsMapFlagsNone);
        getLastCudaError("cudaGraphicsD3D10RegisterResource (g_pHistogram) failed");

        // Register color buffer with CUDA
        cudaGraphicsD3D10RegisterResource(&g_color.cudaResource, g_color.pBuffer, cudaGraphicsMapFlagsNone);
        getLastCudaError("cudaGraphicsD3D10RegisterResource (g_color.pBuffer) failed");

        // Show the window
        ShowWindow(hWnd, SW_SHOWDEFAULT);
        UpdateWindow(hWnd);
    }

    //
    // The main loop
    //
    while (false == g_bDone)
    {
        Render();

        //
        // 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
            {
                Render();

                if (ref_file)
                {
                    for (int count=0; count<g_iFrameToCompare; count++)
                    {
                        Render();
                    }

                    const char *cur_image_path = "simpleD3D10RenderTarget.ppm";

                    // Save a reference of our current test run image
                    CheckRenderD3D10::ActiveRenderTargetToPPM(g_pd3dDevice,cur_image_path);

                    // compare to offical reference image, printing PASS or FAIL.
                    g_bPassed = CheckRenderD3D10::PPMvsPPM(cur_image_path, ref_file, argv[0], MAX_EPSILON, 0.15f);

                    g_bDone = true;

                    Cleanup();

                    PostQuitMessage(0);
                }
                else
                {
                    g_bPassed = true;
                }
            }
        }
    }

    // Release D3D Library (after message loop)
    dynlinkUnloadD3D10API();

    // Unregister windows class
    UnregisterClass(wc.lpszClassName, wc.hInstance);
}