Archive/ZLUDA
0
0
Fork 0
mirror of https://github.com/vosen/ZLUDA.git synced 2025-04-28 21:47:57 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add support for nvml in zluda_bindgen

Browse source
This commit is contained in:
Andrzej Janik 2024-12-09 15:50:12 +00:00
parent ec63a0b98a
commit c9c7a4d432
22 changed files with 24471 additions and 12236 deletions
Download patch file Download diff file Expand all files Collapse all files

1
.devcontainer/Dockerfile
View file

@ -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}

2
comgr/src/lib.rs
View file

@ -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);

3671
cuda_base/src/cuda.rs
View file

File diff suppressed because it is too large Load diff

7857
cuda_base/src/nvml.rs Normal file
View file

File diff suppressed because it is too large Load diff

8110
cuda_types/src/cuda.rs Normal file
View file

File diff suppressed because it is too large Load diff

8112
cuda_types/src/lib.rs
View file

File diff suppressed because it is too large Load diff

4185
cuda_types/src/nvml.rs Normal file
View file

File diff suppressed because it is too large Load diff

2
zluda/src/impl/context.rs
View file

@ -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};

6
zluda/src/impl/device.rs
View file

@ -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;

4
zluda/src/impl/driver.rs
View file

@ -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(())
}

6
zluda/src/impl/mod.rs
View file

@ -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;

2
zluda/src/impl/module.rs
View file

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

2
zluda/src/impl/pointer.rs
View file

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

129
zluda_bindgen/src/main.rs
View file

@ -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_types(&crate_root, &["..", "cuda_types", "src", "lib.rs"], &module);
generate_functions(
&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"),

2
zluda_dump/src/dark_api.rs
View file

@ -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::{

158
zluda_dump/src/format.rs
View file

@ -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
| cuda_types::CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WRITE_VALUE_32 => {
CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WAIT_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
| cuda_types::CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WRITE_VALUE_64 => {
CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WAIT_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
| cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP
| cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE
|cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE => {
CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32
| CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP
| CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_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
| cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT => {
CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_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
| cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE
| cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE
| cuda_types::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_OPAQUE_WIN32
| CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE
| CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE
| CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX
| 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,
attr: cuda_types::CUkernelNodeAttrID,
value_out: *mut cuda_types::CUkernelNodeAttrValue,
hNode: CUgraphNode,
attr: CUkernelNodeAttrID,
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,
attr: cuda_types::CUkernelNodeAttrID,
value_out: *const cuda_types::CUkernelNodeAttrValue,
hNode: CUgraphNode,
attr: CUkernelNodeAttrID,
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,
attr: cuda_types::CUstreamAttrID,
value_out: *mut cuda_types::CUstreamAttrValue,
hStream: CUstream,
attr: CUstreamAttrID,
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,
value_out: *mut cuda_types::CUstreamAttrValue,
attribute: CUlaunchAttributeID,
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,
attr: cuda_types::CUstreamAttrID,
value_out: *mut cuda_types::CUstreamAttrValue,
hStream: CUstream,
attr: CUstreamAttrID,
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,
attr: cuda_types::CUstreamAttrID,
value_out: *const cuda_types::CUstreamAttrValue,
hStream: CUstream,
attr: CUstreamAttrID,
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,
attr: cuda_types::CUstreamAttrID,
value_out: *const cuda_types::CUstreamAttrValue,
hStream: CUstream,
attr: CUstreamAttrID,
value_out: *const CUstreamAttrValue,
) -> std::io::Result<()> {
write_cuStreamSetAttribute(writer, hStream, attr, value_out)
}

4444
zluda_dump/src/format_generated.rs
View file

File diff suppressed because it is too large Load diff

2
zluda_dump/src/lib.rs
View file

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

5
zluda_dump/src/log.rs
View file

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

2
zluda_dump/src/os_unix.rs
View file

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

2
zluda_dump/src/trace.rs
View file

@ -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},

3
zluda_ml/README
View file

@ -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