Struct CudaFunction 

pub struct CudaFunction { /* private fields */ }

Kernel handle bound to XLOG’s default CUDA stream. Retains the exact loaded module independently of its registry name. Releasing the last module owner follows the potentially blocking cold-lifecycle progress contract.

Implementations

impl CudaFunction

pub fn occupancy_available_dynamic_smem_per_block( &self, num_blocks: u32, block_size: u32, ) -> Result<usize, DriverError>

pub fn occupancy_max_active_blocks_per_multiprocessor( &self, block_size: u32, dynamic_smem_size: usize, flags: Option<CUoccupancy_flags_enum>, ) -> Result<u32, DriverError>

pub fn occupancy_max_active_clusters( &self, config: LaunchConfig, ) -> Result<u32, DriverError>

pub fn occupancy_max_potential_block_size( &self, block_size_to_dynamic_smem_size: extern "C" fn(block_size: c_int) -> usize, dynamic_smem_size: usize, block_size_limit: u32, flags: Option<CUoccupancy_flags_enum>, ) -> Result<(u32, u32), DriverError>

pub fn occupancy_max_potential_cluster_size( &self, config: LaunchConfig, ) -> Result<u32, DriverError>

pub fn get_attribute( &self, attribute: CUfunction_attribute_enum, ) -> Result<i32, DriverError>

pub fn num_regs(&self) -> Result<i32, DriverError>

pub fn shared_size_bytes(&self) -> Result<i32, DriverError>

pub fn const_size_bytes(&self) -> Result<i32, DriverError>

pub fn local_size_bytes(&self) -> Result<i32, DriverError>

pub fn max_threads_per_block(&self) -> Result<i32, DriverError>

pub fn ptx_version(&self) -> Result<i32, DriverError>

pub fn binary_version(&self) -> Result<i32, DriverError>

pub fn set_attribute( &self, attribute: CUfunction_attribute_enum, value: i32, ) -> Result<(), DriverError>

pub fn set_function_cache_config( &self, config: CUfunc_cache, ) -> Result<(), DriverError>

Trait Implementations

impl Clone for CudaFunction

fn clone(&self) -> CudaFunction

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CudaFunction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl LaunchAsync<&mut Vec<*mut c_void>> for CudaFunction

unsafe fn launch_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: &mut Vec<*mut c_void>, ) -> Result<(), DriverError>

Launch within an already admitted memory operation, retaining its capture pin.

unsafe fn launch_cooperative_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: &mut Vec<*mut c_void>, ) -> Result<(), DriverError>

Launch cooperatively within an already admitted memory operation.

unsafe fn launch( self, cfg: LaunchConfig, params: &mut Vec<*mut c_void>, ) -> Result<(), DriverError>

Launch a kernel on the function’s default stream.

unsafe fn launch_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: &mut Vec<*mut c_void>, ) -> Result<(), DriverError>

Launch a kernel on an explicit CUDA stream.

unsafe fn launch_cooperative( self, cfg: LaunchConfig, params: &mut Vec<*mut c_void>, ) -> Result<(), DriverError>

Launch a cooperative kernel.

unsafe fn launch_cooperative_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: &mut Vec<*mut c_void>, ) -> Result<(), DriverError>

Launch a cooperative kernel on an explicit CUDA stream.

impl LaunchAsync<&mut [*mut c_void]> for CudaFunction

unsafe fn launch_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: &mut [*mut c_void], ) -> Result<(), DriverError>

Launch within an already admitted memory operation, retaining its capture pin.

unsafe fn launch_cooperative_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: &mut [*mut c_void], ) -> Result<(), DriverError>

Launch cooperatively within an already admitted memory operation.

unsafe fn launch( self, cfg: LaunchConfig, params: &mut [*mut c_void], ) -> Result<(), DriverError>

Launch a kernel on the function’s default stream.

unsafe fn launch_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: &mut [*mut c_void], ) -> Result<(), DriverError>

Launch a kernel on an explicit CUDA stream.

unsafe fn launch_cooperative( self, cfg: LaunchConfig, params: &mut [*mut c_void], ) -> Result<(), DriverError>

Launch a cooperative kernel.

unsafe fn launch_cooperative_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: &mut [*mut c_void], ) -> Result<(), DriverError>

Launch a cooperative kernel on an explicit CUDA stream.

impl<A: IntoKernelParamStorage, B: IntoKernelParamStorage> LaunchAsync<(A, B)> for CudaFunction

unsafe fn launch_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B), ) -> Result<(), DriverError>

Launch within an already admitted memory operation, retaining its capture pin.

unsafe fn launch_cooperative_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B), ) -> Result<(), DriverError>

Launch cooperatively within an already admitted memory operation.

unsafe fn launch( self, cfg: LaunchConfig, params: (A, B), ) -> Result<(), DriverError>

Launch a kernel on the function’s default stream.

unsafe fn launch_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B), ) -> Result<(), DriverError>

Launch a kernel on an explicit CUDA stream.

unsafe fn launch_cooperative( self, cfg: LaunchConfig, params: (A, B), ) -> Result<(), DriverError>

Launch a cooperative kernel.

unsafe fn launch_cooperative_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B), ) -> Result<(), DriverError>

Launch a cooperative kernel on an explicit CUDA stream.

impl<A: IntoKernelParamStorage, B: IntoKernelParamStorage, C: IntoKernelParamStorage> LaunchAsync<(A, B, C)> for CudaFunction

unsafe fn launch_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C), ) -> Result<(), DriverError>

Launch within an already admitted memory operation, retaining its capture pin.

unsafe fn launch_cooperative_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C), ) -> Result<(), DriverError>

Launch cooperatively within an already admitted memory operation.

unsafe fn launch( self, cfg: LaunchConfig, params: (A, B, C), ) -> Result<(), DriverError>

Launch a kernel on the function’s default stream.

unsafe fn launch_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C), ) -> Result<(), DriverError>

Launch a kernel on an explicit CUDA stream.

unsafe fn launch_cooperative( self, cfg: LaunchConfig, params: (A, B, C), ) -> Result<(), DriverError>

Launch a cooperative kernel.

unsafe fn launch_cooperative_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C), ) -> Result<(), DriverError>

Launch a cooperative kernel on an explicit CUDA stream.

impl<A: IntoKernelParamStorage, B: IntoKernelParamStorage, C: IntoKernelParamStorage, D: IntoKernelParamStorage> LaunchAsync<(A, B, C, D)> for CudaFunction

unsafe fn launch_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D), ) -> Result<(), DriverError>

Launch within an already admitted memory operation, retaining its capture pin.

unsafe fn launch_cooperative_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D), ) -> Result<(), DriverError>

Launch cooperatively within an already admitted memory operation.

unsafe fn launch( self, cfg: LaunchConfig, params: (A, B, C, D), ) -> Result<(), DriverError>

Launch a kernel on the function’s default stream.

unsafe fn launch_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D), ) -> Result<(), DriverError>

Launch a kernel on an explicit CUDA stream.

unsafe fn launch_cooperative( self, cfg: LaunchConfig, params: (A, B, C, D), ) -> Result<(), DriverError>

Launch a cooperative kernel.

unsafe fn launch_cooperative_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D), ) -> Result<(), DriverError>

Launch a cooperative kernel on an explicit CUDA stream.

impl<A: IntoKernelParamStorage, B: IntoKernelParamStorage, C: IntoKernelParamStorage, D: IntoKernelParamStorage, E: IntoKernelParamStorage> LaunchAsync<(A, B, C, D, E)> for CudaFunction

unsafe fn launch_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D, E), ) -> Result<(), DriverError>

Launch within an already admitted memory operation, retaining its capture pin.

unsafe fn launch_cooperative_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D, E), ) -> Result<(), DriverError>

Launch cooperatively within an already admitted memory operation.

unsafe fn launch( self, cfg: LaunchConfig, params: (A, B, C, D, E), ) -> Result<(), DriverError>

Launch a kernel on the function’s default stream.

unsafe fn launch_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D, E), ) -> Result<(), DriverError>

Launch a kernel on an explicit CUDA stream.

unsafe fn launch_cooperative( self, cfg: LaunchConfig, params: (A, B, C, D, E), ) -> Result<(), DriverError>

Launch a cooperative kernel.

unsafe fn launch_cooperative_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D, E), ) -> Result<(), DriverError>

Launch a cooperative kernel on an explicit CUDA stream.

impl<A: IntoKernelParamStorage, B: IntoKernelParamStorage, C: IntoKernelParamStorage, D: IntoKernelParamStorage, E: IntoKernelParamStorage, F: IntoKernelParamStorage> LaunchAsync<(A, B, C, D, E, F)> for CudaFunction

unsafe fn launch_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D, E, F), ) -> Result<(), DriverError>

Launch within an already admitted memory operation, retaining its capture pin.

unsafe fn launch_cooperative_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D, E, F), ) -> Result<(), DriverError>

Launch cooperatively within an already admitted memory operation.

unsafe fn launch( self, cfg: LaunchConfig, params: (A, B, C, D, E, F), ) -> Result<(), DriverError>

Launch a kernel on the function’s default stream.

unsafe fn launch_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D, E, F), ) -> Result<(), DriverError>

Launch a kernel on an explicit CUDA stream.

unsafe fn launch_cooperative( self, cfg: LaunchConfig, params: (A, B, C, D, E, F), ) -> Result<(), DriverError>

Launch a cooperative kernel.

unsafe fn launch_cooperative_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D, E, F), ) -> Result<(), DriverError>

Launch a cooperative kernel on an explicit CUDA stream.

impl<A: IntoKernelParamStorage, B: IntoKernelParamStorage, C: IntoKernelParamStorage, D: IntoKernelParamStorage, E: IntoKernelParamStorage, F: IntoKernelParamStorage, G: IntoKernelParamStorage> LaunchAsync<(A, B, C, D, E, F, G)> for CudaFunction

unsafe fn launch_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D, E, F, G), ) -> Result<(), DriverError>

Launch within an already admitted memory operation, retaining its capture pin.

unsafe fn launch_cooperative_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D, E, F, G), ) -> Result<(), DriverError>

Launch cooperatively within an already admitted memory operation.

unsafe fn launch( self, cfg: LaunchConfig, params: (A, B, C, D, E, F, G), ) -> Result<(), DriverError>

Launch a kernel on the function’s default stream.

unsafe fn launch_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D, E, F, G), ) -> Result<(), DriverError>

Launch a kernel on an explicit CUDA stream.

unsafe fn launch_cooperative( self, cfg: LaunchConfig, params: (A, B, C, D, E, F, G), ) -> Result<(), DriverError>

Launch a cooperative kernel.

unsafe fn launch_cooperative_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D, E, F, G), ) -> Result<(), DriverError>

Launch a cooperative kernel on an explicit CUDA stream.

impl<A: IntoKernelParamStorage, B: IntoKernelParamStorage, C: IntoKernelParamStorage, D: IntoKernelParamStorage, E: IntoKernelParamStorage, F: IntoKernelParamStorage, G: IntoKernelParamStorage, H: IntoKernelParamStorage> LaunchAsync<(A, B, C, D, E, F, G, H)> for CudaFunction

unsafe fn launch_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H), ) -> Result<(), DriverError>

Launch within an already admitted memory operation, retaining its capture pin.

unsafe fn launch_cooperative_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H), ) -> Result<(), DriverError>

Launch cooperatively within an already admitted memory operation.

unsafe fn launch( self, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H), ) -> Result<(), DriverError>

Launch a kernel on the function’s default stream.

unsafe fn launch_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H), ) -> Result<(), DriverError>

Launch a kernel on an explicit CUDA stream.

unsafe fn launch_cooperative( self, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H), ) -> Result<(), DriverError>

Launch a cooperative kernel.

unsafe fn launch_cooperative_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H), ) -> Result<(), DriverError>

Launch a cooperative kernel on an explicit CUDA stream.

impl<A: IntoKernelParamStorage, B: IntoKernelParamStorage, C: IntoKernelParamStorage, D: IntoKernelParamStorage, E: IntoKernelParamStorage, F: IntoKernelParamStorage, G: IntoKernelParamStorage, H: IntoKernelParamStorage, I: IntoKernelParamStorage> LaunchAsync<(A, B, C, D, E, F, G, H, I)> for CudaFunction

unsafe fn launch_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I), ) -> Result<(), DriverError>

Launch within an already admitted memory operation, retaining its capture pin.

unsafe fn launch_cooperative_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I), ) -> Result<(), DriverError>

Launch cooperatively within an already admitted memory operation.

unsafe fn launch( self, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I), ) -> Result<(), DriverError>

Launch a kernel on the function’s default stream.

unsafe fn launch_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I), ) -> Result<(), DriverError>

Launch a kernel on an explicit CUDA stream.

unsafe fn launch_cooperative( self, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I), ) -> Result<(), DriverError>

Launch a cooperative kernel.

unsafe fn launch_cooperative_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I), ) -> Result<(), DriverError>

Launch a cooperative kernel on an explicit CUDA stream.

impl<A: IntoKernelParamStorage, B: IntoKernelParamStorage, C: IntoKernelParamStorage, D: IntoKernelParamStorage, E: IntoKernelParamStorage, F: IntoKernelParamStorage, G: IntoKernelParamStorage, H: IntoKernelParamStorage, I: IntoKernelParamStorage, J: IntoKernelParamStorage> LaunchAsync<(A, B, C, D, E, F, G, H, I, J)> for CudaFunction

unsafe fn launch_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J), ) -> Result<(), DriverError>

Launch within an already admitted memory operation, retaining its capture pin.

unsafe fn launch_cooperative_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J), ) -> Result<(), DriverError>

Launch cooperatively within an already admitted memory operation.

unsafe fn launch( self, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J), ) -> Result<(), DriverError>

Launch a kernel on the function’s default stream.

unsafe fn launch_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J), ) -> Result<(), DriverError>

Launch a kernel on an explicit CUDA stream.

unsafe fn launch_cooperative( self, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J), ) -> Result<(), DriverError>

Launch a cooperative kernel.

unsafe fn launch_cooperative_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J), ) -> Result<(), DriverError>

Launch a cooperative kernel on an explicit CUDA stream.

impl<A: IntoKernelParamStorage, B: IntoKernelParamStorage, C: IntoKernelParamStorage, D: IntoKernelParamStorage, E: IntoKernelParamStorage, F: IntoKernelParamStorage, G: IntoKernelParamStorage, H: IntoKernelParamStorage, I: IntoKernelParamStorage, J: IntoKernelParamStorage, K: IntoKernelParamStorage> LaunchAsync<(A, B, C, D, E, F, G, H, I, J, K)> for CudaFunction

unsafe fn launch_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J, K), ) -> Result<(), DriverError>

Launch within an already admitted memory operation, retaining its capture pin.

unsafe fn launch_cooperative_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J, K), ) -> Result<(), DriverError>

Launch cooperatively within an already admitted memory operation.

unsafe fn launch( self, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J, K), ) -> Result<(), DriverError>

Launch a kernel on the function’s default stream.

unsafe fn launch_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J, K), ) -> Result<(), DriverError>

Launch a kernel on an explicit CUDA stream.

unsafe fn launch_cooperative( self, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J, K), ) -> Result<(), DriverError>

Launch a cooperative kernel.

unsafe fn launch_cooperative_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J, K), ) -> Result<(), DriverError>

Launch a cooperative kernel on an explicit CUDA stream.

impl<A: IntoKernelParamStorage, B: IntoKernelParamStorage, C: IntoKernelParamStorage, D: IntoKernelParamStorage, E: IntoKernelParamStorage, F: IntoKernelParamStorage, G: IntoKernelParamStorage, H: IntoKernelParamStorage, I: IntoKernelParamStorage, J: IntoKernelParamStorage, K: IntoKernelParamStorage, L: IntoKernelParamStorage> LaunchAsync<(A, B, C, D, E, F, G, H, I, J, K, L)> for CudaFunction

unsafe fn launch_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J, K, L), ) -> Result<(), DriverError>

Launch within an already admitted memory operation, retaining its capture pin.

unsafe fn launch_cooperative_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J, K, L), ) -> Result<(), DriverError>

Launch cooperatively within an already admitted memory operation.

unsafe fn launch( self, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J, K, L), ) -> Result<(), DriverError>

Launch a kernel on the function’s default stream.

unsafe fn launch_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J, K, L), ) -> Result<(), DriverError>

Launch a kernel on an explicit CUDA stream.

unsafe fn launch_cooperative( self, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J, K, L), ) -> Result<(), DriverError>

Launch a cooperative kernel.

unsafe fn launch_cooperative_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J, K, L), ) -> Result<(), DriverError>

Launch a cooperative kernel on an explicit CUDA stream.

impl<A: IntoKernelParamStorage, B: IntoKernelParamStorage, C: IntoKernelParamStorage, D: IntoKernelParamStorage, E: IntoKernelParamStorage, F: IntoKernelParamStorage, G: IntoKernelParamStorage, H: IntoKernelParamStorage, I: IntoKernelParamStorage, J: IntoKernelParamStorage, K: IntoKernelParamStorage, L: IntoKernelParamStorage, M: IntoKernelParamStorage> LaunchAsync<(A, B, C, D, E, F, G, H, I, J, K, L, M)> for CudaFunction

unsafe fn launch_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J, K, L, M), ) -> Result<(), DriverError>

Launch within an already admitted memory operation, retaining its capture pin.

unsafe fn launch_cooperative_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J, K, L, M), ) -> Result<(), DriverError>

Launch cooperatively within an already admitted memory operation.

unsafe fn launch( self, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J, K, L, M), ) -> Result<(), DriverError>

Launch a kernel on the function’s default stream.

unsafe fn launch_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J, K, L, M), ) -> Result<(), DriverError>

Launch a kernel on an explicit CUDA stream.

unsafe fn launch_cooperative( self, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J, K, L, M), ) -> Result<(), DriverError>

Launch a cooperative kernel.

unsafe fn launch_cooperative_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A, B, C, D, E, F, G, H, I, J, K, L, M), ) -> Result<(), DriverError>

Launch a cooperative kernel on an explicit CUDA stream.

impl<A: IntoKernelParamStorage> LaunchAsync<(A,)> for CudaFunction

unsafe fn launch_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A,), ) -> Result<(), DriverError>

Launch within an already admitted memory operation, retaining its capture pin.

unsafe fn launch_cooperative_in( self, enqueue: &CudaEnqueue<'_>, cfg: LaunchConfig, params: (A,), ) -> Result<(), DriverError>

Launch cooperatively within an already admitted memory operation.

unsafe fn launch( self, cfg: LaunchConfig, params: (A,), ) -> Result<(), DriverError>

Launch a kernel on the function’s default stream.

unsafe fn launch_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A,), ) -> Result<(), DriverError>

Launch a kernel on an explicit CUDA stream.

unsafe fn launch_cooperative( self, cfg: LaunchConfig, params: (A,), ) -> Result<(), DriverError>

Launch a cooperative kernel.

unsafe fn launch_cooperative_on_stream( self, stream: &CudaStream, cfg: LaunchConfig, params: (A,), ) -> Result<(), DriverError>

Launch a cooperative kernel on an explicit CUDA stream.