Add support for nvml in zluda_bindgen

.devcontainer/Dockerfile

@@ -27,6 +27,7 @@ RUN DEBIAN_FRONTEND=noninteractive apt-get update -y && DEBIAN_FRONTEND=noninter
     libgl-dev libegl-dev libvdpau-dev \
     nvidia-utils-${CUDA_DRIVER} \
     cuda-cudart-dev-${CUDA_PKG_VERSION} \
+    cuda-nvml-dev-${CUDA_PKG_VERSION} \
     cuda-cudart-${CUDA_PKG_VERSION} \
     cuda-profiler-api-${CUDA_PKG_VERSION} \
     cuda-nvcc-${CUDA_PKG_VERSION}

comgr/src/lib.rs

@@ -1,5 +1,5 @@
 use amd_comgr_sys::*;
-use std::{ffi::CStr, iter, mem, ptr};
+use std::{ffi::CStr, mem, ptr};
 
 struct Data(amd_comgr_data_t);
 

zluda/src/impl/context.rs

@@ -1,5 +1,5 @@
 use super::{driver, FromCuda, ZludaObject};
-use cuda_types::*;
+use cuda_types::cuda::*;
 use hip_runtime_sys::*;
 use rustc_hash::FxHashSet;
 use std::{cell::RefCell, ptr, sync::Mutex};

zluda/src/impl/device.rs

@@ -1,4 +1,4 @@
-use cuda_types::*;
+use cuda_types::cuda::*;
 use hip_runtime_sys::*;
 use std::{mem, ptr};
 
@@ -377,7 +377,7 @@ pub(crate) fn get_name(
     name: *mut ::core::ffi::c_char,
     len: ::core::ffi::c_int,
     dev: hipDevice_t,
-) -> cuda_types::CUresult {
+) -> CUresult {
     unsafe { hipDeviceGetName(name, len, dev) }?;
     let len = len as usize;
     let buffer = unsafe { std::slice::from_raw_parts(name, len) };
@@ -404,7 +404,7 @@ pub(crate) fn total_mem_v2(bytes: *mut usize, dev: hipDevice_t) -> hipError_t {
     unsafe { hipDeviceTotalMem(bytes, dev) }
 }
 
-pub(crate) fn get_properties(prop: &mut cuda_types::CUdevprop, dev: hipDevice_t) -> hipError_t {
+pub(crate) fn get_properties(prop: &mut CUdevprop, dev: hipDevice_t) -> hipError_t {
     let mut hip_props = unsafe { mem::zeroed() };
     unsafe { hipGetDevicePropertiesR0600(&mut hip_props, dev) }?;
     prop.maxThreadsPerBlock = hip_props.maxThreadsPerBlock;

zluda/src/impl/driver.rs

@@ -1,4 +1,4 @@
-use cuda_types::*;
+use cuda_types::cuda::*;
 use hip_runtime_sys::*;
 use std::{
     ffi::{CStr, CString},
@@ -74,6 +74,6 @@ pub(crate) fn init(flags: ::core::ffi::c_uint) -> CUresult {
 }
 
 pub(crate) fn get_version(version: &mut ::core::ffi::c_int) -> CUresult {
-    *version = cuda_types::CUDA_VERSION as i32;
+    *version = cuda_types::cuda::CUDA_VERSION as i32;
     Ok(())
 }

zluda/src/impl/mod.rs

@@ -1,4 +1,4 @@
-use cuda_types::*;
+use cuda_types::cuda::*;
 use hip_runtime_sys::*;
 use std::mem::{self, ManuallyDrop, MaybeUninit};
 
@@ -111,7 +111,7 @@ from_cuda_nop!(
     i32,
     u32,
     usize,
-    cuda_types::CUdevprop,
+    cuda_types::cuda::CUdevprop,
     CUdevice_attribute
 );
 from_cuda_transmute!(
@@ -137,7 +137,7 @@ impl<'a> FromCuda<'a, CUlimit> for hipLimit_t {
 
 pub(crate) trait ZludaObject: Sized + Send + Sync {
     const COOKIE: usize;
-    const LIVENESS_FAIL: CUerror = cuda_types::CUerror::INVALID_VALUE;
+    const LIVENESS_FAIL: CUerror = cuda_types::cuda::CUerror::INVALID_VALUE;
 
     type CudaHandle: Sized;
 

zluda/src/impl/module.rs

@@ -1,5 +1,5 @@
 use super::ZludaObject;
-use cuda_types::*;
+use cuda_types::cuda::*;
 use hip_runtime_sys::*;
 use std::{ffi::CStr, mem};
 

zluda/src/impl/pointer.rs

@@ -1,4 +1,4 @@
-use cuda_types::*;
+use cuda_types::cuda::*;
 use hip_runtime_sys::*;
 use std::{ffi::c_void, ptr};
 

zluda_bindgen/src/main.rs

@@ -5,7 +5,7 @@ use std::{collections::hash_map, fs::File, io::Write, iter, path::PathBuf, str::
 use syn::{
     parse_quote, punctuated::Punctuated, visit_mut::VisitMut, Abi, Fields, FieldsUnnamed, FnArg,
     ForeignItem, ForeignItemFn, Ident, Item, ItemConst, ItemForeignMod, ItemUse, LitStr, Path,
-    PathArguments, Signature, Type, TypePath, UseTree,
+    PathArguments, Signature, Type, TypePath, UseTree, PathSegment
 };
 
 fn main() {
@@ -14,6 +14,11 @@ fn main() {
         &crate_root,
         &["..", "ext", "hip_runtime-sys", "src", "lib.rs"],
     );
+    generate_ml(&crate_root);
+    generate_cuda(&crate_root);
+}
+
+fn generate_cuda(crate_root: &PathBuf) {
     let cuda_header = bindgen::Builder::default()
         .use_core()
         .rust_target(bindgen::RustTarget::Stable_1_77)
@@ -42,16 +47,91 @@ fn main() {
         .unwrap()
         .to_string();
     let module: syn::File = syn::parse_str(&cuda_header).unwrap();
-    generate_functions(&crate_root, &["..", "cuda_base", "src", "cuda.rs"], &module);
+    generate_functions(
-    generate_types(&crate_root, &["..", "cuda_types", "src", "lib.rs"], &module);
+        &crate_root,
+        "cuda",
+        &["..", "cuda_base", "src", "cuda.rs"],
+        &module,
+    );
+    generate_types_cuda(
+        &crate_root,
+        &["..", "cuda_types", "src", "cuda.rs"],
+        &module,
+    );
     generate_display(
         &crate_root,
         &["..", "zluda_dump", "src", "format_generated.rs"],
-        "cuda_types",
+        &["cuda_types", "cuda"],
         &module,
     )
 }
 
+fn generate_ml(crate_root: &PathBuf) {
+    let ml_header = bindgen::Builder::default()
+        .use_core()
+        .rust_target(bindgen::RustTarget::Stable_1_77)
+        .layout_tests(false)
+        .default_enum_style(bindgen::EnumVariation::NewType {
+            is_bitfield: false,
+            is_global: false,
+        })
+        .derive_hash(true)
+        .derive_eq(true)
+        .header("/usr/local/cuda/include/nvml.h")
+        .allowlist_type("^nvml.*")
+        .allowlist_function("^nvml.*")
+        .allowlist_var("^NVML.*")
+        .must_use_type("nvmlReturn_t")
+        .constified_enum("nvmlReturn_enum")
+        .generate()
+        .unwrap()
+        .to_string();
+    let mut module: syn::File = syn::parse_str(&ml_header).unwrap();
+    let mut converter = ConvertIntoRustResult {
+        type_: "nvmlReturn_t",
+        underlying_type: "nvmlReturn_enum",
+        new_error_type: "nvmlError_t",
+        error_prefix: ("NVML_ERROR_", "ERROR_"),
+        success: ("NVML_SUCCESS", "SUCCESS"),
+        constants: Vec::new(),
+    };
+    module.items = module
+        .items
+        .into_iter()
+        .filter_map(|item| match item {
+            Item::Const(const_) => converter.get_const(const_).map(Item::Const),
+            Item::Use(use_) => converter.get_use(use_).map(Item::Use),
+            Item::Type(type_) => converter.get_type(type_).map(Item::Type),
+            item => Some(item),
+        })
+        .collect::<Vec<_>>();
+    converter.flush(&mut module.items);
+    generate_functions(
+        &crate_root,
+        "nvml",
+        &["..", "cuda_base", "src", "nvml.rs"],
+        &module,
+    );
+    generate_types(
+        &crate_root,
+        &["..", "cuda_types", "src", "nvml.rs"],
+        &module,
+    );
+}
+
+fn generate_types(crate_root: &PathBuf, path: &[&str], module: &syn::File) {
+    let non_fn = module.items.iter().filter_map(|item| match item {
+        Item::ForeignMod(_) => None,
+        _ => Some(item),
+    });
+    let module: syn::File = parse_quote! {
+            #(#non_fn)*
+    };
+    let mut output = crate_root.clone();
+    output.extend(path);
+    write_rust_to_file(output, &prettyplease::unparse(&module))
+}
+
 fn generate_hip_runtime(output: &PathBuf, path: &[&str]) {
     let hiprt_header = bindgen::Builder::default()
         .use_core()
@@ -125,7 +205,7 @@ fn add_send_sync(items: &mut Vec<Item>, arg: &[&str]) {
     }
 }
 
-fn generate_functions(output: &PathBuf, path: &[&str], module: &syn::File) {
+fn generate_functions(output: &PathBuf, submodule: &str, path: &[&str], module: &syn::File) {
     let fns_ = module.items.iter().filter_map(|item| match item {
         Item::ForeignMod(extern_) => match &*extern_.items {
             [ForeignItem::Fn(fn_)] => Some(fn_),
@@ -138,7 +218,8 @@ fn generate_functions(output: &PathBuf, path: &[&str], module: &syn::File) {
             #(#fns_)*
         }
     };
-    syn::visit_mut::visit_file_mut(&mut PrependCudaPath, &mut module);
+    let submodule = Ident::new(submodule, Span::call_site());
+    syn::visit_mut::visit_file_mut(&mut PrependCudaPath { module: submodule }, &mut module);
     syn::visit_mut::visit_file_mut(&mut RemoveVisibility, &mut module);
     syn::visit_mut::visit_file_mut(&mut ExplicitReturnType, &mut module);
     let mut output = output.clone();
@@ -146,7 +227,7 @@ fn generate_functions(output: &PathBuf, path: &[&str], module: &syn::File) {
     write_rust_to_file(output, &prettyplease::unparse(&module))
 }
 
-fn generate_types(output: &PathBuf, path: &[&str], module: &syn::File) {
+fn generate_types_cuda(output: &PathBuf, path: &[&str], module: &syn::File) {
     let mut module = module.clone();
     let mut converter = ConvertIntoRustResult {
         type_: "CUresult",
@@ -314,7 +395,9 @@ impl VisitMut for FixAbi {
     }
 }
 
-struct PrependCudaPath;
+struct PrependCudaPath {
+    module: Ident,
+}
 
 impl VisitMut for PrependCudaPath {
     fn visit_type_path_mut(&mut self, type_: &mut TypePath) {
@@ -322,7 +405,8 @@ impl VisitMut for PrependCudaPath {
             match &*type_.path.segments[0].ident.to_string() {
                 "usize" | "f64" | "f32" => {}
                 _ => {
-                    *type_ = parse_quote! { cuda_types :: #type_ };
+                    let module = &self.module;
+                    *type_ = parse_quote! { cuda_types :: #module :: #type_ };
                 }
             }
         }
@@ -350,7 +434,7 @@ impl VisitMut for ExplicitReturnType {
 fn generate_display(
     output: &PathBuf,
     path: &[&str],
-    types_crate: &'static str,
+    types_crate: &[&'static str],
     module: &syn::File,
 ) {
     let ignore_types = [
@@ -419,7 +503,7 @@ fn generate_display(
 }
 
 struct DeriveDisplayState<'a> {
-    types_crate: &'static str,
+    types_crate: Path,
     ignore_types: FxHashSet<Ident>,
     ignore_fns: FxHashSet<Ident>,
     enums: FxHashMap<&'a Ident, Vec<&'a Ident>>,
@@ -430,12 +514,22 @@ struct DeriveDisplayState<'a> {
 impl<'a> DeriveDisplayState<'a> {
     fn new(
         ignore_types: &[&'static str],
-        types_crate: &'static str,
+        types_crate: &[&'static str],
         ignore_fns: &[&'static str],
         count_selectors: &[(&'static str, usize, usize)],
     ) -> Self {
+        let segments = types_crate
+            .iter()
+            .map(|seg| PathSegment {
+                ident: Ident::new(seg, Span::call_site()),
+                arguments: PathArguments::None,
+            })
+            .collect::<Punctuated<_, _>>();
         DeriveDisplayState {
-            types_crate,
+            types_crate: Path {
+                leading_colon: None,
+                segments,
+            },
             ignore_types: ignore_types
                 .into_iter()
                 .map(|x| Ident::new(x, Span::call_site()))
@@ -469,8 +563,11 @@ fn cuda_derive_display_trait_for_item<'a>(
     state: &mut DeriveDisplayState<'a>,
     item: &'a Item,
 ) -> Option<syn::Item> {
-    let path_prefix = Path::from(Ident::new(state.types_crate, Span::call_site()));
+    let path_prefix = & state.types_crate;
     let path_prefix_iter = iter::repeat(&path_prefix);
+    let mut prepend_path = PrependCudaPath {
+        module: Ident::new("cuda", Span::call_site()),
+    };
     match item {
         Item::Const(const_) => {
             if const_.ty.to_token_stream().to_string() == "cudaError_enum" {
@@ -490,7 +587,7 @@ fn cuda_derive_display_trait_for_item<'a>(
                     .iter()
                     .map(|fn_arg| {
                         let mut fn_arg = fn_arg.clone();
-                        syn::visit_mut::visit_fn_arg_mut(&mut PrependCudaPath, &mut fn_arg);
+                        syn::visit_mut::visit_fn_arg_mut(&mut prepend_path, &mut fn_arg);
                         fn_arg
                     })
                     .collect::<Vec<_>>();
@@ -686,7 +783,7 @@ fn curesult_display_trait(derive_state: &DeriveDisplayState) -> syn::Item {
         })
     });
     parse_quote! {
-        impl crate::format::CudaDisplay for cuda_types::CUresult {
+        impl crate::format::CudaDisplay for cuda_types::cuda::CUresult {
             fn write(&self, _fn_name: &'static str, _index: usize, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {
                 match self {
                     Ok(()) => writer.write_all(b"CUDA_SUCCESS"),

zluda_dump/src/dark_api.rs

@@ -1,7 +1,7 @@
 use crate::format;
 use crate::{log, os, trace::StateTracker};
 use crate::{log::UInt, GlobalDelayedState};
-use cuda_types::{CUmodule, CUresult, CUuuid};
+use cuda_types::cuda::*;
 use std::borrow::Cow;
 use std::hash::Hash;
 use std::{

zluda_dump/src/format.rs

@@ -1,4 +1,4 @@
-use cuda_types::{CUGLDeviceList, CUdevice};
+use cuda_types::cuda::*;
 use std::{
     ffi::{c_void, CStr},
     fmt::LowerHex,
@@ -14,7 +14,7 @@ pub(crate) trait CudaDisplay {
     ) -> std::io::Result<()>;
 }
 
-impl CudaDisplay for cuda_types::CUuuid {
+impl CudaDisplay for CUuuid {
     fn write(
         &self,
         _fn_name: &'static str,
@@ -26,7 +26,7 @@ impl CudaDisplay for cuda_types::CUuuid {
     }
 }
 
-impl CudaDisplay for cuda_types::CUdeviceptr_v1 {
+impl CudaDisplay for CUdeviceptr_v1 {
     fn write(
         &self,
         _fn_name: &'static str,
@@ -125,7 +125,7 @@ pub fn write_handle<T: LowerHex>(
     Ok(())
 }
 
-impl CudaDisplay for cuda_types::CUipcMemHandle {
+impl CudaDisplay for CUipcMemHandle {
     fn write(
         &self,
         _fn_name: &'static str,
@@ -136,7 +136,7 @@ impl CudaDisplay for cuda_types::CUipcMemHandle {
     }
 }
 
-impl CudaDisplay for cuda_types::CUipcEventHandle {
+impl CudaDisplay for CUipcEventHandle {
     fn write(
         &self,
         _fn_name: &'static str,
@@ -147,7 +147,7 @@ impl CudaDisplay for cuda_types::CUipcEventHandle {
     }
 }
 
-impl CudaDisplay for cuda_types::CUmemPoolPtrExportData_v1 {
+impl CudaDisplay for CUmemPoolPtrExportData_v1 {
     fn write(
         &self,
         _fn_name: &'static str,
@@ -223,7 +223,7 @@ impl CudaDisplay for *mut i8 {
     }
 }
 
-impl CudaDisplay for cuda_types::CUstreamBatchMemOpParams {
+impl CudaDisplay for CUstreamBatchMemOpParams {
     fn write(
         &self,
         _fn_name: &'static str,
@@ -236,15 +236,15 @@ impl CudaDisplay for cuda_types::CUstreamBatchMemOpParams {
                 // distinct operations with nominally distinct union variants, but
                 // in reality they are structurally different, so we take a little
                 // shortcut here
-                cuda_types::CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WAIT_VALUE_32
+                CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WAIT_VALUE_32
-                | cuda_types::CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WRITE_VALUE_32 => {
+                | CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WRITE_VALUE_32 => {
                     write_wait_value(&self.waitValue, writer, false)
                 }
-                cuda_types::CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WAIT_VALUE_64
+                CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WAIT_VALUE_64
-                | cuda_types::CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WRITE_VALUE_64 => {
+                | CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WRITE_VALUE_64 => {
                     write_wait_value(&self.waitValue, writer, true)
                 }
-                cuda_types::CUstreamBatchMemOpType::CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES => {
+                CUstreamBatchMemOpType::CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES => {
                     CudaDisplay::write(&self.flushRemoteWrites, "", 0, writer)
                 }
                 _ => {
@@ -258,7 +258,7 @@ impl CudaDisplay for cuda_types::CUstreamBatchMemOpParams {
 }
 
 pub fn write_wait_value(
-    this: &cuda_types::CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st,
+    this: &CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st,
     writer: &mut (impl std::io::Write + ?Sized),
     is_64_bit: bool,
 ) -> std::io::Result<()> {
@@ -275,7 +275,7 @@ pub fn write_wait_value(
 }
 
 pub fn write_wait_value_32_or_64(
-    this: &cuda_types::CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1,
+    this: &CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1,
     writer: &mut (impl std::io::Write + ?Sized),
     is_64_bit: bool,
 ) -> std::io::Result<()> {
@@ -288,7 +288,7 @@ pub fn write_wait_value_32_or_64(
     }
 }
 
-impl CudaDisplay for cuda_types::CUDA_RESOURCE_DESC_st {
+impl CudaDisplay for CUDA_RESOURCE_DESC_st {
     fn write(
         &self,
         _fn_name: &'static str,
@@ -298,28 +298,28 @@ impl CudaDisplay for cuda_types::CUDA_RESOURCE_DESC_st {
         writer.write_all(b"{ resType: ")?;
         CudaDisplay::write(&self.resType, "", 0, writer)?;
         match self.resType {
-            cuda_types::CUresourcetype::CU_RESOURCE_TYPE_ARRAY => {
+            CUresourcetype::CU_RESOURCE_TYPE_ARRAY => {
                 writer.write_all(b", res: ")?;
                 CudaDisplay::write(unsafe { &self.res.array }, "", 0, writer)?;
                 writer.write_all(b", flags: ")?;
                 CudaDisplay::write(&self.flags, "", 0, writer)?;
                 writer.write_all(b" }")
             }
-            cuda_types::CUresourcetype::CU_RESOURCE_TYPE_MIPMAPPED_ARRAY => {
+            CUresourcetype::CU_RESOURCE_TYPE_MIPMAPPED_ARRAY => {
                 writer.write_all(b", res: ")?;
                 CudaDisplay::write(unsafe { &self.res.mipmap }, "", 0, writer)?;
                 writer.write_all(b", flags: ")?;
                 CudaDisplay::write(&self.flags, "", 0, writer)?;
                 writer.write_all(b" }")
             }
-            cuda_types::CUresourcetype::CU_RESOURCE_TYPE_LINEAR => {
+            CUresourcetype::CU_RESOURCE_TYPE_LINEAR => {
                 writer.write_all(b", res: ")?;
                 CudaDisplay::write(unsafe { &self.res.linear }, "", 0, writer)?;
                 writer.write_all(b", flags: ")?;
                 CudaDisplay::write(&self.flags, "", 0, writer)?;
                 writer.write_all(b" }")
             }
-            cuda_types::CUresourcetype::CU_RESOURCE_TYPE_PITCH2D => {
+            CUresourcetype::CU_RESOURCE_TYPE_PITCH2D => {
                 writer.write_all(b", res: ")?;
                 CudaDisplay::write(unsafe { &self.res.pitch2D }, "", 0, writer)?;
                 writer.write_all(b", flags: ")?;
@@ -335,7 +335,7 @@ impl CudaDisplay for cuda_types::CUDA_RESOURCE_DESC_st {
     }
 }
 
-impl CudaDisplay for cuda_types::CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st {
+impl CudaDisplay for CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st {
     fn write(
         &self,
         _fn_name: &'static str,
@@ -345,22 +345,22 @@ impl CudaDisplay for cuda_types::CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st {
         writer.write_all(b"{ type: ")?;
         CudaDisplay::write(&self.type_, "", 0, writer)?;
         match self.type_ {
-            cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD => {
+            CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD => {
                 writer.write_all(b", handle: ")?;
                 CudaDisplay::write(unsafe { &self.handle.fd }, "", 0,writer)?;
             }
-            cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32
+            CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32
-            | cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP
+            | CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP
-            | cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE
+            | CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE
-            |cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE => {
+            |CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE => {
                 write_win32_handle(unsafe { self.handle.win32 }, writer)?;
             }
-            cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT
+            CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT
-            | cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT => {
+            | CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT => {
                 writer.write_all(b", handle: ")?;
                 CudaDisplay::write(unsafe { &self.handle.win32.handle }, "", 0,writer)?;
             }
-            cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF => {
+            CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF => {
                 writer.write_all(b", handle: ")?;
                 CudaDisplay::write(unsafe { &self.handle.nvSciBufObject }, "", 0,writer)?;
             }
@@ -381,7 +381,7 @@ impl CudaDisplay for cuda_types::CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st {
 }
 
 pub fn write_win32_handle(
-    win32: cuda_types::CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1,
+    win32: CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1,
     writer: &mut (impl std::io::Write + ?Sized),
 ) -> std::io::Result<()> {
     if win32.handle != ptr::null_mut() {
@@ -400,7 +400,7 @@ pub fn write_win32_handle(
     Ok(())
 }
 
-impl CudaDisplay for cuda_types::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st {
+impl CudaDisplay for CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st {
     fn write(
         &self,
         _fn_name: &'static str,
@@ -410,22 +410,22 @@ impl CudaDisplay for cuda_types::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st {
         writer.write_all(b"{ type: ")?;
         CudaDisplay::write(&self.type_, "", 0, writer)?;
         match self.type_ {
-            cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD => {
+            CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD => {
                 writer.write_all(b", handle: ")?;
                 CudaDisplay::write(unsafe { &self.handle.fd }, "", 0,writer)?;
             }
-            cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32
+            CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32
-            | cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE
+            | CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE
-            | cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE
+            | CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE
-            | cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX
+            | CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX
-            | cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT => {
+            | CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT => {
                 write_win32_handle(unsafe { mem::transmute(self.handle.win32) }, writer)?;
             }
-            cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT => {
+            CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT => {
                 writer.write_all(b", handle: ")?;
                 CudaDisplay::write(unsafe { &self.handle.win32.handle }, "", 0,writer)?;
             }
-            cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC => {
+            CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC => {
                 writer.write_all(b", handle: ")?;
                 CudaDisplay::write(unsafe { &self.handle.nvSciSyncObj }, "", 0,writer)?;
             }
@@ -442,7 +442,7 @@ impl CudaDisplay for cuda_types::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st {
 }
 
 impl CudaDisplay
-    for cuda_types::CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2
+    for CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2
 {
     fn write(
         &self,
@@ -457,7 +457,7 @@ impl CudaDisplay
 }
 
 impl CudaDisplay
-    for cuda_types::CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2
+    for CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2
 {
     fn write(
         &self,
@@ -471,7 +471,7 @@ impl CudaDisplay
     }
 }
 
-impl CudaDisplay for cuda_types::CUgraphNodeParams_st {
+impl CudaDisplay for CUgraphNodeParams_st {
     fn write(
         &self,
         _fn_name: &'static str,
@@ -482,7 +482,7 @@ impl CudaDisplay for cuda_types::CUgraphNodeParams_st {
     }
 }
 
-impl CudaDisplay for cuda_types::CUlaunchConfig_st {
+impl CudaDisplay for CUlaunchConfig_st {
     fn write(
         &self,
         _fn_name: &'static str,
@@ -493,7 +493,7 @@ impl CudaDisplay for cuda_types::CUlaunchConfig_st {
     }
 }
 
-impl CudaDisplay for cuda_types::CUeglFrame_st {
+impl CudaDisplay for CUeglFrame_st {
     fn write(
         &self,
         _fn_name: &'static str,
@@ -504,7 +504,7 @@ impl CudaDisplay for cuda_types::CUeglFrame_st {
     }
 }
 
-impl CudaDisplay for cuda_types::CUdevResource_st {
+impl CudaDisplay for CUdevResource_st {
     fn write(
         &self,
         _fn_name: &'static str,
@@ -514,7 +514,7 @@ impl CudaDisplay for cuda_types::CUdevResource_st {
         todo!()
     }
 }
-impl CudaDisplay for cuda_types::CUlaunchAttribute_st {
+impl CudaDisplay for CUlaunchAttribute_st {
     fn write(
         &self,
         _fn_name: &'static str,
@@ -574,7 +574,7 @@ impl<T: CudaDisplay, const N: usize> CudaDisplay for [T; N] {
     }
 }
 
-impl CudaDisplay for cuda_types::CUarrayMapInfo_st {
+impl CudaDisplay for CUarrayMapInfo_st {
     fn write(
         &self,
         _fn_name: &'static str,
@@ -585,7 +585,7 @@ impl CudaDisplay for cuda_types::CUarrayMapInfo_st {
     }
 }
 
-impl CudaDisplay for cuda_types::CUexecAffinityParam_st {
+impl CudaDisplay for CUexecAffinityParam_st {
     fn write(
         &self,
         _fn_name: &'static str,
@@ -599,9 +599,9 @@ impl CudaDisplay for cuda_types::CUexecAffinityParam_st {
 #[allow(non_snake_case)]
 pub fn write_cuGraphKernelNodeGetAttribute(
     writer: &mut (impl std::io::Write + ?Sized),
-    hNode: cuda_types::CUgraphNode,
+    hNode: CUgraphNode,
-    attr: cuda_types::CUkernelNodeAttrID,
+    attr: CUkernelNodeAttrID,
-    value_out: *mut cuda_types::CUkernelNodeAttrValue,
+    value_out: *mut CUkernelNodeAttrValue,
 ) -> std::io::Result<()> {
     writer.write_all(b"(hNode: ")?;
     CudaDisplay::write(&hNode, "cuGraphKernelNodeGetAttribute", 0, writer)?;
@@ -614,9 +614,9 @@ pub fn write_cuGraphKernelNodeGetAttribute(
 #[allow(non_snake_case)]
 pub fn write_cuGraphKernelNodeSetAttribute(
     writer: &mut (impl std::io::Write + ?Sized),
-    hNode: cuda_types::CUgraphNode,
+    hNode: CUgraphNode,
-    attr: cuda_types::CUkernelNodeAttrID,
+    attr: CUkernelNodeAttrID,
-    value_out: *const cuda_types::CUkernelNodeAttrValue,
+    value_out: *const CUkernelNodeAttrValue,
 ) -> std::io::Result<()> {
     write_cuGraphKernelNodeGetAttribute(writer, hNode, attr, value_out as *mut _)
 }
@@ -624,9 +624,9 @@ pub fn write_cuGraphKernelNodeSetAttribute(
 #[allow(non_snake_case)]
 pub fn write_cuStreamGetAttribute(
     writer: &mut (impl std::io::Write + ?Sized),
-    hStream: cuda_types::CUstream,
+    hStream: CUstream,
-    attr: cuda_types::CUstreamAttrID,
+    attr: CUstreamAttrID,
-    value_out: *mut cuda_types::CUstreamAttrValue,
+    value_out: *mut CUstreamAttrValue,
 ) -> std::io::Result<()> {
     writer.write_all(b"(hStream: ")?;
     CudaDisplay::write(&hStream, "cuStreamGetAttribute", 0, writer)?;
@@ -640,11 +640,11 @@ fn write_launch_attribute(
     writer: &mut (impl std::io::Write + ?Sized),
     fn_name: &'static str,
     index: usize,
-    attribute: cuda_types::CUlaunchAttributeID,
+    attribute: CUlaunchAttributeID,
-    value_out: *mut cuda_types::CUstreamAttrValue,
+    value_out: *mut CUstreamAttrValue,
 ) -> std::io::Result<()> {
     match attribute {
-        cuda_types::CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW => {
+        CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW => {
             writer.write_all(b", value_out: ")?;
             CudaDisplay::write(
                 unsafe { &(*value_out).accessPolicyWindow },
@@ -653,47 +653,47 @@ fn write_launch_attribute(
                 writer,
             )
         }
-        cuda_types::CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_COOPERATIVE => {
+        CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_COOPERATIVE => {
             writer.write_all(b", value_out: ")?;
             CudaDisplay::write(unsafe { &(*value_out).cooperative }, fn_name, index, writer)
         }
-        cuda_types::CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY => {
+        CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY => {
             writer.write_all(b", value_out: ")?;
             CudaDisplay::write(unsafe { &(*value_out).syncPolicy }, fn_name, index, writer)
         }
-        cuda_types::CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION => {
+        CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION => {
             writer.write_all(b", value_out: ")?;
             CudaDisplay::write(unsafe { &(*value_out).clusterDim }, fn_name, index, writer)
         }
-        cuda_types::CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE => {
+        CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE => {
             writer.write_all(b", value_out: ")?;
             CudaDisplay::write(unsafe { &(*value_out).clusterSchedulingPolicyPreference }, fn_name, index, writer)
         }
-        cuda_types::CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION => {
+        CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION => {
             writer.write_all(b", value_out: ")?;
             CudaDisplay::write(unsafe { &(*value_out).programmaticStreamSerializationAllowed }, fn_name, index, writer)
         }
-        cuda_types::CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT => {
+        CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT => {
             writer.write_all(b", value_out: ")?;
             CudaDisplay::write(unsafe { &(*value_out).programmaticEvent }, fn_name, index, writer)
         }
-        cuda_types::CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_PRIORITY => {
+        CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_PRIORITY => {
             writer.write_all(b", value_out: ")?;
             CudaDisplay::write(unsafe { &(*value_out).priority }, fn_name, index, writer)
         }
-        cuda_types::CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_MEM_SYNC_DOMAIN_MAP => {
+        CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_MEM_SYNC_DOMAIN_MAP => {
             writer.write_all(b", value_out: ")?;
             CudaDisplay::write(unsafe { &(*value_out).memSyncDomainMap }, fn_name, index, writer)
         }
-        cuda_types::CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_MEM_SYNC_DOMAIN => {
+        CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_MEM_SYNC_DOMAIN => {
             writer.write_all(b", value_out: ")?;
             CudaDisplay::write(unsafe { &(*value_out).memSyncDomain }, fn_name, index, writer)
         }
-        cuda_types::CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_LAUNCH_COMPLETION_EVENT => {
+        CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_LAUNCH_COMPLETION_EVENT => {
             writer.write_all(b", value_out: ")?;
             CudaDisplay::write(unsafe { &(*value_out).launchCompletionEvent }, fn_name, index, writer)
         }
-        cuda_types::CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_DEVICE_UPDATABLE_KERNEL_NODE => {
+        CUlaunchAttributeID::CU_LAUNCH_ATTRIBUTE_DEVICE_UPDATABLE_KERNEL_NODE => {
             writer.write_all(b", value_out: ")?;
             CudaDisplay::write(unsafe { &(*value_out).deviceUpdatableKernelNode }, fn_name, index, writer)
         }
@@ -704,9 +704,9 @@ fn write_launch_attribute(
 #[allow(non_snake_case)]
 pub fn write_cuStreamGetAttribute_ptsz(
     writer: &mut (impl std::io::Write + ?Sized),
-    hStream: cuda_types::CUstream,
+    hStream: CUstream,
-    attr: cuda_types::CUstreamAttrID,
+    attr: CUstreamAttrID,
-    value_out: *mut cuda_types::CUstreamAttrValue,
+    value_out: *mut CUstreamAttrValue,
 ) -> std::io::Result<()> {
     write_cuStreamGetAttribute(writer, hStream, attr, value_out)
 }
@@ -714,9 +714,9 @@ pub fn write_cuStreamGetAttribute_ptsz(
 #[allow(non_snake_case)]
 pub fn write_cuStreamSetAttribute(
     writer: &mut (impl std::io::Write + ?Sized),
-    hStream: cuda_types::CUstream,
+    hStream: CUstream,
-    attr: cuda_types::CUstreamAttrID,
+    attr: CUstreamAttrID,
-    value_out: *const cuda_types::CUstreamAttrValue,
+    value_out: *const CUstreamAttrValue,
 ) -> std::io::Result<()> {
     write_cuStreamGetAttribute(writer, hStream, attr, value_out as *mut _)
 }
@@ -724,9 +724,9 @@ pub fn write_cuStreamSetAttribute(
 #[allow(non_snake_case)]
 pub fn write_cuStreamSetAttribute_ptsz(
     writer: &mut (impl std::io::Write + ?Sized),
-    hStream: cuda_types::CUstream,
+    hStream: CUstream,
-    attr: cuda_types::CUstreamAttrID,
+    attr: CUstreamAttrID,
-    value_out: *const cuda_types::CUstreamAttrValue,
+    value_out: *const CUstreamAttrValue,
 ) -> std::io::Result<()> {
     write_cuStreamSetAttribute(writer, hStream, attr, value_out)
 }

zluda_dump/src/lib.rs

@@ -1,4 +1,4 @@
-use cuda_types::*;
+use cuda_types::cuda::*;
 use paste::paste;
 use side_by_side::CudaDynamicFns;
 use std::io;

zluda_dump/src/log.rs

@@ -1,8 +1,5 @@
 use crate::format;
-use cuda_types::CUmodule;
+use cuda_types::cuda::*;
-use cuda_types::CUuuid;
-
-use super::CUresult;
 use super::Settings;
 use std::error::Error;
 use std::ffi::c_void;

zluda_dump/src/os_unix.rs

@@ -1,4 +1,4 @@
-use cuda_types::CUuuid;
+use cuda_types::cuda::CUuuid;
 use std::ffi::{c_void, CStr, CString};
 use std::mem;
 

zluda_dump/src/trace.rs

@@ -1,5 +1,5 @@
 use crate::{dark_api, log, Settings};
-use cuda_types::CUmodule;
+use cuda_types::cuda::*;
 use std::{
     collections::HashMap,
     ffi::{c_void, CStr, CString},

zluda_ml/README

@@ -1,3 +0,0 @@
-bindgen "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.0\include\nvml.h" --whitelist-function="^nvml.*" --size_t-is-usize --default-enum-style=newtype --no-layout-tests --no-doc-comments --no-derive-debug -o src/nvml.rs
-sed -i -e 's/extern "C" {//g' -e 's/-> nvmlReturn_t;/-> nvmlReturn_t { crate::r#impl::unimplemented()/g' -e 's/pub fn /#[no_mangle] pub extern "C" fn /g' src/nvml.rs
-rustfmt src/nvml.rs