NASP/cuda-samples
85
0
Fork 0
mirror of https://github.com/NVIDIA/cuda-samples.git synced 2026-10-25 22:28:17 +08:00
Code Issues Packages Projects Releases Wiki Activity

Apply consistent code formatting across the repo. Add clang-format and pre-commit hooks.

Browse Source
This commit is contained in:
Rob Armstrong
2025-03-27 10:30:07 -07:00
parent 2cd58fbc9a
commit ceab6e8bcc
782 changed files with 107230 additions and 106548 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Samples/5_Domain_Specific/simpleD3D11/README.md
View File

@@ -34,4 +34,3 @@ Download and install the [CUDA Toolkit 12.5](https://developer.nvidia.com/cuda-d
Make sure the dependencies mentioned in [Dependencies]() section above are installed.
## References (for more details)

15
Samples/5_Domain_Specific/simpleD3D11/ShaderStructs.h
View File

@@ -27,17 +27,22 @@
#pragma once
//#include "stdafx.h"
#include <cuda_runtime.h>
// #include "stdafx.h"
#include <DirectXMath.h>
#include <cuda_runtime.h>
#include "helper_cuda.h"
using namespace DirectX;
struct Vertex
{
XMFLOAT3 position;
XMFLOAT4 color;
XMFLOAT3 position;
XMFLOAT4 color;
};
void RunSineWaveKernel(size_t mesh_width, size_t mesh_height, Vertex *cudaDevVertptr, cudaStream_t streamToRun, float AnimTime);
void RunSineWaveKernel(size_t mesh_width,
size_t mesh_height,
Vertex *cudaDevVertptr,
cudaStream_t streamToRun,
float AnimTime);

380
Samples/5_Domain_Specific/simpleD3D11/simpleD3D11.cpp
View File

@@ -26,25 +26,26 @@
*/
/* This example demonstrates how to use the CUDA-D3D11 External Resource Interoperability APIs
* to update D3D11 buffers from CUDA and synchronize between D3D11 and CUDA with Keyed Mutexes.
* to update D3D11 buffers from CUDA and synchronize between D3D11 and CUDA with Keyed Mutexes.
*/
#pragma warning(disable: 4312)
#pragma warning(disable : 4312)
#include <windows.h>
#include <mmsystem.h>
#include <windows.h>
// This header inclues all the necessary D3D11 and CUDA includes
#include <dynlink_d3d11.h>
#include <dxgi1_2.h>
#include <cuda_runtime_api.h>
#include <cuda_d3d11_interop.h>
#include <cuda_runtime_api.h>
#include <d3dcompiler.h>
#include <dxgi1_2.h>
#include <dynlink_d3d11.h>
// includes, project
#include <rendercheck_d3d11.h>
#include <helper_cuda.h>
#include <helper_functions.h> // includes cuda.h and cuda_runtime_api.h
#include <helper_functions.h> // includes cuda.h and cuda_runtime_api.h
#include <rendercheck_d3d11.h>
#include "ShaderStructs.h"
#include "sinewave_cuda.h"
@@ -55,62 +56,59 @@ static char *SDK_name = "simpleD3D11";
//-----------------------------------------------------------------------------
// Global variables
//-----------------------------------------------------------------------------
IDXGIAdapter1 *g_pCudaCapableAdapter = NULL; // Adapter to use
ID3D11Device *g_pd3dDevice = NULL; // Our rendering device
ID3D11DeviceContext *g_pd3dDeviceContext = NULL;
IDXGISwapChain *g_pSwapChain = NULL; // The swap chain of the window
ID3D11RenderTargetView *g_pSwapChainRTV = NULL; //The Render target view on the swap chain ( used for clear)
ID3D11RasterizerState *g_pRasterState = NULL;
ID3D11InputLayout *g_pInputLayout = NULL;
IDXGIAdapter1 *g_pCudaCapableAdapter = NULL; // Adapter to use
ID3D11Device *g_pd3dDevice = NULL; // Our rendering device
ID3D11DeviceContext *g_pd3dDeviceContext = NULL;
IDXGISwapChain *g_pSwapChain = NULL; // The swap chain of the window
ID3D11RenderTargetView *g_pSwapChainRTV = NULL; // The Render target view on the swap chain ( used for clear)
ID3D11RasterizerState *g_pRasterState = NULL;
ID3D11InputLayout *g_pInputLayout = NULL;
ID3D11VertexShader *g_pVertexShader;
ID3D11PixelShader *g_pPixelShader;
ID3D11InputLayout *g_pLayout;
ID3D11Buffer *g_VertexBuffer;
IDXGIKeyedMutex *g_pKeyedMutex11;
Vertex *d_VertexBufPtr = NULL;
cudaExternalMemory_t extMemory;
Vertex *d_VertexBufPtr = NULL;
cudaExternalMemory_t extMemory;
cudaExternalSemaphore_t extSemaphore;
//
// Vertex and Pixel shaders here : VSMain() & PSMain()
//
static const char g_simpleShaders[] =
"struct PSInput\n" \
"{ \n" \
" float4 position : SV_POSITION;\n" \
" float4 color : COLOR; \n" \
"};\n" \
"PSInput VSMain(float3 position : POSITION, float4 color : COLOR)\n" \
"{ \n" \
" PSInput result;\n" \
" result.position = float4(position, 1.0f); \n" \
" // Pass the color through without modification. \n" \
" result.color = color; \n" \
" return result; \n" \
"} \n" \
"float4 PSMain(PSInput input) : SV_TARGET \n" \
"{ \n" \
" return input.color; \n" \
"} \n" \
;
static const char g_simpleShaders[] = "struct PSInput\n"
"{ \n"
" float4 position : SV_POSITION;\n"
" float4 color : COLOR; \n"
"};\n"
"PSInput VSMain(float3 position : POSITION, float4 color : COLOR)\n"
"{ \n"
" PSInput result;\n"
" result.position = float4(position, 1.0f); \n"
" // Pass the color through without modification. \n"
" result.color = color; \n"
" return result; \n"
"} \n"
"float4 PSMain(PSInput input) : SV_TARGET \n"
"{ \n"
" return input.color; \n"
"} \n";
// testing/tracing function used pervasively in tests. if the condition is unsatisfied
// then spew and fail the function immediately (doing no cleanup)
#define AssertOrQuit(x) \
if (!(x)) \
{ \
#define AssertOrQuit(x) \
if (!(x)) { \
fprintf(stdout, "Assert unsatisfied in %s at %s:%d\n", __FUNCTION__, __FILE__, __LINE__); \
return 1; \
return 1; \
}
bool g_bDone = false;
bool g_bPassed = true;
int *pArgc = NULL;
int *pArgc = NULL;
char **pArgv = NULL;
const unsigned int g_WindowWidth = 720;
const unsigned int g_WindowWidth = 720;
const unsigned int g_WindowHeight = 720;
int g_iFrameToCompare = 10;
@@ -128,7 +126,7 @@ void Render();
LRESULT WINAPI MsgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
#define NAME_LEN 512
#define NAME_LEN 512
bool findCUDADevice()
{
@@ -136,13 +134,11 @@ bool findCUDADevice()
// This function call returns 0 if there are no CUDA capable devices.
checkCudaErrors(cudaGetDeviceCount(&deviceCount));
if (deviceCount == 0)
{
if (deviceCount == 0) {
printf("> There are no device(s) supporting CUDA\n");
return false;
}
else
{
else {
printf("> Found %d CUDA Capable Device(s)\n", deviceCount);
}
@@ -151,41 +147,37 @@ bool findCUDADevice()
bool findDXDevice(char *dev_name)
{
HRESULT hr = S_OK;
HRESULT hr = S_OK;
cudaError cuStatus;
int cuda_dev = -1;
int cuda_dev = -1;
// Iterate through the candidate adapters
IDXGIFactory1 *pFactory;
hr = sFnPtr_CreateDXGIFactory(__uuidof(IDXGIFactory1), (void **)(&pFactory));
if (! SUCCEEDED(hr))
{
if (!SUCCEEDED(hr)) {
printf("> No DXGI Factory created.\n");
return false;
}
UINT adapter = 0;
for (; !g_pCudaCapableAdapter; ++adapter)
{
for (; !g_pCudaCapableAdapter; ++adapter) {
// Get a candidate DXGI adapter
IDXGIAdapter1 *pAdapter = NULL;
hr = pFactory->EnumAdapters1(adapter, &pAdapter);
if (FAILED(hr))
{
break; // no compatible adapters found
if (FAILED(hr)) {
break; // no compatible adapters found
}
// Query to see if there exists a corresponding compute device
int cuDevice;
cuStatus = cudaD3D11GetDevice(&cuDevice, pAdapter);
printLastCudaError("cudaD3D11GetDevice failed"); //This prints and resets the cudaError to cudaSuccess
printLastCudaError("cudaD3D11GetDevice failed"); // This prints and resets the cudaError to cudaSuccess
if (cudaSuccess == cuStatus)
{
if (cudaSuccess == cuStatus) {
// If so, mark it as the one against which to create our d3d11 device
g_pCudaCapableAdapter = pAdapter;
g_pCudaCapableAdapter->AddRef();
@@ -196,12 +188,11 @@ bool findDXDevice(char *dev_name)
pAdapter->Release();
}
printf("> Found %d D3D11 Adapater(s).\n", (int) adapter);
printf("> Found %d D3D11 Adapater(s).\n", (int)adapter);
pFactory->Release();
if (!g_pCudaCapableAdapter)
{
if (!g_pCudaCapableAdapter) {
printf("> Found 0 D3D11 Adapater(s) /w Compute capability.\n");
return false;
}
@@ -225,7 +216,7 @@ bool findDXDevice(char *dev_name)
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char *argv[])
{
char device_name[256];
char device_name[256];
char *ref_file = NULL;
pArgc = &argc;
@@ -233,20 +224,20 @@ int main(int argc, char *argv[])
printf("[%s] - Starting...\n", SDK_name);
if (!findCUDADevice()) // Search for CUDA GPU
if (!findCUDADevice()) // Search for CUDA GPU
{
printf("> CUDA Device NOT found on \"%s\".. Exiting.\n", device_name);
exit(EXIT_SUCCESS);
}
if (!dynlinkLoadD3D11API()) // Search for D3D API (locate drivers, does not mean device is found)
if (!dynlinkLoadD3D11API()) // Search for D3D API (locate drivers, does not mean device is found)
{
printf("> D3D11 API libraries NOT found on.. Exiting.\n");
dynlinkUnloadD3D11API();
exit(EXIT_SUCCESS);
}
if (!findDXDevice(device_name)) // Search for D3D Hardware Device
if (!findDXDevice(device_name)) // Search for D3D Hardware Device
{
printf("> D3D11 Graphics Device NOT found.. Exiting.\n");
dynlinkUnloadD3D11API();
@@ -254,8 +245,7 @@ int main(int argc, char *argv[])
}
// command line options
if (argc > 1)
{
if (argc > 1) {
// automatied build testing harness
if (checkCmdLineFlag(argc, (const char **)argv, "file"))
getCmdLineArgumentString(argc, (const char **)argv, "file", &ref_file);
@@ -265,26 +255,41 @@ int main(int argc, char *argv[])
// create window
//
// Register the window class
WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
"CUDA SDK", NULL
};
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
int xBorder = ::GetSystemMetrics(SM_CXSIZEFRAME);
int yMenu = ::GetSystemMetrics(SM_CYMENU);
int yBorder = ::GetSystemMetrics(SM_CYSIZEFRAME);
HWND hWnd = CreateWindow(wc.lpszClassName, "CUDA/D3D11 InterOP",
WS_OVERLAPPEDWINDOW, 0, 0, g_WindowWidth + 2*xBorder, g_WindowHeight+ 2*yBorder+yMenu,
NULL, NULL, wc.hInstance, NULL);
int xBorder = ::GetSystemMetrics(SM_CXSIZEFRAME);
int yMenu = ::GetSystemMetrics(SM_CYMENU);
int yBorder = ::GetSystemMetrics(SM_CYSIZEFRAME);
HWND hWnd = CreateWindow(wc.lpszClassName,
"CUDA/D3D11 InterOP",
WS_OVERLAPPEDWINDOW,
0,
0,
g_WindowWidth + 2 * xBorder,
g_WindowHeight + 2 * yBorder + yMenu,
NULL,
NULL,
wc.hInstance,
NULL);
ShowWindow(hWnd, SW_SHOWDEFAULT);
UpdateWindow(hWnd);
// Initialize Direct3D
if (!SUCCEEDED(InitD3D(hWnd)))
{
if (!SUCCEEDED(InitD3D(hWnd))) {
printf("InitD3D Failed.. Exiting..\n");
exit(EXIT_FAILURE);
}
@@ -292,8 +297,7 @@ int main(int argc, char *argv[])
//
// the main loop
//
while (false == g_bDone)
{
while (false == g_bDone) {
Render();
//
@@ -302,28 +306,23 @@ int main(int argc, char *argv[])
MSG msg;
ZeroMemory(&msg, sizeof(msg));
while (msg.message!=WM_QUIT)
{
if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
{
while (msg.message != WM_QUIT) {
if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
else {
Render();
if (ref_file)
{
for (int count=0; count<g_iFrameToCompare; count++)
{
if (ref_file) {
for (int count = 0; count < g_iFrameToCompare; count++) {
Render();
}
const char *cur_image_path = "simpleD3D11.ppm";
// Save a reference of our current test run image
CheckRenderD3D11::ActiveRenderTargetToPPM(g_pd3dDevice,cur_image_path);
CheckRenderD3D11::ActiveRenderTargetToPPM(g_pd3dDevice, cur_image_path);
// compare to offical reference image, printing PASS or FAIL.
g_bPassed = CheckRenderD3D11::PPMvsPPM(cur_image_path, ref_file, argv[0], MAX_EPSILON, 0.15f);
@@ -334,13 +333,11 @@ int main(int argc, char *argv[])
PostQuitMessage(0);
}
else
{
else {
g_bPassed = true;
}
}
}
};
// Release D3D Library (after message loop)
@@ -364,45 +361,40 @@ int main(int argc, char *argv[])
//-----------------------------------------------------------------------------
HRESULT InitD3D(HWND hWnd)
{
HRESULT hr = S_OK;
HRESULT hr = S_OK;
cudaError cuStatus;
// Set up the structure used to create the device and swapchain
DXGI_SWAP_CHAIN_DESC sd;
ZeroMemory(&sd, sizeof(sd));
sd.BufferCount = 1;
sd.BufferDesc.Width = g_WindowWidth;
sd.BufferDesc.Height = g_WindowHeight;
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.RefreshRate.Numerator = 60;
sd.BufferCount = 1;
sd.BufferDesc.Width = g_WindowWidth;
sd.BufferDesc.Height = g_WindowHeight;
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.RefreshRate.Numerator = 60;
sd.BufferDesc.RefreshRate.Denominator = 1;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.OutputWindow = hWnd;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.Windowed = TRUE;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.OutputWindow = hWnd;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.Windowed = TRUE;
D3D_FEATURE_LEVEL tour_fl[] =
{
D3D_FEATURE_LEVEL_11_1,
D3D_FEATURE_LEVEL_11_0
};
D3D_FEATURE_LEVEL tour_fl[] = {D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0};
D3D_FEATURE_LEVEL flRes;
// Create device and swapchain
hr = sFnPtr_D3D11CreateDeviceAndSwapChain(
g_pCudaCapableAdapter,
D3D_DRIVER_TYPE_UNKNOWN,//D3D_DRIVER_TYPE_HARDWARE,
NULL, //HMODULE Software
0, //UINT Flags
tour_fl, // D3D_FEATURE_LEVEL* pFeatureLevels
2, //FeatureLevels
D3D11_SDK_VERSION, //UINT SDKVersion
&sd, // DXGI_SWAP_CHAIN_DESC* pSwapChainDesc
&g_pSwapChain, //IDXGISwapChain** ppSwapChain
&g_pd3dDevice, //ID3D11Device** ppDevice
&flRes, //D3D_FEATURE_LEVEL* pFeatureLevel
&g_pd3dDeviceContext//ID3D11DeviceContext** ppImmediateContext
);
hr = sFnPtr_D3D11CreateDeviceAndSwapChain(g_pCudaCapableAdapter,
D3D_DRIVER_TYPE_UNKNOWN, // D3D_DRIVER_TYPE_HARDWARE,
NULL, // HMODULE Software
0, // UINT Flags
tour_fl, // D3D_FEATURE_LEVEL* pFeatureLevels
2, // FeatureLevels
D3D11_SDK_VERSION, // UINT SDKVersion
&sd, // DXGI_SWAP_CHAIN_DESC* pSwapChainDesc
&g_pSwapChain, // IDXGISwapChain** ppSwapChain
&g_pd3dDevice, // ID3D11Device** ppDevice
&flRes, // D3D_FEATURE_LEVEL* pFeatureLevel
&g_pd3dDeviceContext // ID3D11DeviceContext** ppImmediateContext
);
AssertOrQuit(SUCCEEDED(hr));
@@ -424,8 +416,8 @@ HRESULT InitD3D(HWND hWnd)
// Setup the viewport
D3D11_VIEWPORT vp;
vp.Width = g_WindowWidth;
vp.Height = g_WindowHeight;
vp.Width = g_WindowWidth;
vp.Height = g_WindowHeight;
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
vp.TopLeftX = 0;
@@ -438,10 +430,19 @@ HRESULT InitD3D(HWND hWnd)
ID3DBlob *pErrorMsgs;
// Vertex shader
{
hr = D3DCompile(g_simpleShaders, strlen(g_simpleShaders), "Memory", NULL, NULL,"VSMain", "vs_4_0", 0/*Flags1*/, 0/*Flags2*/, &VS, &pErrorMsgs);
hr = D3DCompile(g_simpleShaders,
strlen(g_simpleShaders),
"Memory",
NULL,
NULL,
"VSMain",
"vs_4_0",
0 /*Flags1*/,
0 /*Flags2*/,
&VS,
&pErrorMsgs);
if (FAILED(hr))
{
if (FAILED(hr)) {
const char *pStr = (const char *)pErrorMsgs->GetBufferPointer();
printf(pStr);
}
@@ -454,7 +455,17 @@ HRESULT InitD3D(HWND hWnd)
}
// Pixel shader
{
hr = D3DCompile(g_simpleShaders, strlen(g_simpleShaders), "Memory", NULL, NULL, "PSMain", "ps_4_0", 0/*Flags1*/, 0/*Flags2*/, &PS, &pErrorMsgs);
hr = D3DCompile(g_simpleShaders,
strlen(g_simpleShaders),
"Memory",
NULL,
NULL,
"PSMain",
"ps_4_0",
0 /*Flags1*/,
0 /*Flags2*/,
&PS,
&pErrorMsgs);
AssertOrQuit(SUCCEEDED(hr));
hr = g_pd3dDevice->CreatePixelShader(PS->GetBufferPointer(), PS->GetBufferSize(), NULL, &g_pPixelShader);
@@ -464,26 +475,24 @@ HRESULT InitD3D(HWND hWnd)
}
D3D11_BUFFER_DESC bufferDesc;
bufferDesc.Usage = D3D11_USAGE_DEFAULT;
bufferDesc.ByteWidth = sizeof(Vertex) * g_WindowWidth * g_WindowHeight;
bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bufferDesc.Usage = D3D11_USAGE_DEFAULT;
bufferDesc.ByteWidth = sizeof(Vertex) * g_WindowWidth * g_WindowHeight;
bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bufferDesc.CPUAccessFlags = 0;
bufferDesc.MiscFlags = D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX;
bufferDesc.MiscFlags = D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX;
hr = g_pd3dDevice->CreateBuffer(&bufferDesc, NULL, &g_VertexBuffer);
AssertOrQuit(SUCCEEDED(hr));
hr = g_VertexBuffer->QueryInterface(__uuidof(IDXGIKeyedMutex), (void**)&g_pKeyedMutex11);
hr = g_VertexBuffer->QueryInterface(__uuidof(IDXGIKeyedMutex), (void **)&g_pKeyedMutex11);
AssertOrQuit(SUCCEEDED(hr));
D3D11_INPUT_ELEMENT_DESC inputElementDescs[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
D3D11_INPUT_ELEMENT_DESC inputElementDescs[] = {
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 12, D3D11_INPUT_PER_VERTEX_DATA, 0}};
hr = g_pd3dDevice->CreateInputLayout(inputElementDescs, 2, VS->GetBufferPointer(), VS->GetBufferSize(), &g_pLayout);
hr = g_pd3dDevice->CreateInputLayout(inputElementDescs, 2, VS->GetBufferPointer(), VS->GetBufferSize(), &g_pLayout);
AssertOrQuit(SUCCEEDED(hr));
// Setup Input Layout
g_pd3dDeviceContext->IASetInputLayout(g_pLayout);
@@ -491,34 +500,33 @@ HRESULT InitD3D(HWND hWnd)
g_pd3dDeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_POINTLIST);
AssertOrQuit(SUCCEEDED(hr));
IDXGIResource1* pResource;
HANDLE sharedHandle;
g_VertexBuffer->QueryInterface(__uuidof(IDXGIResource1), (void**)&pResource);
IDXGIResource1 *pResource;
HANDLE sharedHandle;
g_VertexBuffer->QueryInterface(__uuidof(IDXGIResource1), (void **)&pResource);
hr = pResource->GetSharedHandle(&sharedHandle);
if (!SUCCEEDED(hr))
{
if (!SUCCEEDED(hr)) {
std::cout << "Failed GetSharedHandle hr= " << hr << std::endl;
}
// Import the D3D11 Vertex Buffer into CUDA
d_VertexBufPtr = cudaImportVertexBuffer(sharedHandle, extMemory, g_WindowWidth, g_WindowHeight);
pResource->Release();
g_pKeyedMutex11->QueryInterface(__uuidof(IDXGIResource1), (void**)&pResource);
g_pKeyedMutex11->QueryInterface(__uuidof(IDXGIResource1), (void **)&pResource);
pResource->GetSharedHandle(&sharedHandle);
// Import the D3D11 Keyed Mutex into CUDA
cudaImportKeyedMutex(sharedHandle, extSemaphore);
pResource->Release();
D3D11_RASTERIZER_DESC rasterizerState;
rasterizerState.FillMode = D3D11_FILL_SOLID;
rasterizerState.CullMode = D3D11_CULL_FRONT;
rasterizerState.FillMode = D3D11_FILL_SOLID;
rasterizerState.CullMode = D3D11_CULL_FRONT;
rasterizerState.FrontCounterClockwise = false;
rasterizerState.DepthBias = false;
rasterizerState.DepthBiasClamp = 0;
rasterizerState.SlopeScaledDepthBias = 0;
rasterizerState.DepthClipEnable = false;
rasterizerState.ScissorEnable = false;
rasterizerState.MultisampleEnable = false;
rasterizerState.DepthBias = false;
rasterizerState.DepthBiasClamp = 0;
rasterizerState.SlopeScaledDepthBias = 0;
rasterizerState.DepthClipEnable = false;
rasterizerState.ScissorEnable = false;
rasterizerState.MultisampleEnable = false;
rasterizerState.AntialiasedLineEnable = false;
g_pd3dDevice->CreateRasterizerState(&rasterizerState, &g_pRasterState);
g_pd3dDeviceContext->RSSetState(g_pRasterState);
@@ -535,7 +543,7 @@ bool DrawScene(uint64_t &key)
HRESULT hr = S_OK;
// Clear the backbuffer
float ClearColor[4] = { 0.5f, 0.5f, 0.6f, 1.0f };
float ClearColor[4] = {0.5f, 0.5f, 0.6f, 1.0f};
g_pd3dDeviceContext->ClearRenderTargetView(g_pSwapChainRTV, ClearColor);
@@ -544,7 +552,7 @@ bool DrawScene(uint64_t &key)
UINT stride = sizeof(Vertex);
UINT offset = 0;
g_pd3dDeviceContext->IASetVertexBuffers(0, 1, &g_VertexBuffer, &stride, &offset);
g_pd3dDeviceContext->Draw(g_WindowHeight*g_WindowWidth, 0);
g_pd3dDeviceContext->Draw(g_WindowHeight * g_WindowWidth, 0);
hr = g_pKeyedMutex11->ReleaseSync(key);
AssertOrQuit(SUCCEEDED(hr));
@@ -567,38 +575,31 @@ void Cleanup()
// clean up Direct3D
//
// release the resources we created
if (g_pInputLayout != NULL)
{
if (g_pInputLayout != NULL) {
g_pInputLayout->Release();
}
if (g_pVertexShader)
{
if (g_pVertexShader) {
g_pVertexShader->Release();
}
if (g_pPixelShader)
{
if (g_pPixelShader) {
g_pPixelShader->Release();
}
if (g_VertexBuffer)
{
if (g_VertexBuffer) {
g_VertexBuffer->Release();
}
if (g_pSwapChainRTV != NULL)
{
if (g_pSwapChainRTV != NULL) {
g_pSwapChainRTV->Release();
}
if (g_pSwapChain != NULL)
{
if (g_pSwapChain != NULL) {
g_pSwapChain->Release();
}
if (g_pd3dDevice != NULL)
{
if (g_pd3dDevice != NULL) {
g_pd3dDevice->Release();
}
}
@@ -624,30 +625,27 @@ void Render()
//-----------------------------------------------------------------------------
static LRESULT WINAPI MsgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_KEYDOWN:
if (wParam==VK_ESCAPE)
{
g_bDone = true;
Cleanup();
PostQuitMessage(0);
return 0;
}
break;
case WM_DESTROY:
switch (msg) {
case WM_KEYDOWN:
if (wParam == VK_ESCAPE) {
g_bDone = true;
Cleanup();
PostQuitMessage(0);
return 0;
}
case WM_PAINT:
ValidateRect(hWnd, NULL);
return 0;
break;
case WM_DESTROY:
g_bDone = true;
Cleanup();
PostQuitMessage(0);
return 0;
case WM_PAINT:
ValidateRect(hWnd, NULL);
return 0;
}
return DefWindowProc(hWnd, msg, wParam, lParam);
}

74
Samples/5_Domain_Specific/simpleD3D11/sinewave_cuda.cu
View File

@@ -26,46 +26,46 @@
*/
#include <stdio.h>
#include "ShaderStructs.h"
#include "helper_cuda.h"
#include "sinewave_cuda.h"
__global__ void sinewave_gen_kernel(Vertex *vertices, unsigned int width, unsigned int height, float time)
{
unsigned int x = blockIdx.x*blockDim.x + threadIdx.x;
unsigned int y = blockIdx.y*blockDim.y + threadIdx.y;
unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
unsigned int y = blockIdx.y * blockDim.y + threadIdx.y;
// calculate uv coordinates
float u = x / (float) width;
float v = y / (float) height;
u = u*2.0f - 1.0f;
v = v*2.0f - 1.0f;
float u = x / (float)width;
float v = y / (float)height;
u = u * 2.0f - 1.0f;
v = v * 2.0f - 1.0f;
// calculate simple sine wave pattern
float freq = 4.0f;
float w = sinf(u*freq + time) * cosf(v*freq + time) * 0.5f;
float w = sinf(u * freq + time) * cosf(v * freq + time) * 0.5f;
if (y < height && x < width)
{
if (y < height && x < width) {
// write output vertex
vertices[y*width+x].position.x = u;
vertices[y*width+x].position.y = w;
vertices[y*width+x].position.z = v;
vertices[y*width+x].color.x = 1.0f;
vertices[y*width+x].color.y = 0.0f;
vertices[y*width+x].color.z = 0.0f;
vertices[y*width + x].color.w = 0.0f;
vertices[y * width + x].position.x = u;
vertices[y * width + x].position.y = w;
vertices[y * width + x].position.z = v;
vertices[y * width + x].color.x = 1.0f;
vertices[y * width + x].color.y = 0.0f;
vertices[y * width + x].color.z = 0.0f;
vertices[y * width + x].color.w = 0.0f;
}
}
Vertex* cudaImportVertexBuffer(void*sharedHandle, cudaExternalMemory_t &externalMemory, int meshWidth, int meshHeight)
Vertex *cudaImportVertexBuffer(void *sharedHandle, cudaExternalMemory_t &externalMemory, int meshWidth, int meshHeight)
{
cudaExternalMemoryHandleDesc externalMemoryHandleDesc;
memset(&externalMemoryHandleDesc, 0, sizeof(externalMemoryHandleDesc));
externalMemoryHandleDesc.type = cudaExternalMemoryHandleTypeD3D11ResourceKmt;
externalMemoryHandleDesc.size = sizeof(Vertex) * meshHeight * meshWidth;
externalMemoryHandleDesc.flags = cudaExternalMemoryDedicated;
externalMemoryHandleDesc.type = cudaExternalMemoryHandleTypeD3D11ResourceKmt;
externalMemoryHandleDesc.size = sizeof(Vertex) * meshHeight * meshWidth;
externalMemoryHandleDesc.flags = cudaExternalMemoryDedicated;
externalMemoryHandleDesc.handle.win32.handle = sharedHandle;
checkCudaErrors(cudaImportExternalMemory(&externalMemory, &externalMemoryHandleDesc));
@@ -73,31 +73,35 @@ Vertex* cudaImportVertexBuffer(void*sharedHandle, cudaExternalMemory_t &external
cudaExternalMemoryBufferDesc externalMemoryBufferDesc;
memset(&externalMemoryBufferDesc, 0, sizeof(externalMemoryBufferDesc));
externalMemoryBufferDesc.offset = 0;
externalMemoryBufferDesc.size = sizeof(Vertex) * meshHeight * meshWidth;
externalMemoryBufferDesc.flags = 0;
externalMemoryBufferDesc.size = sizeof(Vertex) * meshHeight * meshWidth;
externalMemoryBufferDesc.flags = 0;
Vertex* cudaDevVertptr = NULL;
checkCudaErrors(cudaExternalMemoryGetMappedBuffer((void**)&cudaDevVertptr, externalMemory, &externalMemoryBufferDesc));
Vertex *cudaDevVertptr = NULL;
checkCudaErrors(
cudaExternalMemoryGetMappedBuffer((void **)&cudaDevVertptr, externalMemory, &externalMemoryBufferDesc));
return cudaDevVertptr;
}
void cudaImportKeyedMutex(void*sharedHandle, cudaExternalSemaphore_t &extSemaphore)
void cudaImportKeyedMutex(void *sharedHandle, cudaExternalSemaphore_t &extSemaphore)
{
cudaExternalSemaphoreHandleDesc extSemaDesc;
memset(&extSemaDesc, 0, sizeof(extSemaDesc));
extSemaDesc.type = cudaExternalSemaphoreHandleTypeKeyedMutexKmt;
extSemaDesc.type = cudaExternalSemaphoreHandleTypeKeyedMutexKmt;
extSemaDesc.handle.win32.handle = sharedHandle;
extSemaDesc.flags = 0;
extSemaDesc.flags = 0;
checkCudaErrors(cudaImportExternalSemaphore(&extSemaphore, &extSemaDesc));
}
void cudaAcquireSync(cudaExternalSemaphore_t &extSemaphore, uint64_t key, unsigned int timeoutMs, cudaStream_t streamToRun)
void cudaAcquireSync(cudaExternalSemaphore_t &extSemaphore,
uint64_t key,
unsigned int timeoutMs,
cudaStream_t streamToRun)
{
cudaExternalSemaphoreWaitParams extSemWaitParams;
memset(&extSemWaitParams, 0, sizeof(extSemWaitParams));
extSemWaitParams.params.keyedMutex.key = key;
extSemWaitParams.params.keyedMutex.key = key;
extSemWaitParams.params.keyedMutex.timeoutMs = timeoutMs;
checkCudaErrors(cudaWaitExternalSemaphoresAsync(&extSemaphore, &extSemWaitParams, 1, streamToRun));
@@ -115,18 +119,22 @@ void cudaReleaseSync(cudaExternalSemaphore_t &extSemaphore, uint64_t key, cudaSt
////////////////////////////////////////////////////////////////////////////////
//! Run the Cuda part of the computation
////////////////////////////////////////////////////////////////////////////////
void RunSineWaveKernel(cudaExternalSemaphore_t &extSemaphore, uint64_t &key, unsigned int timeoutMs,
size_t mesh_width, size_t mesh_height, Vertex *cudaDevVertptr, cudaStream_t streamToRun)
void RunSineWaveKernel(cudaExternalSemaphore_t &extSemaphore,
uint64_t &key,
unsigned int timeoutMs,
size_t mesh_width,
size_t mesh_height,
Vertex *cudaDevVertptr,
cudaStream_t streamToRun)
{
static float t = 0.0f;
cudaAcquireSync(extSemaphore, key++, timeoutMs, streamToRun);
dim3 block(16, 16, 1);
dim3 grid(mesh_width / 16, mesh_height / 16, 1);
sinewave_gen_kernel<<< grid, block, 0, streamToRun >>>(cudaDevVertptr, mesh_width, mesh_height, t);
sinewave_gen_kernel<<<grid, block, 0, streamToRun>>>(cudaDevVertptr, mesh_width, mesh_height, t);
getLastCudaError("sinewave_gen_kernel execution failed.\n");
cudaReleaseSync(extSemaphore, key, streamToRun);
t += 0.01f;
}

16
Samples/5_Domain_Specific/simpleD3D11/sinewave_cuda.h
View File

@@ -29,11 +29,17 @@
#define SINEWAVE_CUDA_H
#include <stdio.h>
#include "ShaderStructs.h"
#include "helper_cuda.h"
void RunSineWaveKernel(cudaExternalSemaphore_t &extSemaphore, uint64_t &key, unsigned int timeoutMs,
size_t mesh_width, size_t mesh_height, Vertex *cudaDevVertptr, cudaStream_t streamToRun);
Vertex* cudaImportVertexBuffer(void*sharedHandle, cudaExternalMemory_t &externalMemory, int meshWidth, int meshHeight);
void cudaImportKeyedMutex(void*sharedHandle, cudaExternalSemaphore_t &extSemaphore);
#endif // !
void RunSineWaveKernel(cudaExternalSemaphore_t &extSemaphore,
uint64_t &key,
unsigned int timeoutMs,
size_t mesh_width,
size_t mesh_height,
Vertex *cudaDevVertptr,
cudaStream_t streamToRun);
Vertex *cudaImportVertexBuffer(void *sharedHandle, cudaExternalMemory_t &externalMemory, int meshWidth, int meshHeight);
void cudaImportKeyedMutex(void *sharedHandle, cudaExternalSemaphore_t &extSemaphore);
#endif // !