From dcd4f7f9f08214656f5de5d2510eace8ea8e4826 Mon Sep 17 00:00:00 2001 From: Michael Fabian 'Xaymar' Dirks Date: Tue, 8 Jun 2021 04:42:43 +0200 Subject: [PATCH] nvidia/cuda: Apply coding guidelines --- source/nvidia/cuda/nvidia-cuda.cpp | 134 ++++++++++++++--------------- source/nvidia/cuda/nvidia-cuda.hpp | 107 ++++++++++++----------- 2 files changed, 122 insertions(+), 119 deletions(-) diff --git a/source/nvidia/cuda/nvidia-cuda.cpp b/source/nvidia/cuda/nvidia-cuda.cpp index 5f998592..fb3de9fd 100644 --- a/source/nvidia/cuda/nvidia-cuda.cpp +++ b/source/nvidia/cuda/nvidia-cuda.cpp @@ -36,44 +36,44 @@ #endif #if defined(_WIN32) || defined(_WIN64) -#define CUDA_NAME "nvcuda.dll" +#define ST_CUDA_NAME "nvcuda.dll" #else -#define CUDA_NAME "libcuda.so.1" +#define ST_CUDA_NAME "libcuda.so.1" #endif -#define CUDA_LOAD_SYMBOL(NAME) \ - { \ - NAME = reinterpret_cast(_library->load_symbol(#NAME)); \ - if (!NAME) \ - throw std::runtime_error("Failed to load '" #NAME "' from '" CUDA_NAME "'."); \ +#define P_CUDA_LOAD_SYMBOL(NAME) \ + { \ + NAME = reinterpret_cast(_library->load_symbol(#NAME)); \ + if (!NAME) \ + throw std::runtime_error("Failed to load '" #NAME "' from '" ST_CUDA_NAME "'."); \ } -#define CUDA_LOAD_SYMBOL_OPT(NAME) \ +#define P_CUDA_LOAD_SYMBOL_OPT(NAME) \ { \ NAME = reinterpret_cast(_library->load_symbol(#NAME)); \ if (!NAME) \ D_LOG_WARNING("Loading of optional symbol '" #NAME "' failed.", 0); \ } -#define CUDA_LOAD_SYMBOL_EX(NAME, OVERRIDE) \ - { \ - NAME = reinterpret_cast(_library->load_symbol(#OVERRIDE)); \ - if (!NAME) \ - throw std::runtime_error("Failed to load '" #NAME "' from '" CUDA_NAME "'."); \ +#define P_CUDA_LOAD_SYMBOL_EX(NAME, OVERRIDE) \ + { \ + NAME = reinterpret_cast(_library->load_symbol(#OVERRIDE)); \ + if (!NAME) \ + throw std::runtime_error("Failed to load '" #NAME "' from '" ST_CUDA_NAME "'."); \ } -#define CUDA_LOAD_SYMBOL_OPT_EX(NAME, OVERRIDE) \ +#define P_CUDA_LOAD_SYMBOL_OPT_EX(NAME, OVERRIDE) \ { \ NAME = reinterpret_cast(_library->load_symbol(#OVERRIDE)); \ if (!NAME) \ D_LOG_WARNING("Loading of optional symbol '" #NAME "' failed.", 0); \ } -#define CUDA_LOAD_SYMBOL_V2(NAME) \ - { \ - NAME = reinterpret_cast(_library->load_symbol(#NAME "_v2")); \ - if (!NAME) \ - throw std::runtime_error("Failed to load '" #NAME "' from '" CUDA_NAME "'."); \ +#define P_CUDA_LOAD_SYMBOL_V2(NAME) \ + { \ + NAME = reinterpret_cast(_library->load_symbol(#NAME "_v2")); \ + if (!NAME) \ + throw std::runtime_error("Failed to load '" #NAME "' from '" ST_CUDA_NAME "'."); \ } -#define CUDA_LOAD_SYMBOL_OPT_V2(NAME) \ +#define P_CUDA_LOAD_SYMBOL_OPT_V2(NAME) \ { \ NAME = reinterpret_cast(_library->load_symbol(#NAME "_v2")); \ if (!NAME) \ @@ -91,14 +91,14 @@ nvidia::cuda::cuda::cuda() : _library() D_LOG_DEBUG("Initialization... (Addr: 0x%" PRIuPTR ")", this); - _library = streamfx::util::library::load(std::string_view(CUDA_NAME)); + _library = streamfx::util::library::load(std::string_view(ST_CUDA_NAME)); { // 1. Load critical initialization functions. // Initialization - CUDA_LOAD_SYMBOL(cuInit); + P_CUDA_LOAD_SYMBOL(cuInit); // Version Management - CUDA_LOAD_SYMBOL(cuDriverGetVersion); + P_CUDA_LOAD_SYMBOL(cuDriverGetVersion); } { // 2. Get the CUDA Driver version and log it. @@ -117,44 +117,44 @@ nvidia::cuda::cuda::cuda() : _library() // - Not yet needed. // Primary Context Management - CUDA_LOAD_SYMBOL(cuDevicePrimaryCtxRetain); - CUDA_LOAD_SYMBOL_V2(cuDevicePrimaryCtxRelease); - CUDA_LOAD_SYMBOL_OPT_V2(cuDevicePrimaryCtxSetFlags); + P_CUDA_LOAD_SYMBOL(cuDevicePrimaryCtxRetain); + P_CUDA_LOAD_SYMBOL_V2(cuDevicePrimaryCtxRelease); + P_CUDA_LOAD_SYMBOL_OPT_V2(cuDevicePrimaryCtxSetFlags); // Context Management - CUDA_LOAD_SYMBOL_V2(cuCtxCreate); - CUDA_LOAD_SYMBOL_V2(cuCtxDestroy); - CUDA_LOAD_SYMBOL_V2(cuCtxPushCurrent); - CUDA_LOAD_SYMBOL_V2(cuCtxPopCurrent); - CUDA_LOAD_SYMBOL_OPT(cuCtxGetCurrent); - CUDA_LOAD_SYMBOL_OPT(cuCtxSetCurrent); - CUDA_LOAD_SYMBOL(cuCtxGetStreamPriorityRange); - CUDA_LOAD_SYMBOL(cuCtxSynchronize); + P_CUDA_LOAD_SYMBOL_V2(cuCtxCreate); + P_CUDA_LOAD_SYMBOL_V2(cuCtxDestroy); + P_CUDA_LOAD_SYMBOL_V2(cuCtxPushCurrent); + P_CUDA_LOAD_SYMBOL_V2(cuCtxPopCurrent); + P_CUDA_LOAD_SYMBOL_OPT(cuCtxGetCurrent); + P_CUDA_LOAD_SYMBOL_OPT(cuCtxSetCurrent); + P_CUDA_LOAD_SYMBOL(cuCtxGetStreamPriorityRange); + P_CUDA_LOAD_SYMBOL(cuCtxSynchronize); // Module Management // - Not yet needed. // Memory Management - CUDA_LOAD_SYMBOL_V2(cuMemAlloc); - CUDA_LOAD_SYMBOL_V2(cuMemAllocPitch); - CUDA_LOAD_SYMBOL_V2(cuMemFree); - CUDA_LOAD_SYMBOL(cuMemcpy); - CUDA_LOAD_SYMBOL_V2(cuMemcpy2D); - CUDA_LOAD_SYMBOL_V2(cuMemcpy2DAsync); - CUDA_LOAD_SYMBOL_OPT_V2(cuArrayGetDescriptor); - CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyAtoA); - CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyAtoD); - CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyAtoH); - CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyAtoHAsync); - CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyDtoA); - CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyDtoD); - CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyDtoH); - CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyDtoHAsync); - CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyHtoA); - CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyHtoAAsync); - CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyHtoD); - CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyHtoDAsync); - CUDA_LOAD_SYMBOL_OPT_V2(cuMemHostGetDevicePointer); + P_CUDA_LOAD_SYMBOL_V2(cuMemAlloc); + P_CUDA_LOAD_SYMBOL_V2(cuMemAllocPitch); + P_CUDA_LOAD_SYMBOL_V2(cuMemFree); + P_CUDA_LOAD_SYMBOL(cuMemcpy); + P_CUDA_LOAD_SYMBOL_V2(cuMemcpy2D); + P_CUDA_LOAD_SYMBOL_V2(cuMemcpy2DAsync); + P_CUDA_LOAD_SYMBOL_OPT_V2(cuArrayGetDescriptor); + P_CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyAtoA); + P_CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyAtoD); + P_CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyAtoH); + P_CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyAtoHAsync); + P_CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyDtoA); + P_CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyDtoD); + P_CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyDtoH); + P_CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyDtoHAsync); + P_CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyHtoA); + P_CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyHtoAAsync); + P_CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyHtoD); + P_CUDA_LOAD_SYMBOL_OPT_V2(cuMemcpyHtoDAsync); + P_CUDA_LOAD_SYMBOL_OPT_V2(cuMemHostGetDevicePointer); // Virtual Memory Management // - Not yet needed. @@ -166,11 +166,11 @@ nvidia::cuda::cuda::cuda() : _library() // - Not yet needed. // Stream Management - CUDA_LOAD_SYMBOL(cuStreamCreate); - CUDA_LOAD_SYMBOL_V2(cuStreamDestroy); - CUDA_LOAD_SYMBOL(cuStreamSynchronize); - CUDA_LOAD_SYMBOL_OPT(cuStreamCreateWithPriority); - CUDA_LOAD_SYMBOL_OPT(cuStreamGetPriority); + P_CUDA_LOAD_SYMBOL(cuStreamCreate); + P_CUDA_LOAD_SYMBOL_V2(cuStreamDestroy); + P_CUDA_LOAD_SYMBOL(cuStreamSynchronize); + P_CUDA_LOAD_SYMBOL_OPT(cuStreamCreateWithPriority); + P_CUDA_LOAD_SYMBOL_OPT(cuStreamGetPriority); // Event Management // - Not yet needed. @@ -200,10 +200,10 @@ nvidia::cuda::cuda::cuda() : _library() // - Not yet needed. // Graphics Interoperability - CUDA_LOAD_SYMBOL(cuGraphicsMapResources); - CUDA_LOAD_SYMBOL(cuGraphicsSubResourceGetMappedArray); - CUDA_LOAD_SYMBOL(cuGraphicsUnmapResources); - CUDA_LOAD_SYMBOL(cuGraphicsUnregisterResource); + P_CUDA_LOAD_SYMBOL(cuGraphicsMapResources); + P_CUDA_LOAD_SYMBOL(cuGraphicsSubResourceGetMappedArray); + P_CUDA_LOAD_SYMBOL(cuGraphicsUnmapResources); + P_CUDA_LOAD_SYMBOL(cuGraphicsUnregisterResource); // Driver Entry Point Access // - Not yet needed. @@ -225,12 +225,12 @@ nvidia::cuda::cuda::cuda() : _library() // - Not yet needed. // Direct3D10 Interoperability - CUDA_LOAD_SYMBOL(cuD3D10GetDevice); - CUDA_LOAD_SYMBOL_OPT(cuGraphicsD3D10RegisterResource); + P_CUDA_LOAD_SYMBOL(cuD3D10GetDevice); + P_CUDA_LOAD_SYMBOL_OPT(cuGraphicsD3D10RegisterResource); // Direct3D11 Interoperability - CUDA_LOAD_SYMBOL(cuD3D11GetDevice); - CUDA_LOAD_SYMBOL_OPT(cuGraphicsD3D11RegisterResource); + P_CUDA_LOAD_SYMBOL(cuD3D11GetDevice); + P_CUDA_LOAD_SYMBOL_OPT(cuGraphicsD3D11RegisterResource); #endif } diff --git a/source/nvidia/cuda/nvidia-cuda.hpp b/source/nvidia/cuda/nvidia-cuda.hpp index 64e66a1c..d2c9836b 100644 --- a/source/nvidia/cuda/nvidia-cuda.hpp +++ b/source/nvidia/cuda/nvidia-cuda.hpp @@ -32,7 +32,7 @@ #pragma warning(pop) #endif -#define CUDA_DEFINE_FUNCTION(name, ...) \ +#define P_CUDA_DEFINE_FUNCTION(name, ...) \ private: \ typedef ::nvidia::cuda::result (*t##name)(__VA_ARGS__); \ \ @@ -186,55 +186,57 @@ namespace nvidia::cuda { public: // Initialization - CUDA_DEFINE_FUNCTION(cuInit, int32_t flags); + P_CUDA_DEFINE_FUNCTION(cuInit, int32_t flags); // Version Management - CUDA_DEFINE_FUNCTION(cuDriverGetVersion, int32_t* driverVersion); + P_CUDA_DEFINE_FUNCTION(cuDriverGetVersion, int32_t* driverVersion); // Device Management // - Not yet needed. // Primary Context Management - CUDA_DEFINE_FUNCTION(cuDevicePrimaryCtxRelease, device_t device); - CUDA_DEFINE_FUNCTION(cuDevicePrimaryCtxRetain, context_t* ctx, device_t device); - CUDA_DEFINE_FUNCTION(cuDevicePrimaryCtxSetFlags, device_t device, context_flags flags); + P_CUDA_DEFINE_FUNCTION(cuDevicePrimaryCtxRelease, device_t device); + P_CUDA_DEFINE_FUNCTION(cuDevicePrimaryCtxRetain, context_t* ctx, device_t device); + P_CUDA_DEFINE_FUNCTION(cuDevicePrimaryCtxSetFlags, device_t device, context_flags flags); // Context Management - CUDA_DEFINE_FUNCTION(cuCtxCreate, context_t* ctx, context_flags flags, device_t device); - CUDA_DEFINE_FUNCTION(cuCtxDestroy, context_t ctx); - CUDA_DEFINE_FUNCTION(cuCtxGetCurrent, context_t* ctx); - CUDA_DEFINE_FUNCTION(cuCtxGetStreamPriorityRange, int32_t* lowestPriority, int32_t* highestPriority); - CUDA_DEFINE_FUNCTION(cuCtxPopCurrent, context_t* ctx); - CUDA_DEFINE_FUNCTION(cuCtxPushCurrent, context_t ctx); - CUDA_DEFINE_FUNCTION(cuCtxSetCurrent, context_t ctx); - CUDA_DEFINE_FUNCTION(cuCtxSynchronize); + P_CUDA_DEFINE_FUNCTION(cuCtxCreate, context_t* ctx, context_flags flags, device_t device); + P_CUDA_DEFINE_FUNCTION(cuCtxDestroy, context_t ctx); + P_CUDA_DEFINE_FUNCTION(cuCtxGetCurrent, context_t* ctx); + P_CUDA_DEFINE_FUNCTION(cuCtxGetStreamPriorityRange, int32_t* lowestPriority, int32_t* highestPriority); + P_CUDA_DEFINE_FUNCTION(cuCtxPopCurrent, context_t* ctx); + P_CUDA_DEFINE_FUNCTION(cuCtxPushCurrent, context_t ctx); + P_CUDA_DEFINE_FUNCTION(cuCtxSetCurrent, context_t ctx); + P_CUDA_DEFINE_FUNCTION(cuCtxSynchronize); // Module Management // - Not yet needed. // Memory Management - CUDA_DEFINE_FUNCTION(cuArrayGetDescriptor, array_descriptor_v2_t* pArrayDescripter, array_t array); - CUDA_DEFINE_FUNCTION(cuMemAlloc, device_ptr_t* ptr, std::size_t bytes); - CUDA_DEFINE_FUNCTION(cuMemAllocPitch, device_ptr_t* ptr, std::size_t* pitch, std::size_t width_in_bytes, - std::size_t height, uint32_t element_size_bytes); - CUDA_DEFINE_FUNCTION(cuMemFree, device_ptr_t ptr); - CUDA_DEFINE_FUNCTION(cuMemHostGetDevicePointer, device_ptr_t* devptr, void* ptr, uint32_t flags); - CUDA_DEFINE_FUNCTION(cuMemcpy, device_ptr_t dst, device_ptr_t src, std::size_t bytes); - CUDA_DEFINE_FUNCTION(cuMemcpy2D, const memcpy2d_v2_t* copy); - CUDA_DEFINE_FUNCTION(cuMemcpy2DAsync, const memcpy2d_v2_t* copy, stream_t stream); - CUDA_DEFINE_FUNCTION(cuMemcpyAtoA, array_t dst, std::size_t dstOffset, array_t src, std::size_t srcOffset, - std::size_t byteCount); - CUDA_DEFINE_FUNCTION(cuMemcpyAtoD, device_ptr_t dst, array_t src, std::size_t srcOffset, std::size_t byteCount); - CUDA_DEFINE_FUNCTION(cuMemcpyAtoH, void* dst, array_t src, std::size_t srcOffset, std::size_t byteCount); - CUDA_DEFINE_FUNCTION(cuMemcpyAtoHAsync, void* dst, array_t src, std::size_t srcOffset, std::size_t byteCount); - CUDA_DEFINE_FUNCTION(cuMemcpyDtoA, array_t dst, std::size_t dstOffset, device_ptr_t src, std::size_t byteCount); - CUDA_DEFINE_FUNCTION(cuMemcpyDtoD, device_ptr_t dst, array_t srcArray, std::size_t byteCount); - CUDA_DEFINE_FUNCTION(cuMemcpyDtoH, void* dst, array_t src, std::size_t byteCount); - CUDA_DEFINE_FUNCTION(cuMemcpyDtoHAsync, void* dst, array_t src, std::size_t byteCount); - CUDA_DEFINE_FUNCTION(cuMemcpyHtoA, array_t dst, std::size_t dstOffset, void* src, std::size_t byteCount); - CUDA_DEFINE_FUNCTION(cuMemcpyHtoAAsync, array_t dst, std::size_t dstOffset, void* src, std::size_t byteCount); - CUDA_DEFINE_FUNCTION(cuMemcpyHtoD, device_ptr_t dst, void* src, std::size_t byteCount); - CUDA_DEFINE_FUNCTION(cuMemcpyHtoDAsync, device_ptr_t dst, void* src, std::size_t byteCount); + P_CUDA_DEFINE_FUNCTION(cuArrayGetDescriptor, array_descriptor_v2_t* pArrayDescripter, array_t array); + P_CUDA_DEFINE_FUNCTION(cuMemAlloc, device_ptr_t* ptr, std::size_t bytes); + P_CUDA_DEFINE_FUNCTION(cuMemAllocPitch, device_ptr_t* ptr, std::size_t* pitch, std::size_t width_in_bytes, + std::size_t height, uint32_t element_size_bytes); + P_CUDA_DEFINE_FUNCTION(cuMemFree, device_ptr_t ptr); + P_CUDA_DEFINE_FUNCTION(cuMemHostGetDevicePointer, device_ptr_t* devptr, void* ptr, uint32_t flags); + P_CUDA_DEFINE_FUNCTION(cuMemcpy, device_ptr_t dst, device_ptr_t src, std::size_t bytes); + P_CUDA_DEFINE_FUNCTION(cuMemcpy2D, const memcpy2d_v2_t* copy); + P_CUDA_DEFINE_FUNCTION(cuMemcpy2DAsync, const memcpy2d_v2_t* copy, stream_t stream); + P_CUDA_DEFINE_FUNCTION(cuMemcpyAtoA, array_t dst, std::size_t dstOffset, array_t src, std::size_t srcOffset, + std::size_t byteCount); + P_CUDA_DEFINE_FUNCTION(cuMemcpyAtoD, device_ptr_t dst, array_t src, std::size_t srcOffset, + std::size_t byteCount); + P_CUDA_DEFINE_FUNCTION(cuMemcpyAtoH, void* dst, array_t src, std::size_t srcOffset, std::size_t byteCount); + P_CUDA_DEFINE_FUNCTION(cuMemcpyAtoHAsync, void* dst, array_t src, std::size_t srcOffset, std::size_t byteCount); + P_CUDA_DEFINE_FUNCTION(cuMemcpyDtoA, array_t dst, std::size_t dstOffset, device_ptr_t src, + std::size_t byteCount); + P_CUDA_DEFINE_FUNCTION(cuMemcpyDtoD, device_ptr_t dst, array_t srcArray, std::size_t byteCount); + P_CUDA_DEFINE_FUNCTION(cuMemcpyDtoH, void* dst, array_t src, std::size_t byteCount); + P_CUDA_DEFINE_FUNCTION(cuMemcpyDtoHAsync, void* dst, array_t src, std::size_t byteCount); + P_CUDA_DEFINE_FUNCTION(cuMemcpyHtoA, array_t dst, std::size_t dstOffset, void* src, std::size_t byteCount); + P_CUDA_DEFINE_FUNCTION(cuMemcpyHtoAAsync, array_t dst, std::size_t dstOffset, void* src, std::size_t byteCount); + P_CUDA_DEFINE_FUNCTION(cuMemcpyHtoD, device_ptr_t dst, void* src, std::size_t byteCount); + P_CUDA_DEFINE_FUNCTION(cuMemcpyHtoDAsync, device_ptr_t dst, void* src, std::size_t byteCount); // Virtual Memory Management // - Not yet needed. @@ -246,11 +248,11 @@ namespace nvidia::cuda { // - Not yet needed. // Stream Managment - CUDA_DEFINE_FUNCTION(cuStreamCreate, stream_t* stream, stream_flags flags); - CUDA_DEFINE_FUNCTION(cuStreamCreateWithPriority, stream_t* stream, stream_flags flags, int32_t priority); - CUDA_DEFINE_FUNCTION(cuStreamDestroy, stream_t stream); - CUDA_DEFINE_FUNCTION(cuStreamSynchronize, stream_t stream); - CUDA_DEFINE_FUNCTION(cuStreamGetPriority, stream_t stream, int32_t* priority); + P_CUDA_DEFINE_FUNCTION(cuStreamCreate, stream_t* stream, stream_flags flags); + P_CUDA_DEFINE_FUNCTION(cuStreamCreateWithPriority, stream_t* stream, stream_flags flags, int32_t priority); + P_CUDA_DEFINE_FUNCTION(cuStreamDestroy, stream_t stream); + P_CUDA_DEFINE_FUNCTION(cuStreamSynchronize, stream_t stream); + P_CUDA_DEFINE_FUNCTION(cuStreamGetPriority, stream_t stream, int32_t* priority); // Event Management // - Not yet needed. @@ -280,11 +282,12 @@ namespace nvidia::cuda { // - Not yet needed. // Graphics Interoperability - CUDA_DEFINE_FUNCTION(cuGraphicsMapResources, uint32_t count, graphics_resource_t* resources, stream_t stream); - CUDA_DEFINE_FUNCTION(cuGraphicsSubResourceGetMappedArray, array_t* array, graphics_resource_t resource, - uint32_t index, uint32_t level); - CUDA_DEFINE_FUNCTION(cuGraphicsUnmapResources, uint32_t count, graphics_resource_t* resources, stream_t stream); - CUDA_DEFINE_FUNCTION(cuGraphicsUnregisterResource, graphics_resource_t resource); + P_CUDA_DEFINE_FUNCTION(cuGraphicsMapResources, uint32_t count, graphics_resource_t* resources, stream_t stream); + P_CUDA_DEFINE_FUNCTION(cuGraphicsSubResourceGetMappedArray, array_t* array, graphics_resource_t resource, + uint32_t index, uint32_t level); + P_CUDA_DEFINE_FUNCTION(cuGraphicsUnmapResources, uint32_t count, graphics_resource_t* resources, + stream_t stream); + P_CUDA_DEFINE_FUNCTION(cuGraphicsUnregisterResource, graphics_resource_t resource); // Driver Entry Point Access // - Not yet needed. @@ -306,14 +309,14 @@ namespace nvidia::cuda { // - Not yet needed. // Direct3D10 Interoperability - CUDA_DEFINE_FUNCTION(cuD3D10GetDevice, device_t* device, IDXGIAdapter* adapter); - CUDA_DEFINE_FUNCTION(cuGraphicsD3D10RegisterResource, graphics_resource_t* resource, - ID3D10Resource* d3dresource, uint32_t flags); + P_CUDA_DEFINE_FUNCTION(cuD3D10GetDevice, device_t* device, IDXGIAdapter* adapter); + P_CUDA_DEFINE_FUNCTION(cuGraphicsD3D10RegisterResource, graphics_resource_t* resource, + ID3D10Resource* d3dresource, uint32_t flags); // Direct3D11 Interoperability - CUDA_DEFINE_FUNCTION(cuD3D11GetDevice, device_t* device, IDXGIAdapter* adapter); - CUDA_DEFINE_FUNCTION(cuGraphicsD3D11RegisterResource, graphics_resource_t* resource, - ID3D11Resource* d3dresource, uint32_t flags); + P_CUDA_DEFINE_FUNCTION(cuD3D11GetDevice, device_t* device, IDXGIAdapter* adapter); + P_CUDA_DEFINE_FUNCTION(cuGraphicsD3D11RegisterResource, graphics_resource_t* resource, + ID3D11Resource* d3dresource, uint32_t flags); #endif public: static std::shared_ptr<::nvidia::cuda::cuda> get();