use std::ffi::c_void;
use std::os::raw::c_char;
use libloading::{Library, Symbol};
use super::{igpu_enabled, HostGpu};
#[cfg(target_os = "windows")]
fn open_cuda_lib() -> Option<Library> {
unsafe { Library::new("nvcuda.dll").ok() }
}
#[cfg(target_os = "linux")]
fn open_cuda_lib() -> Option<Library> {
unsafe {
Library::new("libcuda.so.1")
.or_else(|_| Library::new("libcuda.so"))
.ok()
}
}
#[cfg(target_os = "windows")]
fn open_hip_lib() -> Option<Library> {
unsafe {
Library::new("amdhip64_6.dll")
.or_else(|_| Library::new("amdhip64.dll"))
.ok()
}
}
#[cfg(target_os = "linux")]
fn open_hip_lib() -> Option<Library> {
unsafe {
Library::new("libamdhip64.so.6")
.or_else(|_| Library::new("libamdhip64.so.5"))
.or_else(|_| Library::new("libamdhip64.so"))
.ok()
}
}
#[cfg(all(target_os = "windows", target_arch = "aarch64"))]
fn open_opencl_lib() -> Option<Library> {
unsafe { Library::new("OpenCL.dll").ok() }
}
#[cfg(target_os = "windows")]
fn open_vulkan_lib() -> Option<Library> {
unsafe { Library::new("vulkan-1.dll").ok() }
}
#[cfg(target_os = "linux")]
fn open_vulkan_lib() -> Option<Library> {
unsafe {
Library::new("libvulkan.so.1")
.or_else(|_| Library::new("libvulkan.so"))
.ok()
}
}
const CUDA_SUCCESS: i32 = 0;
const CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR: i32 = 75;
const CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR: i32 = 76;
fn cuda_major_from_driver_version(driver_version: i32) -> u32 {
(driver_version / 1000).max(0) as u32
}
pub(super) fn detect_cuda() -> Option<(HostGpu, u64)> {
let lib = open_cuda_lib()?;
unsafe {
let cu_driver_get_version: Symbol<unsafe extern "C" fn(*mut i32) -> i32> =
lib.get(b"cuDriverGetVersion\0").ok()?;
let cu_init: Symbol<unsafe extern "C" fn(u32) -> i32> = lib.get(b"cuInit\0").ok()?;
let cu_device_get_count: Symbol<unsafe extern "C" fn(*mut i32) -> i32> =
lib.get(b"cuDeviceGetCount\0").ok()?;
let mut driver_version: i32 = 0;
if cu_driver_get_version(&mut driver_version) != CUDA_SUCCESS {
return None;
}
if cu_init(0) != CUDA_SUCCESS {
return None;
}
let mut count: i32 = 0;
if cu_device_get_count(&mut count) != CUDA_SUCCESS || count == 0 {
return None;
}
let mut vram: u64 = 0;
if let (Ok(cu_device_get), Ok(cu_device_get_attribute)) = (
lib.get::<unsafe extern "C" fn(*mut i32, i32) -> i32>(b"cuDeviceGet\0"),
lib.get::<unsafe extern "C" fn(*mut i32, i32, i32) -> i32>(b"cuDeviceGetAttribute\0"),
) {
let cu_device_total_mem = lib
.get::<unsafe extern "C" fn(*mut u64, i32) -> i32>(b"cuDeviceTotalMem_v2\0")
.ok();
for index in 0..count {
let mut device: i32 = 0;
if cu_device_get(&mut device, index) != CUDA_SUCCESS {
continue;
}
let mut major: i32 = 0;
let mut minor: i32 = 0;
cu_device_get_attribute(
&mut major,
CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR,
device,
);
cu_device_get_attribute(
&mut minor,
CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR,
device,
);
crate::debug_log!("CUDA device {index} compute capability: {major}.{minor}");
if let Some(cu_device_total_mem) = &cu_device_total_mem {
let mut bytes: u64 = 0;
if cu_device_total_mem(&mut bytes, device) == CUDA_SUCCESS {
vram += bytes;
}
}
}
}
Some((
HostGpu::Cuda {
major: cuda_major_from_driver_version(driver_version),
},
vram,
))
}
}
const HIP_SUCCESS: i32 = 0;
pub(super) fn detect_rocm() -> Option<u64> {
let lib = open_hip_lib()?;
unsafe {
let hip_get_device_count = lib
.get::<unsafe extern "C" fn(*mut i32) -> i32>(b"hipGetDeviceCount\0")
.ok()?;
let mut count: i32 = 0;
if hip_get_device_count(&mut count) != HIP_SUCCESS || count == 0 {
return None;
}
let mut vram: u64 = 0;
if let (Ok(hip_set_device), Ok(hip_mem_get_info)) = (
lib.get::<unsafe extern "C" fn(i32) -> i32>(b"hipSetDevice\0"),
lib.get::<unsafe extern "C" fn(*mut u64, *mut u64) -> i32>(b"hipMemGetInfo\0"),
) {
for index in 0..count {
if hip_set_device(index) != HIP_SUCCESS {
continue;
}
let (mut free, mut total): (u64, u64) = (0, 0);
if hip_mem_get_info(&mut free, &mut total) == HIP_SUCCESS {
vram += total;
}
}
}
Some(vram)
}
}
#[cfg(all(target_os = "windows", target_arch = "aarch64"))]
pub(super) fn detect_opencl() -> Option<u64> {
const CL_SUCCESS: i32 = 0;
const CL_DEVICE_TYPE_GPU: u64 = 1 << 2;
const CL_DEVICE_GLOBAL_MEM_SIZE: u32 = 0x101F;
const CL_DEVICE_NAME: u32 = 0x102B;
let lib = open_opencl_lib()?;
unsafe {
let get_platform_ids: Symbol<unsafe extern "C" fn(u32, *mut *mut c_void, *mut u32) -> i32> =
lib.get(b"clGetPlatformIDs\0").ok()?;
let get_device_ids: Symbol<
unsafe extern "C" fn(*mut c_void, u64, u32, *mut *mut c_void, *mut u32) -> i32,
> = lib.get(b"clGetDeviceIDs\0").ok()?;
let get_device_info: Symbol<
unsafe extern "C" fn(*mut c_void, u32, usize, *mut c_void, *mut usize) -> i32,
> = lib.get(b"clGetDeviceInfo\0").ok()?;
let mut platform_count: u32 = 0;
if get_platform_ids(0, std::ptr::null_mut(), &mut platform_count) != CL_SUCCESS
|| platform_count == 0
{
return None;
}
let mut platforms = vec![std::ptr::null_mut(); platform_count as usize];
if get_platform_ids(platform_count, platforms.as_mut_ptr(), std::ptr::null_mut())
!= CL_SUCCESS
{
return None;
}
let mut found: Option<u64> = None;
for platform in platforms {
let mut device_count: u32 = 0;
if get_device_ids(
platform,
CL_DEVICE_TYPE_GPU,
0,
std::ptr::null_mut(),
&mut device_count,
) != CL_SUCCESS
|| device_count == 0
{
continue;
}
let mut devices = vec![std::ptr::null_mut(); device_count as usize];
if get_device_ids(
platform,
CL_DEVICE_TYPE_GPU,
device_count,
devices.as_mut_ptr(),
std::ptr::null_mut(),
) != CL_SUCCESS
{
continue;
}
for device in devices {
let mut size: usize = 0;
if get_device_info(device, CL_DEVICE_NAME, 0, std::ptr::null_mut(), &mut size)
!= CL_SUCCESS
|| size == 0
{
continue;
}
let mut name = vec![0u8; size];
if get_device_info(
device,
CL_DEVICE_NAME,
name.len(),
name.as_mut_ptr().cast(),
std::ptr::null_mut(),
) != CL_SUCCESS
{
continue;
}
if !String::from_utf8_lossy(&name)
.to_ascii_lowercase()
.contains("adreno")
{
continue;
}
let mut mem: u64 = 0;
if get_device_info(
device,
CL_DEVICE_GLOBAL_MEM_SIZE,
std::mem::size_of::<u64>(),
(&mut mem as *mut u64).cast(),
std::ptr::null_mut(),
) != CL_SUCCESS
{
mem = 0;
}
found = Some(found.unwrap_or(0) + mem);
}
}
found
}
}
#[cfg(not(all(target_os = "windows", target_arch = "aarch64")))]
pub(super) fn detect_opencl() -> Option<u64> {
None
}
const VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: i32 = 1;
const VK_SUCCESS: i32 = 0;
const VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: i32 = 1;
const VK_PHYSICAL_DEVICE_TYPE_CPU: i32 = 4;
const VK_QUEUE_COMPUTE_BIT: u32 = 0x2;
const VK_QUEUE_TRANSFER_BIT: u32 = 0x4;
fn vk_make_api_version(variant: u32, major: u32, minor: u32, patch: u32) -> u32 {
(variant << 29) | (major << 22) | (minor << 12) | patch
}
type VkInstance = *mut c_void;
type VkPhysicalDevice = *mut c_void;
#[repr(C)]
struct VkInstanceCreateInfo {
s_type: i32,
p_next: *const c_void,
flags: u32,
p_application_info: *const c_void,
enabled_layer_count: u32,
pp_enabled_layer_names: *const *const c_char,
enabled_extension_count: u32,
pp_enabled_extension_names: *const *const c_char,
}
#[repr(C)]
#[derive(Clone, Copy, Default)]
struct VkExtent3D {
width: u32,
height: u32,
depth: u32,
}
#[repr(C)]
#[derive(Clone, Copy, Default)]
struct VkQueueFamilyProperties {
queue_flags: u32,
queue_count: u32,
timestamp_valid_bits: u32,
min_image_transfer_granularity: VkExtent3D,
}
#[repr(C, align(8))]
struct RawPhysicalDeviceProperties([u8; 1024]);
const VK_MAX_MEMORY_HEAPS: usize = 16;
const VK_MEMORY_HEAP_DEVICE_LOCAL_BIT: u32 = 0x1;
#[repr(C)]
#[derive(Clone, Copy, Default)]
struct VkMemoryHeap {
size: u64,
flags: u32,
_pad: u32,
}
#[repr(C)]
struct RawPhysicalDeviceMemoryProperties {
memory_type_count: u32,
_memory_types_padding: [u8; 32 * 8],
memory_heap_count: u32,
memory_heaps: [VkMemoryHeap; VK_MAX_MEMORY_HEAPS],
}
pub(super) fn detect_vulkan() -> Option<u64> {
let lib = open_vulkan_lib()?;
unsafe { detect_vulkan_inner(&lib).unwrap_or(None) }
}
unsafe fn detect_vulkan_inner(lib: &Library) -> Option<Option<u64>> {
let vk_create_instance: Symbol<
unsafe extern "C" fn(*const VkInstanceCreateInfo, *const c_void, *mut VkInstance) -> i32,
> = lib.get(b"vkCreateInstance\0").ok()?;
let vk_destroy_instance: Symbol<unsafe extern "C" fn(VkInstance, *const c_void)> =
lib.get(b"vkDestroyInstance\0").ok()?;
let vk_enumerate_physical_devices: Symbol<
unsafe extern "C" fn(VkInstance, *mut u32, *mut VkPhysicalDevice) -> i32,
> = lib.get(b"vkEnumeratePhysicalDevices\0").ok()?;
let vk_get_physical_device_properties: Symbol<unsafe extern "C" fn(VkPhysicalDevice, *mut u8)> =
lib.get(b"vkGetPhysicalDeviceProperties\0").ok()?;
let vk_get_physical_device_queue_family_properties: Symbol<
unsafe extern "C" fn(VkPhysicalDevice, *mut u32, *mut VkQueueFamilyProperties),
> = lib
.get(b"vkGetPhysicalDeviceQueueFamilyProperties\0")
.ok()?;
let vk_get_physical_device_memory_properties: Symbol<
unsafe extern "C" fn(VkPhysicalDevice, *mut RawPhysicalDeviceMemoryProperties),
> = lib.get(b"vkGetPhysicalDeviceMemoryProperties\0").ok()?;
let create_info = VkInstanceCreateInfo {
s_type: VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
p_next: std::ptr::null(),
flags: 0,
p_application_info: std::ptr::null(),
enabled_layer_count: 0,
pp_enabled_layer_names: std::ptr::null(),
enabled_extension_count: 0,
pp_enabled_extension_names: std::ptr::null(),
};
let mut instance: VkInstance = std::ptr::null_mut();
if vk_create_instance(&create_info, std::ptr::null(), &mut instance) != VK_SUCCESS {
return Some(None);
}
let mut count: u32 = 0;
let found = if vk_enumerate_physical_devices(instance, &mut count, std::ptr::null_mut())
!= VK_SUCCESS
|| count == 0
{
None
} else {
let mut devices: Vec<VkPhysicalDevice> = vec![std::ptr::null_mut(); count as usize];
if vk_enumerate_physical_devices(instance, &mut count, devices.as_mut_ptr()) != VK_SUCCESS {
None
} else {
let mut found: Option<u64> = None;
for &device in &devices {
let mut props_buf = RawPhysicalDeviceProperties([0u8; 1024]);
vk_get_physical_device_properties(device, props_buf.0.as_mut_ptr());
let api_version = u32::from_ne_bytes(props_buf.0[0..4].try_into().unwrap());
let device_type = i32::from_ne_bytes(props_buf.0[16..20].try_into().unwrap());
if device_type == VK_PHYSICAL_DEVICE_TYPE_CPU {
continue;
}
if device_type == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU && !igpu_enabled() {
continue;
}
if api_version < vk_make_api_version(0, 1, 2, 0) {
continue;
}
let mut qcount: u32 = 0;
vk_get_physical_device_queue_family_properties(
device,
&mut qcount,
std::ptr::null_mut(),
);
if qcount == 0 {
continue;
}
let mut queues = vec![VkQueueFamilyProperties::default(); qcount as usize];
vk_get_physical_device_queue_family_properties(
device,
&mut qcount,
queues.as_mut_ptr(),
);
let has_compute = queues.iter().any(|q| {
q.queue_flags & VK_QUEUE_COMPUTE_BIT != 0
&& q.queue_flags & VK_QUEUE_TRANSFER_BIT != 0
});
if !has_compute {
continue;
}
let mut mem_props = RawPhysicalDeviceMemoryProperties {
memory_type_count: 0,
_memory_types_padding: [0u8; 32 * 8],
memory_heap_count: 0,
memory_heaps: [VkMemoryHeap::default(); VK_MAX_MEMORY_HEAPS],
};
vk_get_physical_device_memory_properties(device, &mut mem_props);
let vram: u64 = mem_props.memory_heaps
[..(mem_props.memory_heap_count as usize).min(VK_MAX_MEMORY_HEAPS)]
.iter()
.filter(|h| h.flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT != 0)
.map(|h| h.size)
.sum();
found = Some(found.unwrap_or(0) + vram);
}
found
}
};
vk_destroy_instance(instance, std::ptr::null());
Some(found)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn cuda_major_from_driver_version_matches_documented_encoding() {
assert_eq!(cuda_major_from_driver_version(12040), 12); assert_eq!(cuda_major_from_driver_version(13030), 13); assert_eq!(cuda_major_from_driver_version(0), 0);
}
#[test]
fn vk_make_api_version_matches_the_vulkan_header_macro() {
assert_eq!(vk_make_api_version(0, 1, 2, 0), (1 << 22) | (2 << 12));
assert_eq!(vk_make_api_version(0, 1, 0, 0), 1 << 22);
}
#[test]
#[ignore = "result depends on this host's actual GPU/driver setup"]
fn detect_reports_this_hosts_real_hardware() {
println!("detect_cuda() -> {:?}", detect_cuda());
println!("detect_rocm() -> {:?}", detect_rocm());
println!("detect_vulkan() -> {:?}", detect_vulkan());
println!(
"detect_with_vram() -> {:?}",
super::super::detect_with_vram()
);
}
}