Devsh-Graphics-Programming · devshgraphicsprogramming · Jul 8, 2023 · Jul 9, 2023 · Jul 9, 2023 · Jul 9, 2023
diff --git a/examples_tests b/examples_tests
diff --git a/include/nbl/video/CCUDAHandler.h b/include/nbl/video/CCUDAHandler.h
@@ -182,6 +182,18 @@ class CCUDAHandler : public core::IReferenceCounted
 			return createProgram(prog,std::move(source),file->getFileName().string().c_str(),headerCount,headerContents,includeNames);
 		}
 
+		struct SCUDADeviceInfo
+		{
+			CUdevice handle = {};
+			CUuuid uuid = {};
+			int attributes[CU_DEVICE_ATTRIBUTE_MAX] = {};
+		};
+
+		inline core::vector<SCUDADeviceInfo> const& getAvailableDevices() const
+		{
+			return m_availableDevices;
+		}
+
 		//
 		inline nvrtcResult compileProgram(nvrtcProgram prog, core::SRange<const char* const> options)
 		{
@@ -217,6 +229,7 @@ class CCUDAHandler : public core::IReferenceCounted
 			result = createProgram(&program,std::move(source),filename,headerCount,headerContents,includeNames);
 			return compileDirectlyToPTX_impl(result,program,nvrtcOptions,log);
 		}
+
 		inline ptx_and_nvrtcResult_t compileDirectlyToPTX(
 			const char* source, const char* filename, core::SRange<const char* const> nvrtcOptions,
 			const int headerCount=0, const char* const* headerContents=nullptr, const char* const* includeNames=nullptr,
@@ -225,6 +238,7 @@ class CCUDAHandler : public core::IReferenceCounted
 		{
 			return compileDirectlyToPTX(std::string(source),filename,nvrtcOptions,headerCount,headerContents,includeNames,log);
 		}
+
 		inline ptx_and_nvrtcResult_t compileDirectlyToPTX(
 			system::IFile* file, core::SRange<const char* const> nvrtcOptions,
 			const int headerCount=0, const char* const* headerContents=nullptr, const char* const* includeNames=nullptr,
@@ -245,16 +259,8 @@ class CCUDAHandler : public core::IReferenceCounted
 
 		core::smart_refctd_ptr<CCUDADevice> createDevice(core::smart_refctd_ptr<CVulkanConnection>&& vulkanConnection, IPhysicalDevice* physicalDevice);
 protected:
-		CCUDAHandler(CUDA&& _cuda, NVRTC&& _nvrtc, core::vector<core::smart_refctd_ptr<system::IFile>>&& _headers, core::smart_refctd_ptr<system::ILogger>&& _logger, int _version)
-			: m_cuda(std::move(_cuda)), m_nvrtc(std::move(_nvrtc)), m_headers(std::move(_headers)), m_logger(std::move(_logger)), m_version(_version)
-		{
-			for (auto& header : m_headers)
-			{
-				m_headerContents.push_back(reinterpret_cast<const char*>(header->getMappedPointer()));
-				m_headerNamesStorage.push_back(header->getFileName().string());
-				m_headerNames.push_back(m_headerNamesStorage.back().c_str());
-			}
-		}
+		CCUDAHandler(CUDA&& _cuda, NVRTC&& _nvrtc, core::vector<core::smart_refctd_ptr<system::IFile>>&& _headers, core::smart_refctd_ptr<system::ILogger>&& _logger, int _version);
+
 		~CCUDAHandler() = default;
 
 
@@ -284,6 +290,8 @@ class CCUDAHandler : public core::IReferenceCounted
 		core::vector<const char*> m_headerNames;
 		system::logger_opt_smart_ptr m_logger;
 		int m_version;
+
+		core::vector<SCUDADeviceInfo> m_availableDevices;
 };
 
 }

diff --git a/src/nbl/video/CCUDAHandler.cpp b/src/nbl/video/CCUDAHandler.cpp
@@ -11,7 +11,49 @@
 
 namespace nbl::video
 {
-
+
+CCUDAHandler::CCUDAHandler(
+	CUDA&& _cuda, 
+	NVRTC&& _nvrtc, 
+	core::vector<core::smart_refctd_ptr<system::IFile>>&& _headers, 
+	core::smart_refctd_ptr<system::ILogger>&& _logger,
+	int _version)
+	: m_cuda(std::move(_cuda))
+	, m_nvrtc(std::move(_nvrtc))
+	, m_headers(std::move(_headers))
+	, m_logger(std::move(_logger))
+	, m_version(_version)
+{
+	for (auto& header : m_headers)
+	{
+		m_headerContents.push_back(reinterpret_cast<const char*>(header->getMappedPointer()));
+		m_headerNamesStorage.push_back(header->getFileName().string());
+		m_headerNames.push_back(m_headerNamesStorage.back().c_str());
+	}
+
+	int deviceCount = 0;
+	if (m_cuda.pcuDeviceGetCount(&deviceCount) != CUDA_SUCCESS || deviceCount <= 0)
+		return;
+
+	for (int ordinal = 0; ordinal < deviceCount; ordinal++)
+	{
+		CUdevice handle = -1;
+		if (m_cuda.pcuDeviceGet(&handle, ordinal) != CUDA_SUCCESS || handle < 0)
+			continue;
+
+		CUuuid uuid = {};
+		if (m_cuda.pcuDeviceGetUuid(&uuid, handle) != CUDA_SUCCESS)
+			continue;
+
+		m_availableDevices.emplace_back(handle, uuid);
+
+		int* attributes = m_availableDevices.back().attributes;
+		for (int i = 0; i < CU_DEVICE_ATTRIBUTE_MAX; i++)
+			m_cuda.pcuDeviceGetAttribute(attributes + i, static_cast<CUdevice_attribute>(i), handle);
+
+	}
+}
+
 bool CCUDAHandler::defaultHandleResult(CUresult result, const system::logger_opt_ptr& logger)
 {
 	switch (result)
@@ -527,110 +569,95 @@ core::smart_refctd_ptr<CCUDADevice> CCUDAHandler::createDevice(core::smart_refct
 	if (std::find(devices.begin(),devices.end(),physicalDevice)==devices.end())
 		return nullptr;
 
-    int deviceCount = 0;
-    if (m_cuda.pcuDeviceGetCount(&deviceCount)!=CUDA_SUCCESS || deviceCount<=0)
-		return nullptr;
-
-    for (int ordinal=0; ordinal<deviceCount; ordinal++)
+
+	for (auto& device : m_availableDevices)
 	{
-		CUdevice handle = -1;
-		if (m_cuda.pcuDeviceGet(&handle,ordinal)!=CUDA_SUCCESS || handle<0)
-			continue;
-
-		CUuuid uuid = {};
-		if (m_cuda.pcuDeviceGetUuid(&uuid,handle)!=CUDA_SUCCESS)
-			continue;
-
-        if (!memcmp(&uuid,&physicalDevice->getProperties().deviceUUID,VK_UUID_SIZE))
+		if (!memcmp(&device.uuid, &physicalDevice->getProperties().deviceUUID, VK_UUID_SIZE))
 		{
-			int attributes[CU_DEVICE_ATTRIBUTE_MAX] = {};
-			for (int i=0; i<CU_DEVICE_ATTRIBUTE_MAX; i++)
-				m_cuda.pcuDeviceGetAttribute(attributes+i,static_cast<CUdevice_attribute>(i),handle);
-
 			CCUDADevice::E_VIRTUAL_ARCHITECTURE arch = CCUDADevice::EVA_COUNT;
-			const int& archMajor = attributes[CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR];
-			const int& archMinor = attributes[CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR];
+			const int& archMajor = device.attributes[CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR];
+			const int& archMinor = device.attributes[CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR];
 			switch (archMajor)
 			{
-				case 3:
-					switch (archMinor)
-					{
-						case 0:
-							arch = CCUDADevice::EVA_30;
-							break;
-						case 2:
-							arch = CCUDADevice::EVA_32;
-							break;
-						case 5:
-							arch = CCUDADevice::EVA_35;
-							break;
-						case 7:
-							arch = CCUDADevice::EVA_37;
-							break;
-						default:
-							break;
-					}
+			case 3:
+				switch (archMinor)
+				{
+				case 0:
+					arch = CCUDADevice::EVA_30;
 					break;
-				case 5:
-					switch (archMinor)
-					{
-						case 0:
-							arch = CCUDADevice::EVA_50;
-							break;
-						case 2:
-							arch = CCUDADevice::EVA_52;
-							break;
-						case 3:
-							arch = CCUDADevice::EVA_53;
-							break;
-						default:
-							break;
-					}
+				case 2:
+					arch = CCUDADevice::EVA_32;
 					break;
-				case 6:
-					switch (archMinor)
-					{
-						case 0:
-							arch = CCUDADevice::EVA_60;
-							break;
-						case 1:
-							arch = CCUDADevice::EVA_61;
-							break;
-						case 2:
-							arch = CCUDADevice::EVA_62;
-							break;
-						default:
-							break;
-					}
+				case 5:
+					arch = CCUDADevice::EVA_35;
 					break;
 				case 7:
-					switch (archMinor)
-					{
-						case 0:
-							arch = CCUDADevice::EVA_70;
-							break;
-						case 2:
-							arch = CCUDADevice::EVA_72;
-							break;
-						case 5:
-							arch = CCUDADevice::EVA_75;
-							break;
-						default:
-							break;
-					}
+					arch = CCUDADevice::EVA_37;
+					break;
+				default:
+					break;
+				}
+				break;
+			case 5:
+				switch (archMinor)
+				{
+				case 0:
+					arch = CCUDADevice::EVA_50;
+					break;
+				case 2:
+					arch = CCUDADevice::EVA_52;
+					break;
+				case 3:
+					arch = CCUDADevice::EVA_53;
 					break;
 				default:
-					if (archMajor>=8)
-						arch = CCUDADevice::EVA_80;
 					break;
+				}
+				break;
+			case 6:
+				switch (archMinor)
+				{
+				case 0:
+					arch = CCUDADevice::EVA_60;
+					break;
+				case 1:
+					arch = CCUDADevice::EVA_61;
+					break;
+				case 2:
+					arch = CCUDADevice::EVA_62;
+					break;
+				default:
+					break;
+				}
+				break;
+			case 7:
+				switch (archMinor)
+				{
+				case 0:
+					arch = CCUDADevice::EVA_70;
+					break;
+				case 2:
+					arch = CCUDADevice::EVA_72;
+					break;
+				case 5:
+					arch = CCUDADevice::EVA_75;
+					break;
+				default:
+					break;
+				}
+				break;
+			default:
+				if (archMajor >= 8)
+					arch = CCUDADevice::EVA_80;
+				break;
 			}
-			if (arch==CCUDADevice::EVA_COUNT)
+			if (arch == CCUDADevice::EVA_COUNT)
 				continue;
 
-			auto device = new CCUDADevice(std::move(vulkanConnection),physicalDevice,arch,handle,core::smart_refctd_ptr<CCUDAHandler>(this));
-            return core::smart_refctd_ptr<CCUDADevice>(device,core::dont_grab);
-        }
-    }
+			return core::smart_refctd_ptr<CCUDADevice>(new CCUDADevice(std::move(vulkanConnection), physicalDevice, arch, device.handle, core::smart_refctd_ptr<CCUDAHandler>(this)), core::dont_grab);
+		}
+	}
+	
 	return nullptr;
 }
 

diff --git a/src/nbl/video/ILogicalDevice.cpp b/src/nbl/video/ILogicalDevice.cpp
@@ -111,23 +111,24 @@ bool ILogicalDevice::supportsMask(const uint32_t queueFamilyIndex, core::bitflag
     return getSupportedStageMask(queueFamilyIndex).hasFlags(stageMask);
 }
 
-bool ILogicalDevice::supportsMask(const uint32_t queueFamilyIndex, core::bitflag<asset::ACCESS_FLAGS> stageMask) const
+bool ILogicalDevice::supportsMask(const uint32_t queueFamilyIndex, core::bitflag<asset::ACCESS_FLAGS> accesMask) const
 {
     if (queueFamilyIndex>m_queueFamilyInfos->size())
         return false;
     using q_family_flags_t = IQueue::FAMILY_FLAGS;
     const auto& familyProps = m_physicalDevice->getQueueFamilyProperties()[queueFamilyIndex].queueFlags;
     const bool shaderCapableFamily = bool(familyProps&(q_family_flags_t::COMPUTE_BIT|q_family_flags_t::GRAPHICS_BIT));
     // strip special values
-    if (stageMask.hasFlags(asset::ACCESS_FLAGS::MEMORY_READ_BITS))
-        stageMask ^= asset::ACCESS_FLAGS::MEMORY_READ_BITS;
-    else if (stageMask.hasFlags(asset::ACCESS_FLAGS::SHADER_READ_BITS) && shaderCapableFamily)
-        stageMask ^= asset::ACCESS_FLAGS::SHADER_READ_BITS;
-    if (stageMask.hasFlags(asset::ACCESS_FLAGS::MEMORY_WRITE_BITS))
-        stageMask ^= asset::ACCESS_FLAGS::MEMORY_WRITE_BITS;
-    else if (stageMask.hasFlags(asset::ACCESS_FLAGS::SHADER_WRITE_BITS) && shaderCapableFamily)
-        stageMask ^= asset::ACCESS_FLAGS::SHADER_WRITE_BITS;
-    return getSupportedAccessMask(queueFamilyIndex).hasFlags(stageMask);
+    VK_ACCESS_SHADER_WRITE_BIT;
+    if (accesMask.hasFlags(asset::ACCESS_FLAGS::MEMORY_READ_BITS))
+        accesMask ^= asset::ACCESS_FLAGS::MEMORY_READ_BITS;
+    else if (accesMask.hasFlags(asset::ACCESS_FLAGS::SHADER_READ_BITS) && shaderCapableFamily)
+        accesMask ^= asset::ACCESS_FLAGS::SHADER_READ_BITS;
+    if (accesMask.hasFlags(asset::ACCESS_FLAGS::MEMORY_WRITE_BITS))
+        accesMask ^= asset::ACCESS_FLAGS::MEMORY_WRITE_BITS;
+    else if (accesMask.hasFlags(asset::ACCESS_FLAGS::SHADER_WRITE_BITS) && shaderCapableFamily)
+        accesMask ^= asset::ACCESS_FLAGS::SHADER_WRITE_BITS;
+    return getSupportedAccessMask(queueFamilyIndex).hasFlags(accesMask);
 }
 
 bool ILogicalDevice::validateMemoryBarrier(const uint32_t queueFamilyIndex, asset::SMemoryBarrier barrier) const
+87 −82		06_HelloGraphicsQueue/main.cpp
+357 −344		63_CUDAInterop/main.cpp
+1 −1		common/MonoDeviceApplication.hpp