optirs-tpu 0.3.1

OptiRS TPU coordination and pod management
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

// Deadlock Prevention Module

use crate::pod_coordination::types::*;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct PreventionTechnique;

pub type WoundWaitStrategy = PreventionTechnique;

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub enum PreventionPolicy {
    #[default]
    WoundWait,
    WaitDie,
    NoWait,
}

#[derive(Debug, Clone, Default)]
pub struct DeadlockPreventer {
    pub policy: PreventionPolicy,
    pub technique: PreventionTechnique,
}

// Additional prevention types
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub enum AllocationPolicy {
    #[default]
    Conservative,
    Optimistic,
    Adaptive,
}

#[derive(Debug, Clone, Default)]
pub struct AvoidanceStrategy {
    pub enabled: bool,
}

#[derive(Debug, Clone, Default)]
pub struct BankersAlgorithmConfig {
    pub max_resources: usize,
}

#[derive(Debug, Clone, Default)]
pub struct CircularWaitPrevention {
    pub enabled: bool,
}

#[derive(Debug, Clone, Default)]
pub struct ConservativeStrategy {
    pub enabled: bool,
}

#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
pub struct DeadlockPrevention {
    pub policy: PreventionPolicy,
}

#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
pub struct DeadlockPreventionSystem {
    pub prevention: DeadlockPrevention,
}

impl DeadlockPreventionSystem {
    /// Create a new deadlock prevention system
    pub fn new() -> Self {
        Self::default()
    }
}

#[derive(Debug, Clone, Default)]
pub struct HoldAndWaitPrevention {
    pub enabled: bool,
}

#[derive(Debug, Clone, Default)]
pub struct MutualExclusionPrevention {
    pub enabled: bool,
}

#[derive(Debug, Clone, Default)]
pub struct NoPreemptionPrevention {
    pub enabled: bool,
}

#[derive(Debug, Clone, Default)]
pub struct OptimisticStrategy {
    pub enabled: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub enum OrderingStrategy {
    #[default]
    Total,
    Partial,
    None,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub enum PreemptionPolicy {
    Allow,
    Deny,
    #[default]
    Conditional,
}

#[derive(Debug, Clone, Default)]
pub struct PreemptionStrategy {
    pub policy: PreemptionPolicy,
}

#[derive(Debug, Clone, Default)]
pub struct PreventionStatistics {
    pub prevented_count: u64,
}

#[derive(Debug, Clone, Default)]
pub struct ResourceOrdering {
    pub strategy: OrderingStrategy,
}

#[derive(Debug, Clone, Default)]
pub struct TimeoutStrategy {
    pub timeout_ms: u64,
}

#[derive(Debug, Clone, Default)]
pub struct ValidationStatistics {
    pub validations_performed: u64,
}