1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
// cuda-helper-functions.cpp
#include "cuda-helper-functions.h"
#include "cuda-device.h"
namespace gfx
{
#ifdef GFX_ENABLE_CUDA
using namespace Slang;
namespace cuda
{
SlangResult CUDAErrorInfo::handle() const
{
StringBuilder builder;
builder << "Error: " << m_filePath << " (" << m_lineNo << ") :";
if (m_errorName)
{
builder << m_errorName << " : ";
}
if (m_errorString)
{
builder << m_errorString;
}
getDebugCallback()->handleMessage(DebugMessageType::Error, DebugMessageSource::Driver,
builder.getUnownedSlice().begin());
// Slang::signalUnexpectedError(builder.getBuffer());
return SLANG_FAIL;
}
SlangResult _handleCUDAError(CUresult cuResult, const char* file, int line)
{
CUDAErrorInfo info(file, line);
cuGetErrorString(cuResult, &info.m_errorString);
cuGetErrorName(cuResult, &info.m_errorName);
return info.handle();
}
SlangResult _handleCUDAError(cudaError_t error, const char* file, int line)
{
return CUDAErrorInfo(file, line, cudaGetErrorName(error), cudaGetErrorString(error)).handle();
}
# ifdef RENDER_TEST_OPTIX
static bool _isError(OptixResult result)
{
return result != OPTIX_SUCCESS;
}
# if 1
static SlangResult _handleOptixError(OptixResult result, char const* file, int line)
{
fprintf(
stderr,
"%s(%d): optix: %s (%s)\n",
file,
line,
optixGetErrorString(result),
optixGetErrorName(result));
return SLANG_FAIL;
}
void _optixLogCallback(unsigned int level, const char* tag, const char* message, void* userData)
{
fprintf(stderr, "optix: %s (%s)\n", message, tag);
}
# endif
# endif
AdapterLUID getAdapterLUID(int device)
{
AdapterLUID luid = {};
#if SLANG_WIN32 || SLANG_WIN64
// LUID reported by CUDA is undefined i not on windows platform.
cudaDeviceProp prop;
cudaGetDeviceProperties(&prop, device);
SLANG_ASSERT(sizeof(AdapterLUID) >= sizeof(cudaDeviceProp::luid));
memcpy(&luid, prop.luid, sizeof(cudaDeviceProp::luid));
#else
SLANG_ASSERT(sizeof(AdapterLUID) >= sizeof(int));
memcpy(&luid, &device, sizeof(int));
#endif
return luid;
}
} // namespace cuda
Result SLANG_MCALL getCUDAAdapters(List<AdapterInfo>& outAdapters)
{
int deviceCount;
cudaGetDeviceCount(&deviceCount);
for (int device = 0; device < deviceCount; device++)
{
cudaDeviceProp prop;
cudaGetDeviceProperties(&prop, device);
AdapterInfo info = {};
memcpy(info.name, prop.name, Math::Min(strlen(prop.name), sizeof(AdapterInfo::name) - 1));
info.luid = cuda::getAdapterLUID(device);
outAdapters.add(info);
}
return SLANG_OK;
}
Result SLANG_MCALL createCUDADevice(const IDevice::Desc* desc, IDevice** outDevice)
{
RefPtr<cuda::DeviceImpl> result = new cuda::DeviceImpl();
SLANG_RETURN_ON_FAIL(result->initialize(*desc));
returnComPtr(outDevice, result);
return SLANG_OK;
}
#else
Result SLANG_MCALL getCUDAAdapters(List<AdapterInfo>& outAdapters)
{
SLANG_UNUSED(outAdapters);
return SLANG_FAIL;
}
Result SLANG_MCALL createCUDADevice(const IDevice::Desc* desc, IDevice** outDevice)
{
SLANG_UNUSED(desc);
*outDevice = nullptr;
return SLANG_FAIL;
}
#endif
} // namespace gfx
|
