era_cudart 0.1.0

CUDA bindings for ZKsync
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

use std::mem::MaybeUninit;

use cudart_sys::{
    cudaOccupancyAvailableDynamicSMemPerBlock, cudaOccupancyMaxActiveBlocksPerMultiprocessor,
    cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags,
};

use crate::execution::KernelFunction;
use crate::result::{CudaResult, CudaResultWrap};

pub fn available_dynamic_smem_per_block(
    kernel_function: &impl KernelFunction,
    num_blocks: i32,
    block_size: i32,
) -> CudaResult<usize> {
    let mut result = MaybeUninit::<usize>::uninit();
    unsafe {
        cudaOccupancyAvailableDynamicSMemPerBlock(
            result.as_mut_ptr(),
            kernel_function.as_ptr(),
            num_blocks,
            block_size,
        )
        .wrap_maybe_uninit(result)
    }
}

pub fn max_active_blocks_per_multiprocessor(
    kernel_function: &impl KernelFunction,
    block_size: i32,
    dynamic_smem_size: usize,
) -> CudaResult<i32> {
    let mut result = MaybeUninit::<i32>::uninit();
    unsafe {
        cudaOccupancyMaxActiveBlocksPerMultiprocessor(
            result.as_mut_ptr(),
            kernel_function.as_ptr(),
            block_size,
            dynamic_smem_size,
        )
        .wrap_maybe_uninit(result)
    }
}

pub fn max_active_blocks_per_multiprocessor_with_flags(
    kernel_function: &impl KernelFunction,
    block_size: i32,
    dynamic_smem_size: usize,
    flags: u32,
) -> CudaResult<i32> {
    let mut result = MaybeUninit::<i32>::uninit();
    unsafe {
        cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(
            result.as_mut_ptr(),
            kernel_function.as_ptr(),
            block_size,
            dynamic_smem_size,
            flags,
        )
        .wrap_maybe_uninit(result)
    }
}