clow 0.1.1

Lower-Level wrapper around Cudarc pointer types
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

use std::sync::atomic::{AtomicU32, Ordering};
use cudarc::driver::{sys, DriverError};
use log::warn;

const ERR_STACK_SIZE: usize = 16;

/// Structure to capture errors in environments in which error capturing is not possible;
/// for example in manual drops.
#[derive(Debug)]
pub struct ErrorSink {
    err_state: [AtomicU32; ERR_STACK_SIZE],
    err_stack: AtomicU32,
}

impl ErrorSink {
    pub fn new() -> Self {
        Self {
            err_state: [const { AtomicU32::new(0) }; ERR_STACK_SIZE],
            err_stack: AtomicU32::new(0),
        }
    }

    pub fn record_err<T>(&self, result: Result<T, DriverError>) {
        if let Err(err) = result {
            let idx = self.err_stack.fetch_add(1, Ordering::Relaxed) as usize;
            if idx < ERR_STACK_SIZE {
                self.err_state[idx].store(err.0 as u32, Ordering::Relaxed)
            }
        }
    }

    /// Check the error stack for any errors.
    /// The error stack is traversed last-in-last-out, so the most recent error is returned first.
    /// Each call of this method can take off one error in the stack.
    pub fn check_err(&self) -> Result<(), DriverError> {
        if let Ok(mut idx) = self.err_stack.fetch_update(
            Ordering::Relaxed,
            Ordering::Relaxed,
            |old| if old > 0 {
                Some(u32::min(old, ERR_STACK_SIZE as u32) - 1)
            } else {
                None
            },
        ) {
            if idx >= ERR_STACK_SIZE as u32 {
                // there was an overflow in the error stack
                warn!("error stack overflow detected");
                idx = ERR_STACK_SIZE as u32 - 1;
            }
            let err_state = self.err_state[idx as usize].swap(0, Ordering::Relaxed);
            Err(DriverError(unsafe {
                std::mem::transmute::<u32, sys::cudaError_enum>(err_state)
            }))
        } else {
            Ok(())
        }
    }
}