deloxide 1.0.0

Deloxide scrubs your threads clean by detecting deadlocks in real time—keeping your system smooth, safe, and corrosion-free. 🦀🧼🔒
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use std::ffi::c_double;
use std::os::raw::{c_int, c_ulong};

#[cfg(feature = "stress-test")]
use crate::core::StressConfig;
#[cfg(feature = "stress-test")]
use crate::ffi::{INITIALIZED, STRESS_CONFIG, STRESS_MODE};
#[cfg(feature = "stress-test")]
use std::sync::atomic::Ordering;

/// Enable random preemption stress testing (only with "stress-test" feature)
///
/// This function enables stress testing with random preemption before lock
/// acquisitions to increase deadlock probability.
///
/// # Arguments
/// * `probability` - Probability of preemption (0.0-1.0)
/// * `min_delay_us` - Minimum delay duration in microseconds
/// * `max_delay_us` - Maximum delay duration in microseconds
///
/// # Returns
/// * `0` on success
/// * `1` if already initialized
/// * `-1` if stress-test feature is not enabled
///
/// # Safety
/// This function writes to mutable static variables and should be called before initialization.
#[unsafe(no_mangle)]
#[allow(unused_variables)]
pub unsafe extern "C" fn deloxide_enable_random_stress(
    probability: c_double,
    min_delay_us: c_ulong,
    max_delay_us: c_ulong,
) -> c_int {
    #[cfg(feature = "stress-test")]
    {
        if INITIALIZED.load(Ordering::SeqCst) {
            return 1; // Already initialized
        }

        STRESS_MODE.store(1, Ordering::SeqCst);

        unsafe {
            STRESS_CONFIG = Some(crate::core::stress::StressConfig {
                preemption_probability: probability,
                min_delay_us,
                max_delay_us,
                preempt_after_release: true,
            });
        }

        0
    }

    #[cfg(not(feature = "stress-test"))]
    {
        // Return error if stress-test feature is not enabled
        -1
    }
}

/// Enable component-based stress testing (only with "stress-test" feature)
///
/// This function enables stress testing with targeted delays based on lock
/// acquisition patterns to increase deadlock probability.
///
/// # Arguments
/// * `min_delay_us` - Minimum delay duration in microseconds
/// * `max_delay_us` - Maximum delay duration in microseconds
///
/// # Returns
/// * `0` on success
/// * `1` if already initialized
/// * `-1` if stress-test feature is not enabled
///
/// # Safety
/// This function writes to mutable static variables and should be called before initialization.
#[unsafe(no_mangle)]
#[allow(unused_variables)]
pub unsafe extern "C" fn deloxide_enable_component_stress(
    min_delay_us: c_ulong,
    max_delay_us: c_ulong,
) -> c_int {
    #[cfg(feature = "stress-test")]
    {
        if INITIALIZED.load(Ordering::SeqCst) {
            return 1; // Already initialized
        }

        STRESS_MODE.store(2, Ordering::SeqCst);

        unsafe {
            STRESS_CONFIG = Some(StressConfig {
                preemption_probability: 0.8, // High probability for component-based mode
                min_delay_us,
                max_delay_us,
                preempt_after_release: true,
            });
        }

        0
    }

    #[cfg(not(feature = "stress-test"))]
    {
        // Return error if stress-test feature is not enabled
        -1
    }
}

/// Disable stress testing (only with "stress-test" feature)
///
/// This function disables any previously enabled stress testing mode.
///
/// # Returns
/// * `0` on success
/// * `1` if already initialized
/// * `-1` if stress-test feature is not enabled
///
/// # Safety
/// This function writes to mutable static variables and should be called before initialization.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn deloxide_disable_stress() -> c_int {
    #[cfg(feature = "stress-test")]
    {
        if INITIALIZED.load(Ordering::SeqCst) {
            return 1; // Already initialized
        }

        STRESS_MODE.store(0, Ordering::SeqCst);

        unsafe {
            STRESS_CONFIG = None;
        }

        0
    }

    #[cfg(not(feature = "stress-test"))]
    {
        // Return error if stress-test feature is not enabled
        -1
    }
}