torsh-backend 0.1.2

Backend abstraction layer for ToRSh
Documentation 
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

//! Error handling for CPU backend using unified TorshError

pub use crate::error::{BackendError, BackendResult as CpuResult, ErrorContext, ErrorContextExt};
pub use torsh_core::error::TorshError;

/// Helper functions for CPU-specific error creation
pub mod cpu_errors {
    use super::*;

    /// Create a memory allocation error with CPU backend context
    pub fn memory_allocation_error(message: impl Into<String>) -> TorshError {
        let context = ErrorContext::new("memory_allocation")
            .with_backend("CPU")
            .with_details(message.into());
        TorshError::AllocationError(context.format())
    }

    /// Create a buffer error with CPU backend context
    pub fn buffer_error(message: impl Into<String>) -> TorshError {
        let context = ErrorContext::new("buffer_operation")
            .with_backend("CPU")
            .with_details(message.into());
        TorshError::BackendError(context.format())
    }

    /// Create a kernel execution error with CPU backend context
    pub fn kernel_execution_error(message: impl Into<String>) -> TorshError {
        let context = ErrorContext::new("kernel_execution")
            .with_backend("CPU")
            .with_details(message.into());
        TorshError::ComputeError(context.format())
    }

    /// Create a thread pool error with CPU backend context
    pub fn thread_pool_error(message: impl Into<String>) -> TorshError {
        let context = ErrorContext::new("thread_pool")
            .with_backend("CPU")
            .with_details(message.into());
        TorshError::BackendError(context.format())
    }

    /// Create a SIMD operation error with CPU backend context
    pub fn simd_error(message: impl Into<String>) -> TorshError {
        let context = ErrorContext::new("simd_operation")
            .with_backend("CPU")
            .with_details(message.into());
        TorshError::ComputeError(context.format())
    }

    /// Create an optimization error with CPU backend context
    pub fn optimization_error(message: impl Into<String>) -> TorshError {
        let context = ErrorContext::new("optimization")
            .with_backend("CPU")
            .with_details(message.into());
        TorshError::BackendError(context.format())
    }

    /// Create an invalid parameter error with CPU backend context
    pub fn invalid_parameter_error(message: impl Into<String>) -> TorshError {
        let context = ErrorContext::new("parameter_validation")
            .with_backend("CPU")
            .with_details(message.into());
        TorshError::InvalidArgument(context.format())
    }

    /// Create a parsing error with CPU backend context
    pub fn parsing_error(message: impl Into<String>) -> TorshError {
        let context = ErrorContext::new("parsing")
            .with_backend("CPU")
            .with_details(message.into());
        TorshError::BackendError(context.format())
    }

    /// Create a serialization error with CPU backend context
    pub fn serialization_error(message: impl Into<String>) -> TorshError {
        let context = ErrorContext::new("serialization")
            .with_backend("CPU")
            .with_details(message.into());
        TorshError::BackendError(context.format())
    }

    /// Create an IO error with CPU backend context (string message version)
    pub fn io_error(message: impl Into<String>) -> TorshError {
        let context = ErrorContext::new("io_operation")
            .with_backend("CPU")
            .with_details(message.into());
        TorshError::BackendError(context.format())
    }

    /// Convert IO errors to TorshError with CPU backend context
    pub fn io_error_from_std(err: std::io::Error, operation: &str) -> TorshError {
        let context = ErrorContext::new(operation)
            .with_backend("CPU")
            .with_details(err.to_string());
        TorshError::BackendError(context.format())
    }
}