Move zluda_dump to the new CUDA infrastructure

1 files changed, 465 insertions, 841 deletions

diff --git a/zluda_dump/src/format.rs b/zluda_dump/src/format.rs
index bee8d4c..5577b30 100644
--- a/zluda_dump/src/format.rs
+++ b/zluda_dump/src/format.rs
@@ -1,953 +1,577 @@
-use paste::paste;

+extern crate cuda_types;

 use std::{

     ffi::{c_void, CStr},

-    io::Write,

-    mem, ptr,

+    fmt::LowerHex,

+    mem, ptr, slice,

 };

 

-use crate::cuda::*;

+use cuda_base::cuda_derive_display_trait;

 

-pub(crate) trait FormatCudaObject {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write);

+pub(crate) trait CudaDisplay {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()>;

 }

 

-fn write_post_execution_ptr<T: FormatCudaObject + Copy>(

-    t: *const T,

-    result: CUresult,

-    f: &mut impl Write,

-) {

-    if t == ptr::null() {

-        write!(f, "NULL").ok();

-    } else if result != CUresult::CUDA_SUCCESS {

-        write!(f, "NONE").ok();

-    } else {

-        unsafe { *t }.write_post_execution(result, f)

-    }

-}

-

-impl<T: FormatCudaObject + Copy> FormatCudaObject for *mut T {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write_post_execution_ptr(self, result, f)

-    }

-}

-

-impl<T: FormatCudaObject + Copy> FormatCudaObject for *const T {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write_post_execution_ptr(self, result, f)

+impl CudaDisplay for cuda_types::CUuuid {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        let guid = self.bytes;

+        write!(writer, "{{{:02X}{:02X}{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}{:02X}{:02X}{:02X}{:02X}}}", guid[0], guid[1], guid[2], guid[3], guid[4], guid[5], guid[6], guid[7], guid[8], guid[9], guid[10], guid[11], guid[12], guid[13], guid[14], guid[15])

     }

 }

 

-impl FormatCudaObject for CUmodule {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for cuda_types::CUdevice {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{}", self.0)

     }

 }

 

-impl FormatCudaObject for CUfunction {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for cuda_types::CUdeviceptr {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{:p}", self.0)

     }

 }

 

-impl FormatCudaObject for *mut c_void {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for cuda_types::CUdeviceptr_v1 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{:p}", self.0 as usize as *const ())

     }

 }

 

-impl FormatCudaObject for *const c_void {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for u8 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{}", *self)

     }

 }

 

-impl FormatCudaObject for CUstream {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for u16 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{}", *self)

     }

 }

 

-impl FormatCudaObject for CUgraphicsResource {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for i32 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{}", *self)

     }

 }

 

-impl FormatCudaObject for CUdeviceptr {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self.0 as *const ()).ok();

+impl CudaDisplay for u32 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{}", *self)

     }

 }

 

-impl FormatCudaObject for CUtexref {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self as *const ()).ok();

+impl CudaDisplay for u64 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{}", *self)

     }

 }

 

-impl FormatCudaObject for CUmipmappedArray {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for usize {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{}", *self)

     }

 }

 

-impl FormatCudaObject for CUarray {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for f32 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{}", *self)

     }

 }

 

-impl FormatCudaObject for CUcontext {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+pub fn write_handle<T: LowerHex>(

+    this: &[T; 64],

+    writer: &mut (impl std::io::Write + ?Sized),

+) -> std::io::Result<()> {

+    writer.write_all(b"0x")?;

+    for i in (0..64).rev() {

+        write!(writer, "{:02x}", this[i])?;

     }

+    Ok(())

 }

 

-impl FormatCudaObject for CUsurfref {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for cuda_types::CUipcMemHandle {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write_handle(&self.reserved, writer)

     }

 }

 

-impl FormatCudaObject for CUgraphNode {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for cuda_types::CUipcEventHandle {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write_handle(&self.reserved, writer)

     }

 }

 

-impl FormatCudaObject for CUgraphExec {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for cuda_types::CUmemPoolPtrExportData_v1 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write_handle(&self.reserved, writer)

     }

 }

 

-impl FormatCudaObject for CUevent {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for *mut c_void {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{:p}", *self)

     }

 }

 

-impl FormatCudaObject for CUgraph {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for *const c_void {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(writer, "{:p}", *self)

     }

 }

 

-impl FormatCudaObject for CUexternalSemaphore {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for *const i8 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(

+            writer,

+            "\"{}\"",

+            unsafe { CStr::from_ptr(*self as _) }.to_string_lossy()

+        )

     }

 }

 

-impl FormatCudaObject for CUexternalMemory {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{:p}", self).ok();

+impl CudaDisplay for *mut i8 {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        write!(

+            writer,

+            "\"{}\"",

+            unsafe { CStr::from_ptr(*self as _) }.to_string_lossy()

+        )

     }

 }

 

-impl FormatCudaObject for CUhostFn {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match self.map(|x| unsafe { mem::transmute::<_, *const ()>(x) }) {

-            Some(x) => write!(f, "{:p}", x),

-            None => write!(f, "NULL"),

+impl CudaDisplay for cuda_types::CUstreamBatchMemOpParams {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        unsafe {

+            match self.operation {

+                // The below is not a typo, `WAIT_VALUE` and `WRITE_VALUE` are

+                // 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 => {

+                    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 => {

+                    write_wait_value(&self.waitValue, writer, true)

+                }

+                cuda_types::CUstreamBatchMemOpType::CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES => {

+                    CudaDisplay::write(&self.flushRemoteWrites, writer)

+                }

+                _ => {

+                    writer.write_all(b"{ operation: ")?;

+                    CudaDisplay::write(&self.operation, writer)?;

+                    writer.write_all(b", ... }")

+                }

+            }

         }

-        .ok();

     }

 }

 

-impl FormatCudaObject for CUoccupancyB2DSize {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match self.map(|x| unsafe { mem::transmute::<_, *const ()>(x) }) {

-            Some(x) => write!(f, "{:p}", x),

-            None => write!(f, "NULL"),

-        }

-        .ok();

+pub fn write_wait_value(

+    this: &cuda_types::CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st,

+    writer: &mut (impl std::io::Write + ?Sized),

+    is_64_bit: bool,

+) -> std::io::Result<()> {

+    writer.write_all(b"{ operation: ")?;

+    CudaDisplay::write(&this.operation, writer)?;

+    writer.write_all(b", address: ")?;

+    CudaDisplay::write(&this.address, writer)?;

+    write_wait_value_32_or_64(&this.__bindgen_anon_1, writer, is_64_bit)?;

+    writer.write_all(b", flags: ")?;

+    CudaDisplay::write(&this.flags, writer)?;

+    writer.write_all(b", alias: ")?;

+    CudaDisplay::write(&this.alias, writer)?;

+    writer.write_all(b" }")

+}

+

+pub fn write_wait_value_32_or_64(

+    this: &cuda_types::CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1,

+    writer: &mut (impl std::io::Write + ?Sized),

+    is_64_bit: bool,

+) -> std::io::Result<()> {

+    if is_64_bit {

+        writer.write_all(b", value64: ")?;

+        CudaDisplay::write(unsafe { &this.value64 }, writer)

+    } else {

+        writer.write_all(b", value: ")?;

+        CudaDisplay::write(unsafe { &this.value }, writer)

     }

 }

 

-impl FormatCudaObject for CUDA_RESOURCE_DESC {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

+impl CudaDisplay for cuda_types::CUDA_RESOURCE_DESC_st {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        writer.write_all(b"{ resType: ")?;

+        CudaDisplay::write(&self.resType, writer)?;

         match self.resType {

-            CU_RESOURCE_TYPE_ARRAY => {

-                write!(

-                    f,

-                    "{{resType: CU_RESOURCE_TYPE_ARRAY, hArray: {:p}, flags: {}}}",

-                    self.res.array.hArray, self.flags

-                )

+            cuda_types::CUresourcetype::CU_RESOURCE_TYPE_ARRAY => {

+                writer.write_all(b", res: ")?;

+                CudaDisplay::write(unsafe { &self.res.array }, writer)?;

+                writer.write_all(b", flags: ")?;

+                CudaDisplay::write(&self.flags, writer)?;

+                writer.write_all(b" }")

             }

-            CU_RESOURCE_TYPE_MIPMAPPED_ARRAY => {

-                write!(

-                    f,

-                    "{{resType: CU_RESOURCE_TYPE_MIPMAPPED_ARRAY, hMipmappedArray: {:p}, flags: {}}}",

-                    self.res.mipmap.hMipmappedArray, self.flags

-                )

+            cuda_types::CUresourcetype::CU_RESOURCE_TYPE_MIPMAPPED_ARRAY => {

+                writer.write_all(b", res: ")?;

+                CudaDisplay::write(unsafe { &self.res.mipmap }, writer)?;

+                writer.write_all(b", flags: ")?;

+                CudaDisplay::write(&self.flags, writer)?;

+                writer.write_all(b" }")

             }

-            CU_RESOURCE_TYPE_LINEAR => {

-                write!(

-                    f,

-                    "{{resType: CU_RESOURCE_TYPE_LINEAR, devPtr: {:p}, format:",

-                    self.res.linear.devPtr.0 as *const ()

-                ).ok();

-                self.res.linear.format.write_post_execution(result, f);

-                write!(

-                    f,

-                    ", numChannels: {}, sizeInBytes: {}}}",

-                    self.res.linear.numChannels, self.res.linear.sizeInBytes,

-                )

+            cuda_types::CUresourcetype::CU_RESOURCE_TYPE_LINEAR => {

+                writer.write_all(b", res: ")?;

+                CudaDisplay::write(unsafe { &self.res.linear }, writer)?;

+                writer.write_all(b", flags: ")?;

+                CudaDisplay::write(&self.flags, writer)?;

+                writer.write_all(b" }")

             }

-            CU_RESOURCE_TYPE_PITCH2D => {

-                write!(

-                    f,

-                    "{{resType: CU_RESOURCE_TYPE_PITCH2D, devPtr: {:p}, format:",

-                    self.res.pitch2D.devPtr.0 as *const ()

-                ).ok();

-                self.res.pitch2D.format.write_post_execution(result, f);

-                write!(

-                    f,

-                    ", numChannels: {}, width: {}, height: {}, pitchInBytes: {}}}",

-                    self.res.pitch2D.numChannels, self.res.pitch2D.width, self.res.pitch2D.height, self.res.pitch2D.pitchInBytes

-                )

+            cuda_types::CUresourcetype::CU_RESOURCE_TYPE_PITCH2D => {

+                writer.write_all(b", res: ")?;

+                CudaDisplay::write(unsafe { &self.res.pitch2D }, writer)?;

+                writer.write_all(b", flags: ")?;

+                CudaDisplay::write(&self.flags, writer)?;

+                writer.write_all(b" }")

             }

             _ => {

-                write!(f, "{{resType: {}, flags: {}}}", self.resType.0, self.flags)

+                writer.write_all(b", flags: ")?;

+                CudaDisplay::write(&self.flags, writer)?;

+                writer.write_all(b", ... }")

             }

         }

-        .ok();

-    }

-}

-

-impl FormatCudaObject for CUDA_RESOURCE_VIEW_DESC {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{{format: ").ok();

-        self.format.write_post_execution(result, f);

-        write!(

-            f,

-            ", width: {}, height: {}, depth: {}, firstMipmapLevel: {}, lastMipmapLevel: {}, firstLayer: {}, lastLayer: {}}}",

-            self.width,

-            self.height,

-            self.depth,

-            self.firstMipmapLevel,

-            self.lastMipmapLevel,

-            self.firstLayer,

-            self.lastLayer

-        ).ok();

-    }

-}

-

-impl FormatCudaObject for CUDA_TEXTURE_DESC {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{{addressMode: [").ok();

-        let [addressMode_0, addressMode_1, addressMode_2] = self.addressMode;

-        addressMode_0.write_post_execution(result, f);

-        write!(f, ", ").ok();

-        addressMode_1.write_post_execution(result, f);

-        write!(f, ", ").ok();

-        addressMode_2.write_post_execution(result, f);

-        write!(

-            f,

-            "], flags: {}, maxAnisotropy: {}, mipmapFilterMode: ",

-            self.flags, self.maxAnisotropy

-        );

-        self.mipmapFilterMode.write_post_execution(result, f);

-        write!(

-            f,

-            ", mipmapLevelBias: {}, minMipmapLevelClamp: {}, maxMipmapLevelClamp: {}, borderColor: [{}, {}, {}, {}]}}",

-            self.mipmapLevelBias,

-            self.minMipmapLevelClamp,

-            self.maxMipmapLevelClamp,

-            self.borderColor[0],

-            self.borderColor[1],

-            self.borderColor[2],

-            self.borderColor[3]

-        ).ok();

-    }

-}

-

-impl FormatCudaObject for CUDA_ARRAY_DESCRIPTOR {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(

-            f,

-            "{{Width: {}, Height: {}, Format: ",

-            self.Width, self.Height

-        )

-        .ok();

-        self.Format.write_post_execution(result, f);

-        write!(f, ",  NumChannels: {}}}", self.NumChannels).ok();

-    }

-}

-

-impl FormatCudaObject for CUDA_MEMCPY3D {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(

-            f,

-            "{{srcXInBytes: {}, srcY: {}, srcZ: {}, srcLOD: {}, srcMemoryType: ",

-            self.srcXInBytes, self.srcY, self.srcZ, self.srcLOD,

-        )

-        .ok();

-        self.srcMemoryType.write_post_execution(result, f);

-        write!(

-            f,

-            ", srcHost: {:p}, srcDevice: {:p}, srcArray: {:p}, srcPitch: {}, srcHeight: {}, dstXInBytes: {}, dstY: {}, dstZ: {}, dstLOD: {}, dstMemoryType: ",

-            self.srcHost,

-            self.srcDevice.0 as *const (),

-            self.srcArray,

-            self.srcPitch,

-            self.srcHeight,

-            self.dstXInBytes,

-            self.dstY,

-            self.dstZ,

-            self.dstLOD,

-        ).ok();

-        self.dstMemoryType.write_post_execution(result, f);

-        write!(

-            f,

-            ", dstHost: {:p}, dstDevice: {:p}, dstArray: {:p}, dstPitch: {}, dstHeight: {}, WidthInBytes: {}, Height: {}, Depth: {}}}",

-            self.dstHost,

-            self.dstDevice.0 as *const (),

-            self.dstArray,

-            self.dstPitch,

-            self.dstHeight,

-            self.WidthInBytes,

-            self.Height,

-            self.Depth,

-        ).ok();

-    }

-}

-

-impl FormatCudaObject for CUmemLocation {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{{type: ").ok();

-        self.type_.write_post_execution(result, f);

-        write!(f, ", id: {}}}", self.id).ok();

-    }

-}

-

-impl FormatCudaObject for *const i8 {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(

-            f,

-            "\"{}\"",

-            unsafe { CStr::from_ptr(self) }.to_str().unwrap()

-        )

-        .ok();

-    }

-}

-

-impl FormatCudaObject for u32 {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{}", self).ok();

-    }

-}

-

-impl FormatCudaObject for u64 {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{}", self).ok();

-    }

-}

-

-impl FormatCudaObject for i32 {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{}", self).ok();

     }

 }

 

-impl FormatCudaObject for f32 {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{}", self).ok();

-    }

-}

-

-impl FormatCudaObject for CUdevice {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{}", self.0).ok();

-    }

-}

-

-impl FormatCudaObject for usize {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{}", self).ok();

-    }

-}

-

-// TODO: support it properly

-impl FormatCudaObject for CUoutput_mode {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        write!(f, "{}", self.0).ok();

-    }

-}

-

-impl FormatCudaObject for CUuuid {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        let guid = self.bytes;

-        write!(f, "{{{:02X}{:02X}{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}{:02X}{:02X}{:02X}{:02X}}}", guid[0], guid[1], guid[2], guid[3], guid[4], guid[5], guid[6], guid[7], guid[8], guid[9], guid[10], guid[11], guid[12], guid[13], guid[14], guid[15]).ok();

-    }

-}

-

-// ENUMS

-

-/*

-impl FormatCudaObject for CUjit_option {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_cujit_option(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

+impl CudaDisplay for cuda_types::CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        writer.write_all(b"{ type: ")?;

+        CudaDisplay::write(&self.type_, writer)?;

+        match self.type_ {

+            cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD => {

+                writer.write_all(b", handle: ")?;

+                CudaDisplay::write(unsafe { &self.handle.fd }, 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 => {

+                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 => {

+                writer.write_all(b", handle: ")?;

+                CudaDisplay::write(unsafe { &self.handle.win32.handle }, writer)?;

+            }

+            cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF => {

+                writer.write_all(b", handle: ")?;

+                CudaDisplay::write(unsafe { &self.handle.nvSciBufObject }, writer)?;

+            }

+            _ => {

+                writer.write_all(b", size: ")?;

+                CudaDisplay::write(&self.size, writer)?;

+                writer.write_all(b", flags: ")?;

+                CudaDisplay::write(&self.flags, writer)?;

+                return writer.write_all(b", ... }")

+            }

         }

-        .ok();

-    }

-}

-

-impl FormatCudaObject for CUdevice_attribute {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_cudevice_attribute(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

+        writer.write_all(b", size: ")?;

+        CudaDisplay::write(&self.size, writer)?;

+        writer.write_all(b", flags: ")?;

+        CudaDisplay::write(&self.flags, writer)?;

+        writer.write_all(b" }")

+    }

+}

+

+pub fn write_win32_handle(

+    win32: cuda_types::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() {

+        writer.write_all(b", handle: ")?;

+        CudaDisplay::write(&win32.handle, writer)?;

+    }

+    if win32.name != ptr::null_mut() {

+        let name_ptr = win32.name as *const u16;

+        let mut strlen = 0usize;

+        while unsafe { *name_ptr.add(strlen) } != 0 {

+            strlen += 1;

         }

-        .ok();

+        let text = String::from_utf16_lossy(unsafe { slice::from_raw_parts(name_ptr, strlen) });

+        write!(writer, ", name: \"{}\"", text)?;

     }

+    Ok(())

 }

 

-impl FormatCudaObject for CUdevice_P2PAttribute {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_cudevice_p2pattribute(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

+impl CudaDisplay for cuda_types::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        writer.write_all(b"{ type: ")?;

+        CudaDisplay::write(&self.type_, writer)?;

+        match self.type_ {

+            cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD => {

+                writer.write_all(b", handle: ")?;

+                CudaDisplay::write(unsafe { &self.handle.fd }, 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 => {

+                write_win32_handle(unsafe { mem::transmute(self.handle.win32) }, writer)?;

+            }

+            cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT => {

+                writer.write_all(b", handle: ")?;

+                CudaDisplay::write(unsafe { &self.handle.win32.handle }, writer)?;

+            }

+            cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC => {

+                writer.write_all(b", handle: ")?;

+                CudaDisplay::write(unsafe { &self.handle.nvSciSyncObj }, writer)?;

+            }

+            _ => {

+                writer.write_all(b", flags: ")?;

+                CudaDisplay::write(&self.flags, writer)?;

+                return writer.write_all(b", ... }")

+            }

         }

-        .ok();

+        writer.write_all(b", flags: ")?;

+        CudaDisplay::write(&self.flags, writer)?;

+        writer.write_all(b" }")

     }

 }

 

-impl FormatCudaObject for CUarray_format {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_cuarray_format(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

-        }

-        .ok();

+impl CudaDisplay

+    for cuda_types::CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2

+{

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        writer.write_all(b"{ fence: ")?;

+        CudaDisplay::write(&unsafe { self.fence }, writer)?;

+        writer.write_all(b" }")

     }

 }

 

-impl FormatCudaObject for CUresourceViewFormat {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_curesourceview_format(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

-        }

-        .ok();

+impl CudaDisplay

+    for cuda_types::CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2

+{

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        writer.write_all(b"{ fence: ")?;

+        CudaDisplay::write(&unsafe { self.fence }, writer)?;

+        writer.write_all(b" }")

     }

 }

 

-impl FormatCudaObject for CUaddress_mode {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_cuaddress_mode(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

+impl<T: CudaDisplay> CudaDisplay for *mut T {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        if *self == ptr::null_mut() {

+            writer.write_all(b"NULL")

+        } else {

+            let this: &T = unsafe { &**self };

+            this.write(writer)

         }

-        .ok();

     }

 }

 

-impl FormatCudaObject for CUfilter_mode {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_cufilter_mode(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

+impl<T: CudaDisplay> CudaDisplay for *const T {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        if *self == ptr::null() {

+            writer.write_all(b"NULL")

+        } else {

+            let this: &T = unsafe { &**self };

+            this.write(writer)

         }

-        .ok();

     }

 }

 

-impl FormatCudaObject for CUgraphExecUpdateResult {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_cugraph_exec_updateresult(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

+impl<T: CudaDisplay, const N: usize> CudaDisplay for [T; N] {

+    fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {

+        writer.write_all(b"[")?;

+        for i in 0..N {

+            CudaDisplay::write(self, writer)?;

+            if i != N - 1 {

+                writer.write_all(b", ")?;

+            }

         }

-        .ok();

-    }

-}

-

-impl FormatCudaObject for CUmemorytype {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_cumemorytype(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

+        writer.write_all(b"]")

+    }

+}

+

+#[allow(non_snake_case)]

+pub fn write_cuStreamBatchMemOp(

+    writer: &mut (impl std::io::Write + ?Sized),

+    stream: cuda_types::CUstream,

+    count: ::std::os::raw::c_uint,

+    paramArray: *mut cuda_types::CUstreamBatchMemOpParams,

+    flags: ::std::os::raw::c_uint,

+) -> std::io::Result<()> {

+    writer.write_all(b"(stream: ")?;

+    CudaDisplay::write(&stream, writer)?;

+    writer.write_all(b", ")?;

+    writer.write_all(b"count: ")?;

+    CudaDisplay::write(&count, writer)?;

+    writer.write_all(b", paramArray: [")?;

+    for i in 0..count {

+        if i != 0 {

+            writer.write_all(b", ")?;

         }

-        .ok();

-    }

-}

-

-impl FormatCudaObject for CUmemLocationType {

-    fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-        match stringify_cumemorytype(self) {

-            Some(text) => write!(f, "{}", text),

-            None => write!(f, "{}", self.0),

+        CudaDisplay::write(&unsafe { paramArray.add(i as usize) }, writer)?;

+    }

+    writer.write_all(b"], flags: ")?;

+    CudaDisplay::write(&flags, writer)?;

+    writer.write_all(b") ")

+}

+

+#[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,

+) -> std::io::Result<()> {

+    writer.write_all(b"(hNode: ")?;

+    CudaDisplay::write(&hNode, writer)?;

+    writer.write_all(b", attr: ")?;

+    CudaDisplay::write(&attr, writer)?;

+    match attr {

+        cuda_types::CUkernelNodeAttrID::CU_KERNEL_NODE_ATTRIBUTE_ACCESS_POLICY_WINDOW => {

+            writer.write_all(b", value_out: ")?;

+            CudaDisplay::write(unsafe { &(*value_out).accessPolicyWindow }, writer)?;

         }

-        .ok();

-    }

-}

-*/

-

-macro_rules! stringify_enum {

-    ($type_:ident, [ $($variant:ident),+ ]) => {

-        paste! {

-            pub(crate) fn [<stringify_ $type_>](x: $type_) -> Option<&'static str> {

-                match x {

-                    $(

-                        $type_::$variant => Some(stringify!($variant)),

-                    )+

-                    _ => None

-                }

-            }

-

-            impl FormatCudaObject for $type_ {

-                fn write_post_execution(self, result: CUresult, f: &mut impl Write) {

-                    match [<stringify_ $type_>](self) {

-                        Some(text) => write!(f, "{}", text),

-                        None => write!(f, "{}", self.0),

-                    }

-                    .ok();

-                }

-            }

+        cuda_types::CUkernelNodeAttrID::CU_KERNEL_NODE_ATTRIBUTE_COOPERATIVE => {

+            writer.write_all(b", value_out: ")?;

+            CudaDisplay::write(unsafe { &(*value_out).cooperative }, writer)?;

         }

-    }

-}

-

-stringify_enum! {

-    CUdevice_attribute_enum,

-    [

-        CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK,

-        CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X,

-        CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y,

-        CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z,

-        CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X,

-        CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y,

-        CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z,

-        CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK,

-        CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK,

-        CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY,

-        CU_DEVICE_ATTRIBUTE_WARP_SIZE,

-        CU_DEVICE_ATTRIBUTE_MAX_PITCH,

-        CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK,

-        CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK,

-        CU_DEVICE_ATTRIBUTE_CLOCK_RATE,

-        CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT,

-        CU_DEVICE_ATTRIBUTE_GPU_OVERLAP,

-        CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT,

-        CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT,

-        CU_DEVICE_ATTRIBUTE_INTEGRATED,

-        CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY,

-        CU_DEVICE_ATTRIBUTE_COMPUTE_MODE,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES,

-        CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT,

-        CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS,

-        CU_DEVICE_ATTRIBUTE_ECC_ENABLED,

-        CU_DEVICE_ATTRIBUTE_PCI_BUS_ID,

-        CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID,

-        CU_DEVICE_ATTRIBUTE_TCC_DRIVER,

-        CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE,

-        CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH,

-        CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE,

-        CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR,

-        CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT,

-        CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS,

-        CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE,

-        CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID,

-        CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT,

-        CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR,

-        CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR,

-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH,

-        CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR,

-        CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR,

-        CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY,

-        CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD,

-        CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID,

-        CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO,

-        CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS,

-        CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS,

-        CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM,

-        CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS,

-        CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS,

-        CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR,

-        CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH,

-        CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH,

-        CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN,

-        CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES,

-        CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES,

-        CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST,

-        CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR,

-        CU_DEVICE_ATTRIBUTE_GENERIC_COMPRESSION_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_MAX_PERSISTING_L2_CACHE_SIZE,

-        CU_DEVICE_ATTRIBUTE_MAX_ACCESS_POLICY_WINDOW_SIZE,

-        CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WITH_CUDA_VMM_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK,

-        CU_DEVICE_ATTRIBUTE_SPARSE_CUDA_ARRAY_SUPPORTED,

-        CU_DEVICE_ATTRIBUTE_READ_ONLY_HOST_REGISTER_SUPPORTED

-    ]

-}

-

-stringify_enum! {

-    CUjit_option,

-    [

-        CU_JIT_MAX_REGISTERS,

-        CU_JIT_THREADS_PER_BLOCK,

-        CU_JIT_WALL_TIME,

-        CU_JIT_INFO_LOG_BUFFER,

-        CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES,

-        CU_JIT_ERROR_LOG_BUFFER,

-        CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES,

-        CU_JIT_OPTIMIZATION_LEVEL,

-        CU_JIT_TARGET_FROM_CUCONTEXT,

-        CU_JIT_TARGET,

-        CU_JIT_FALLBACK_STRATEGY,

-        CU_JIT_GENERATE_DEBUG_INFO,

-        CU_JIT_LOG_VERBOSE,

-        CU_JIT_GENERATE_LINE_INFO,

-        CU_JIT_CACHE_MODE,

-        CU_JIT_NEW_SM3X_OPT,

-        CU_JIT_FAST_COMPILE,

-        CU_JIT_GLOBAL_SYMBOL_NAMES,

-        CU_JIT_GLOBAL_SYMBOL_ADDRESSES,

-        CU_JIT_GLOBAL_SYMBOL_COUNT,

-        CU_JIT_NUM_OPTIONS

-    ]

-}

-

-stringify_enum! {

-    CUresult,

-    [

-        CUDA_SUCCESS,

-        CUDA_ERROR_INVALID_VALUE,

-        CUDA_ERROR_OUT_OF_MEMORY,

-        CUDA_ERROR_NOT_INITIALIZED,

-        CUDA_ERROR_DEINITIALIZED,

-        CUDA_ERROR_PROFILER_DISABLED,

-        CUDA_ERROR_PROFILER_NOT_INITIALIZED,

-        CUDA_ERROR_PROFILER_ALREADY_STARTED,

-        CUDA_ERROR_PROFILER_ALREADY_STOPPED,

-        CUDA_ERROR_NO_DEVICE,

-        CUDA_ERROR_INVALID_DEVICE,

-        CUDA_ERROR_INVALID_IMAGE,

-        CUDA_ERROR_INVALID_CONTEXT,

-        CUDA_ERROR_CONTEXT_ALREADY_CURRENT,

-        CUDA_ERROR_MAP_FAILED,

-        CUDA_ERROR_UNMAP_FAILED,

-        CUDA_ERROR_ARRAY_IS_MAPPED,

-        CUDA_ERROR_ALREADY_MAPPED,

-        CUDA_ERROR_NO_BINARY_FOR_GPU,

-        CUDA_ERROR_ALREADY_ACQUIRED,

-        CUDA_ERROR_NOT_MAPPED,

-        CUDA_ERROR_NOT_MAPPED_AS_ARRAY,

-        CUDA_ERROR_NOT_MAPPED_AS_POINTER,

-        CUDA_ERROR_ECC_UNCORRECTABLE,

-        CUDA_ERROR_UNSUPPORTED_LIMIT,

-        CUDA_ERROR_CONTEXT_ALREADY_IN_USE,

-        CUDA_ERROR_PEER_ACCESS_UNSUPPORTED,

-        CUDA_ERROR_INVALID_PTX,

-        CUDA_ERROR_INVALID_GRAPHICS_CONTEXT,

-        CUDA_ERROR_NVLINK_UNCORRECTABLE,

-        CUDA_ERROR_JIT_COMPILER_NOT_FOUND,

-        CUDA_ERROR_INVALID_SOURCE,

-        CUDA_ERROR_FILE_NOT_FOUND,

-        CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND,

-        CUDA_ERROR_SHARED_OBJECT_INIT_FAILED,

-        CUDA_ERROR_OPERATING_SYSTEM,

-        CUDA_ERROR_INVALID_HANDLE,

-        CUDA_ERROR_ILLEGAL_STATE,

-        CUDA_ERROR_NOT_FOUND,

-        CUDA_ERROR_NOT_READY,

-        CUDA_ERROR_ILLEGAL_ADDRESS,

-        CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES,

-        CUDA_ERROR_LAUNCH_TIMEOUT,

-        CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING,

-        CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED,

-        CUDA_ERROR_PEER_ACCESS_NOT_ENABLED,

-        CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE,

-        CUDA_ERROR_CONTEXT_IS_DESTROYED,

-        CUDA_ERROR_ASSERT,

-        CUDA_ERROR_TOO_MANY_PEERS,

-        CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED,

-        CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED,

-        CUDA_ERROR_HARDWARE_STACK_ERROR,

-        CUDA_ERROR_ILLEGAL_INSTRUCTION,

-        CUDA_ERROR_MISALIGNED_ADDRESS,

-        CUDA_ERROR_INVALID_ADDRESS_SPACE,

-        CUDA_ERROR_INVALID_PC,

-        CUDA_ERROR_LAUNCH_FAILED,

-        CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE,

-        CUDA_ERROR_NOT_PERMITTED,

-        CUDA_ERROR_NOT_SUPPORTED,

-        CUDA_ERROR_SYSTEM_NOT_READY,

-        CUDA_ERROR_SYSTEM_DRIVER_MISMATCH,

-        CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE,

-        CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED,

-        CUDA_ERROR_STREAM_CAPTURE_INVALIDATED,

-        CUDA_ERROR_STREAM_CAPTURE_MERGE,

-        CUDA_ERROR_STREAM_CAPTURE_UNMATCHED,

-        CUDA_ERROR_STREAM_CAPTURE_UNJOINED,

-        CUDA_ERROR_STREAM_CAPTURE_ISOLATION,

-        CUDA_ERROR_STREAM_CAPTURE_IMPLICIT,

-        CUDA_ERROR_CAPTURED_EVENT,

-        CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD,

-        CUDA_ERROR_TIMEOUT,

-        CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE,

-        CUDA_ERROR_UNKNOWN

-    ]

-}

-

-stringify_enum! {

-    CUdevice_P2PAttribute,

-    [

-        CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK,

-        CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED,

-        CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED,

-        CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED,

-        CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED

-    ]

-}

-

-stringify_enum! {

-    CUarray_format,

-    [

-        CU_AD_FORMAT_UNSIGNED_INT8,

-        CU_AD_FORMAT_UNSIGNED_INT16,

-        CU_AD_FORMAT_UNSIGNED_INT32,

-        CU_AD_FORMAT_SIGNED_INT8,

-        CU_AD_FORMAT_SIGNED_INT16,

-        CU_AD_FORMAT_SIGNED_INT32,

-        CU_AD_FORMAT_HALF,

-        CU_AD_FORMAT_FLOAT

-    ]

-}

-

-stringify_enum! {

-    CUresourceViewFormat,

-    [

-        CU_RES_VIEW_FORMAT_NONE,

-        CU_RES_VIEW_FORMAT_UINT_1X8,

-        CU_RES_VIEW_FORMAT_UINT_2X8,

-        CU_RES_VIEW_FORMAT_UINT_4X8,

-        CU_RES_VIEW_FORMAT_SINT_1X8,

-        CU_RES_VIEW_FORMAT_SINT_2X8,

-        CU_RES_VIEW_FORMAT_SINT_4X8,

-        CU_RES_VIEW_FORMAT_UINT_1X16,

-        CU_RES_VIEW_FORMAT_UINT_2X16,

-        CU_RES_VIEW_FORMAT_UINT_4X16,

-        CU_RES_VIEW_FORMAT_SINT_1X16,

-        CU_RES_VIEW_FORMAT_SINT_2X16,

-        CU_RES_VIEW_FORMAT_SINT_4X16,

-        CU_RES_VIEW_FORMAT_UINT_1X32,

-        CU_RES_VIEW_FORMAT_UINT_2X32,

-        CU_RES_VIEW_FORMAT_UINT_4X32,

-        CU_RES_VIEW_FORMAT_SINT_1X32,

-        CU_RES_VIEW_FORMAT_SINT_2X32,

-        CU_RES_VIEW_FORMAT_SINT_4X32,

-        CU_RES_VIEW_FORMAT_FLOAT_1X16,

-        CU_RES_VIEW_FORMAT_FLOAT_2X16,

-        CU_RES_VIEW_FORMAT_FLOAT_4X16,

-        CU_RES_VIEW_FORMAT_FLOAT_1X32,

-        CU_RES_VIEW_FORMAT_FLOAT_2X32,

-        CU_RES_VIEW_FORMAT_FLOAT_4X32,

-        CU_RES_VIEW_FORMAT_UNSIGNED_BC1,

-        CU_RES_VIEW_FORMAT_UNSIGNED_BC2,

-        CU_RES_VIEW_FORMAT_UNSIGNED_BC3,

-        CU_RES_VIEW_FORMAT_UNSIGNED_BC4,

-        CU_RES_VIEW_FORMAT_SIGNED_BC4,

-        CU_RES_VIEW_FORMAT_UNSIGNED_BC5,

-        CU_RES_VIEW_FORMAT_SIGNED_BC5,

-        CU_RES_VIEW_FORMAT_UNSIGNED_BC6H,

-        CU_RES_VIEW_FORMAT_SIGNED_BC6H,

-        CU_RES_VIEW_FORMAT_UNSIGNED_BC7

-    ]

-}

-

-stringify_enum! {

-    CUaddress_mode,

-    [

-        CU_TR_ADDRESS_MODE_WRAP,

-        CU_TR_ADDRESS_MODE_CLAMP,

-        CU_TR_ADDRESS_MODE_MIRROR,

-        CU_TR_ADDRESS_MODE_BORDER

-    ]

-}

-

-stringify_enum! {

-    CUfilter_mode,

-    [

-        CU_TR_FILTER_MODE_POINT,

-        CU_TR_FILTER_MODE_LINEAR

-    ]

-}

-

-stringify_enum! {

-    CUgraphExecUpdateResult,

-    [

-        CU_GRAPH_EXEC_UPDATE_SUCCESS,

-        CU_GRAPH_EXEC_UPDATE_ERROR,

-        CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED,

-        CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED,

-        CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED,

-        CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED,

-        CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED

-    ]

-}

-

-stringify_enum! {

-    CUmemorytype,

-    [

-        CU_MEMORYTYPE_HOST,

-        CU_MEMORYTYPE_DEVICE,

-        CU_MEMORYTYPE_ARRAY,

-        CU_MEMORYTYPE_UNIFIED

-    ]

-}

-

-stringify_enum! {

-    CUmemLocationType,

-    [

-        CU_MEM_LOCATION_TYPE_INVALID,

-        CU_MEM_LOCATION_TYPE_DEVICE

-    ]

-}

-

-stringify_enum! {

-    CUlimit,

-    [

-        CU_LIMIT_STACK_SIZE,

-        CU_LIMIT_PRINTF_FIFO_SIZE,

-        CU_LIMIT_MALLOC_HEAP_SIZE,

-        CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH,

-        CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT,

-        CU_LIMIT_MAX_L2_FETCH_GRANULARITY,

-        CU_LIMIT_PERSISTING_L2_CACHE_SIZE

-    ]

-}

-

-stringify_enum! {

-    CUpointer_attribute,

-    [

-        CU_POINTER_ATTRIBUTE_CONTEXT,

-        CU_POINTER_ATTRIBUTE_MEMORY_TYPE,

-        CU_POINTER_ATTRIBUTE_DEVICE_POINTER,

-        CU_POINTER_ATTRIBUTE_HOST_POINTER,

-        CU_POINTER_ATTRIBUTE_P2P_TOKENS,

-        CU_POINTER_ATTRIBUTE_SYNC_MEMOPS,

-        CU_POINTER_ATTRIBUTE_BUFFER_ID,

-        CU_POINTER_ATTRIBUTE_IS_MANAGED,

-        CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL,

-        CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE,

-        CU_POINTER_ATTRIBUTE_RANGE_START_ADDR,

-        CU_POINTER_ATTRIBUTE_RANGE_SIZE,

-        CU_POINTER_ATTRIBUTE_MAPPED,

-        CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES,

-        CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE,

-        CU_POINTER_ATTRIBUTE_ACCESS_FLAGS

-    ]

-}

-

-stringify_enum! {

-    CUfunction_attribute,

-    [

-        CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK,

-        CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES,

-        CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES,

-        CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES,

-        CU_FUNC_ATTRIBUTE_NUM_REGS,

-        CU_FUNC_ATTRIBUTE_PTX_VERSION,

-        CU_FUNC_ATTRIBUTE_BINARY_VERSION,

-        CU_FUNC_ATTRIBUTE_CACHE_MODE_CA,

-        CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES,

-        CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT

-    ]

-}

-

-stringify_enum! {

-    CUmem_range_attribute,

-    [

-        CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY,

-        CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION,

-        CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY,

-        CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION

-    ]

-}

-

-stringify_enum! {

-    CUfunc_cache,

-    [

-        CU_FUNC_CACHE_PREFER_NONE,

-        CU_FUNC_CACHE_PREFER_SHARED,

-        CU_FUNC_CACHE_PREFER_L1,

-        CU_FUNC_CACHE_PREFER_EQUAL

-    ]

-}

-

-stringify_enum! {

-    CUstreamCaptureMode,

+        _ => return writer.write_all(b", ...) "),

+    }

+    writer.write_all(b") ")

+}

+

+#[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,

+) -> std::io::Result<()> {

+    write_cuGraphKernelNodeGetAttribute(writer, hNode, attr, value_out as *mut _)

+}

+

+#[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,

+) -> std::io::Result<()> {

+    writer.write_all(b"(hStream: ")?;

+    CudaDisplay::write(&hStream, writer)?;

+    writer.write_all(b", attr: ")?;

+    CudaDisplay::write(&attr, writer)?;

+    match attr {

+        cuda_types::CUstreamAttrID::CU_STREAM_ATTRIBUTE_ACCESS_POLICY_WINDOW => {

+            writer.write_all(b", value_out: ")?;

+            CudaDisplay::write(unsafe { &(*value_out).accessPolicyWindow }, writer)?;

+        }

+        cuda_types::CUstreamAttrID::CU_STREAM_ATTRIBUTE_SYNCHRONIZATION_POLICY => {

+            writer.write_all(b", value_out: ")?;

+            CudaDisplay::write(unsafe { &(*value_out).syncPolicy }, writer)?;

+        }

+        _ => return writer.write_all(b", ...) "),

+    }

+    writer.write_all(b") ")

+}

+

+#[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,

+) -> std::io::Result<()> {

+    write_cuStreamGetAttribute(writer, hStream, attr, value_out)

+}

+

+#[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,

+) -> std::io::Result<()> {

+    write_cuStreamGetAttribute(writer, hStream, attr, value_out as *mut _)

+}

+

+#[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,

+) -> std::io::Result<()> {

+    write_cuStreamSetAttribute(writer, hStream, attr, value_out)

+}

+

+#[allow(non_snake_case)]

+pub fn write_cuCtxCreate_v3(

+    _writer: &mut (impl std::io::Write + ?Sized),

+    _pctx: *mut cuda_types::CUcontext,

+    _paramsArray: *mut cuda_types::CUexecAffinityParam,

+    _numParams: ::std::os::raw::c_int,

+    _flags: ::std::os::raw::c_uint,

+    _dev: cuda_types::CUdevice,

+) -> std::io::Result<()> {

+    todo!()

+}

+

+#[allow(non_snake_case)]

+pub fn write_cuCtxGetExecAffinity(

+    _writer: &mut (impl std::io::Write + ?Sized),

+    _pExecAffinity: *mut cuda_types::CUexecAffinityParam,

+    _type_: cuda_types::CUexecAffinityType,

+) -> std::io::Result<()> {

+    todo!()

+}

+

+#[allow(non_snake_case)]

+pub fn write_cuMemMapArrayAsync(

+    _writer: &mut (impl std::io::Write + ?Sized),

+    _mapInfoList: *mut cuda_types::CUarrayMapInfo,

+    _count: ::std::os::raw::c_uint,

+    _hStream: cuda_types::CUstream,

+) -> std::io::Result<()> {

+    todo!()

+}

+

+#[allow(non_snake_case)]

+pub fn write_cuMemMapArrayAsync_ptsz(

+    writer: &mut (impl std::io::Write + ?Sized),

+    mapInfoList: *mut cuda_types::CUarrayMapInfo,

+    count: ::std::os::raw::c_uint,

+    hStream: cuda_types::CUstream,

+) -> std::io::Result<()> {

+    write_cuMemMapArrayAsync(writer, mapInfoList, count, hStream)

+}

+

+cuda_derive_display_trait!(

+    cuda_types,

+    CudaDisplay,

     [

-        CU_STREAM_CAPTURE_MODE_GLOBAL,

-        CU_STREAM_CAPTURE_MODE_THREAD_LOCAL,

-        CU_STREAM_CAPTURE_MODE_RELAXED

-    ]

-}

-

-stringify_enum! {

-    CUmem_advise,

+        CUarrayMapInfo_st,

+        CUDA_RESOURCE_DESC_st,

+        CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st,

+        CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st,

+        CUexecAffinityParam_st,

+        CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st,

+        CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st,

+        CUuuid_st

+    ],

     [

-        CU_MEM_ADVISE_SET_READ_MOSTLY,

-        CU_MEM_ADVISE_UNSET_READ_MOSTLY,

-        CU_MEM_ADVISE_SET_PREFERRED_LOCATION,

-        CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION,

-        CU_MEM_ADVISE_SET_ACCESSED_BY,

-        CU_MEM_ADVISE_UNSET_ACCESSED_BY

+        cuCtxCreate_v3,

+        cuCtxGetExecAffinity,

+        cuGraphKernelNodeGetAttribute,

+        cuGraphKernelNodeSetAttribute,

+        cuMemMapArrayAsync,

+        cuMemMapArrayAsync_ptsz,

+        cuStreamBatchMemOp,

+        cuStreamGetAttribute,

+        cuStreamGetAttribute_ptsz,

+        cuStreamSetAttribute,

+        cuStreamSetAttribute_ptsz

     ]

-}

+);