Skip to main content

inference_lab/scheduler/
policy.rs

1use std::str::FromStr;
2
3/// Scheduling policy for request ordering
4#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5pub enum SchedulingPolicy {
6    /// First-Come-First-Served: requests served in arrival order
7    FCFS,
8    /// Priority-based: requests ordered by priority value (lower = higher priority)
9    Priority,
10
11    // Input-based policies (prompt length)
12    /// Shortest Input First: prioritize requests with smallest input length
13    SIF,
14    /// Longest Input First: prioritize requests with largest input length
15    LIF,
16
17    // Output-based policies (generation length)
18    /// Shortest Output First: prioritize requests with smallest output length
19    SOF,
20    /// Longest Output First: prioritize requests with largest output length
21    LOF,
22
23    // Total-based policies (input + output)
24    /// Shortest Total First: prioritize requests with smallest total length
25    STF,
26    /// Longest Total First: prioritize requests with largest total length
27    LTF,
28}
29
30impl FromStr for SchedulingPolicy {
31    type Err = String;
32
33    fn from_str(s: &str) -> Result<Self, Self::Err> {
34        match s.to_lowercase().as_str() {
35            "fcfs" => Ok(SchedulingPolicy::FCFS),
36            "priority" => Ok(SchedulingPolicy::Priority),
37            "sif" => Ok(SchedulingPolicy::SIF),
38            "lif" => Ok(SchedulingPolicy::LIF),
39            "sof" => Ok(SchedulingPolicy::SOF),
40            "lof" => Ok(SchedulingPolicy::LOF),
41            "stf" => Ok(SchedulingPolicy::STF),
42            "ltf" => Ok(SchedulingPolicy::LTF),
43            // Backward compatibility
44            "sjf" => Ok(SchedulingPolicy::SOF),
45            _ => Err(format!("Unknown scheduling policy: {}", s)),
46        }
47    }
48}
49
50#[cfg(test)]
51mod tests {
52    use super::*;
53
54    #[test]
55    fn test_policy_from_str() {
56        assert_eq!(
57            "fcfs".parse::<SchedulingPolicy>().unwrap(),
58            SchedulingPolicy::FCFS
59        );
60        assert_eq!(
61            "FCFS".parse::<SchedulingPolicy>().unwrap(),
62            SchedulingPolicy::FCFS
63        );
64        assert_eq!(
65            "priority".parse::<SchedulingPolicy>().unwrap(),
66            SchedulingPolicy::Priority
67        );
68        assert_eq!(
69            "sif".parse::<SchedulingPolicy>().unwrap(),
70            SchedulingPolicy::SIF
71        );
72        assert_eq!(
73            "SIF".parse::<SchedulingPolicy>().unwrap(),
74            SchedulingPolicy::SIF
75        );
76        assert_eq!(
77            "lif".parse::<SchedulingPolicy>().unwrap(),
78            SchedulingPolicy::LIF
79        );
80        assert_eq!(
81            "LIF".parse::<SchedulingPolicy>().unwrap(),
82            SchedulingPolicy::LIF
83        );
84        assert_eq!(
85            "sof".parse::<SchedulingPolicy>().unwrap(),
86            SchedulingPolicy::SOF
87        );
88        assert_eq!(
89            "SOF".parse::<SchedulingPolicy>().unwrap(),
90            SchedulingPolicy::SOF
91        );
92        assert_eq!(
93            "lof".parse::<SchedulingPolicy>().unwrap(),
94            SchedulingPolicy::LOF
95        );
96        assert_eq!(
97            "LOF".parse::<SchedulingPolicy>().unwrap(),
98            SchedulingPolicy::LOF
99        );
100        assert_eq!(
101            "stf".parse::<SchedulingPolicy>().unwrap(),
102            SchedulingPolicy::STF
103        );
104        assert_eq!(
105            "STF".parse::<SchedulingPolicy>().unwrap(),
106            SchedulingPolicy::STF
107        );
108        assert_eq!(
109            "ltf".parse::<SchedulingPolicy>().unwrap(),
110            SchedulingPolicy::LTF
111        );
112        assert_eq!(
113            "LTF".parse::<SchedulingPolicy>().unwrap(),
114            SchedulingPolicy::LTF
115        );
116        // Test backward compatibility
117        assert_eq!(
118            "sjf".parse::<SchedulingPolicy>().unwrap(),
119            SchedulingPolicy::SOF
120        );
121        assert_eq!(
122            "SJF".parse::<SchedulingPolicy>().unwrap(),
123            SchedulingPolicy::SOF
124        );
125        assert!("unknown".parse::<SchedulingPolicy>().is_err());
126    }
127}