1use super::Ctx;
4use super::backdrop::Backdrop;
5use super::ops::{CgroupDef, CpusetSpec, HoldSpec, Op, Step, execute_scenario, execute_steps};
6use crate::assert::AssertResult;
7use crate::workload::*;
8use anyhow::Result;
9use std::time::Duration;
10
11fn cgroup_cpuset_apply_midrun_backdrop() -> Backdrop {
12 Backdrop::new()
13 .push_cgroup(CgroupDef::named("cg_0"))
14 .push_cgroup(CgroupDef::named("cg_1"))
15}
16
17fn cgroup_cpuset_apply_midrun_steps(ctx: &Ctx) -> Vec<Step> {
18 vec![
19 Step::new(vec![], ctx.settled_hold(0.5)),
20 Step::new(
21 vec![
22 Op::set_cpuset("cg_0", CpusetSpec::disjoint(0, 2)),
23 Op::set_cpuset("cg_1", CpusetSpec::disjoint(1, 2)),
24 ],
25 HoldSpec::frac(0.5),
26 ),
27 ]
28}
29
30pub fn custom_cgroup_cpuset_apply_midrun(ctx: &Ctx) -> Result<AssertResult> {
32 execute_scenario(
33 ctx,
34 cgroup_cpuset_apply_midrun_backdrop(),
35 cgroup_cpuset_apply_midrun_steps(ctx),
36 )
37}
38
39pub fn custom_cgroup_cpuset_clear_midrun(ctx: &Ctx) -> Result<AssertResult> {
41 let backdrop = Backdrop::new()
42 .push_cgroup(CgroupDef::named("cg_0").cpuset(CpusetSpec::disjoint(0, 2)))
43 .push_cgroup(CgroupDef::named("cg_1").cpuset(CpusetSpec::disjoint(1, 2)));
44
45 let steps = vec![
46 Step::new(vec![], ctx.settled_hold(0.5)),
47 Step::new(
48 vec![Op::clear_cpuset("cg_0"), Op::clear_cpuset("cg_1")],
49 HoldSpec::frac(0.5),
50 ),
51 ];
52
53 execute_scenario(ctx, backdrop, steps)
54}
55
56fn cgroup_cpuset_resize_backdrop() -> Backdrop {
57 Backdrop::new()
58 .push_cgroup(CgroupDef::named("cg_0").cpuset(CpusetSpec::range(0.0, 0.5)))
59 .push_cgroup(CgroupDef::named("cg_1").cpuset(CpusetSpec::range(0.5, 1.0)))
60}
61
62fn cgroup_cpuset_resize_steps(ctx: &Ctx) -> Vec<Step> {
63 vec![
64 Step::new(vec![], ctx.settled_hold(1.0 / 3.0)),
65 Step::new(
66 vec![
67 Op::set_cpuset("cg_0", CpusetSpec::range(0.0, 0.25)),
68 Op::set_cpuset("cg_1", CpusetSpec::range(0.25, 1.0)),
69 ],
70 HoldSpec::frac(1.0 / 3.0),
71 ),
72 Step::new(
73 vec![
74 Op::set_cpuset("cg_0", CpusetSpec::range(0.0, 0.75)),
75 Op::set_cpuset("cg_1", CpusetSpec::range(0.75, 1.0)),
76 ],
77 HoldSpec::frac(1.0 / 3.0),
78 ),
79 ]
80}
81
82pub fn custom_cgroup_cpuset_resize(ctx: &Ctx) -> Result<AssertResult> {
84 if ctx.topo.all_cpus().len() < 4 {
85 return Ok(AssertResult::skip("need >=4 CPUs"));
86 }
87 execute_scenario(
88 ctx,
89 cgroup_cpuset_resize_backdrop(),
90 cgroup_cpuset_resize_steps(ctx),
91 )
92}
93
94pub fn custom_cgroup_cpuset_swap_disjoint(ctx: &Ctx) -> Result<AssertResult> {
96 if ctx.topo.all_cpus().len() < 8 {
97 return Ok(AssertResult::skip("need >=8 CPUs"));
98 }
99
100 let backdrop = Backdrop::new()
101 .push_cgroup(CgroupDef::named("cg_0").cpuset(CpusetSpec::range(0.0, 0.5)))
102 .push_cgroup(CgroupDef::named("cg_1").cpuset(CpusetSpec::range(0.5, 1.0)));
103
104 let steps = vec![
105 Step::new(vec![], ctx.settled_hold(1.0 / 3.0)),
106 Step::new(
107 vec![
108 Op::set_cpuset("cg_0", CpusetSpec::range(0.5, 1.0)),
109 Op::set_cpuset("cg_1", CpusetSpec::range(0.0, 0.5)),
110 ],
111 HoldSpec::frac(1.0 / 3.0),
112 ),
113 Step::new(
114 vec![
115 Op::set_cpuset("cg_0", CpusetSpec::range(0.0, 0.5)),
116 Op::set_cpuset("cg_1", CpusetSpec::range(0.5, 1.0)),
117 ],
118 HoldSpec::frac(1.0 / 3.0),
119 ),
120 ];
121
122 execute_scenario(ctx, backdrop, steps)
123}
124
125pub fn custom_cgroup_cpuset_workload_imbalance(ctx: &Ctx) -> Result<AssertResult> {
127 let mid = ctx.topo.usable_cpus().len() / 2;
128
129 let steps = vec![Step::with_defs(
130 vec![
131 CgroupDef::named("cg_0")
132 .cpuset(CpusetSpec::disjoint(0, 2))
133 .workers(mid * 2),
134 CgroupDef::named("cg_1")
135 .cpuset(CpusetSpec::disjoint(1, 2))
136 .work_type(WorkType::bursty(
137 Duration::from_millis(50),
138 Duration::from_millis(100),
139 )),
140 ],
141 ctx.settled_hold(1.0),
142 )];
143
144 execute_steps(ctx, steps)
145}
146
147pub fn custom_cgroup_cpuset_change_imbalance(ctx: &Ctx) -> Result<AssertResult> {
149 if ctx.topo.all_cpus().len() < 4 {
150 return Ok(AssertResult::skip("need >=4 CPUs"));
151 }
152
153 let all = ctx.topo.all_cpus();
154 let last = all.len() - 1;
155 let mid = last / 2;
156
157 let narrow = CpusetSpec::exact([all[mid]]);
158
159 let backdrop = Backdrop::new()
160 .push_cgroup(
161 CgroupDef::named("cg_0")
162 .cpuset(CpusetSpec::range(0.0, 0.5))
163 .workers(mid * 2),
164 )
165 .push_cgroup(
166 CgroupDef::named("cg_1")
167 .cpuset(CpusetSpec::range(0.5, 1.0))
168 .workers(2)
169 .work_type(WorkType::bursty(
170 Duration::from_millis(30),
171 Duration::from_millis(100),
172 )),
173 );
174
175 let steps = vec![
176 Step::new(vec![], ctx.settled_hold(1.0 / 3.0)),
177 Step::new(
178 vec![Op::set_cpuset("cg_1", narrow)],
179 HoldSpec::frac(1.0 / 3.0),
180 ),
181 Step::new(
182 vec![Op::set_cpuset("cg_1", CpusetSpec::range(0.5, 1.0))],
183 HoldSpec::frac(1.0 / 3.0),
184 ),
185 ];
186
187 execute_scenario(ctx, backdrop, steps)
188}
189
190pub fn custom_cgroup_cpuset_load_shift(ctx: &Ctx) -> Result<AssertResult> {
192 let backdrop = Backdrop::new()
193 .push_cgroup(
194 CgroupDef::named("cg_0")
195 .cpuset(CpusetSpec::disjoint(0, 2))
196 .workers(16),
197 )
198 .push_cgroup(
199 CgroupDef::named("cg_1")
200 .cpuset(CpusetSpec::disjoint(1, 2))
201 .workers(1)
202 .work_type(WorkType::YieldHeavy),
203 );
204
205 let steps = vec![
206 Step::new(vec![], ctx.settled_hold(0.5)),
207 Step::new(
211 vec![Op::spawn_workers("cg_1", WorkSpec::default().workers(16))],
212 HoldSpec::frac(0.5),
213 ),
214 ];
215
216 execute_scenario(ctx, backdrop, steps)
217}
218
219#[cfg(test)]
220mod tests {
221 use super::super::ops::Setup;
222 use super::*;
223 use crate::cgroup::CgroupManager;
224 use crate::topology::TestTopology;
225 use std::time::Duration;
226
227 fn ctx_for_test<'a>(cgroups: &'a CgroupManager, topo: &'a TestTopology) -> Ctx<'a> {
228 Ctx {
229 cgroups,
230 topo,
231 duration: Duration::from_secs(6),
232 workers_per_cgroup: 2,
233 sched_pid: Some(1),
234 settle: Duration::from_millis(100),
235 work_type_override: None,
236 assert: crate::assert::Assert::default_checks(),
237 wait_for_map_write: false,
238 current_step: std::sync::Arc::new(std::sync::atomic::AtomicU16::new(0)),
239 entry_name: None,
240 variant_hash: 0,
241 }
242 }
243
244 #[test]
245 fn apply_midrun_backdrop_declares_two_cgroups() {
246 let backdrop = cgroup_cpuset_apply_midrun_backdrop();
247 assert_eq!(
248 backdrop.cgroups.len(),
249 2,
250 "Backdrop declares cg_0 and cg_1 as persistent"
251 );
252 assert_eq!(backdrop.cgroups[0].name.as_ref(), "cg_0");
253 assert_eq!(backdrop.cgroups[1].name.as_ref(), "cg_1");
254 }
255
256 #[test]
257 fn apply_midrun_builds_two_phase_steps() {
258 let cgroups = CgroupManager::new("/nonexistent");
259 let topo = TestTopology::from_vm_topology(&crate::vmm::topology::Topology::new(1, 1, 4, 1));
260 let ctx = ctx_for_test(&cgroups, &topo);
261
262 let steps = cgroup_cpuset_apply_midrun_steps(&ctx);
263 assert_eq!(steps.len(), 2, "settle + apply phases");
264
265 assert!(
266 matches!(&steps[0].setup, Setup::Defs(defs) if defs.is_empty()),
267 "phase 1 has no step-local CgroupDefs (cgroups live in the Backdrop)",
268 );
269 assert!(steps[0].ops.is_empty(), "phase 1 is a pure settle — no ops");
270
271 assert!(matches!(steps[0].hold, HoldSpec::Fixed(_)));
272 let phase2_ops = &steps[1].ops;
273 assert_eq!(phase2_ops.len(), 2, "set_cpuset once per cgroup");
274 for op in phase2_ops {
275 assert!(matches!(op, Op::SetCpuset { .. }));
276 }
277 assert!(matches!(steps[1].hold, HoldSpec::Frac(f) if (f - 0.5).abs() < f64::EPSILON));
278 }
279
280 #[test]
281 fn resize_backdrop_declares_two_cgroups_with_cpusets() {
282 let backdrop = cgroup_cpuset_resize_backdrop();
283 assert_eq!(backdrop.cgroups.len(), 2);
284 assert!(backdrop.cgroups[0].cpuset.is_some());
285 assert!(backdrop.cgroups[1].cpuset.is_some());
286 }
287
288 #[test]
289 fn resize_builds_three_phase_range_progression() {
290 let cgroups = CgroupManager::new("/nonexistent");
291 let topo = TestTopology::from_vm_topology(&crate::vmm::topology::Topology::new(1, 1, 4, 1));
292 let ctx = ctx_for_test(&cgroups, &topo);
293
294 let steps = cgroup_cpuset_resize_steps(&ctx);
295 assert_eq!(steps.len(), 3);
296 assert!(
297 matches!(&steps[0].setup, Setup::Defs(defs) if defs.is_empty()),
298 "phase 1 is a settle step — cgroups live in the Backdrop",
299 );
300 assert!(steps[0].ops.is_empty(), "phase 1 has no ops");
301 for step in &steps[1..] {
303 assert_eq!(step.ops.len(), 2);
304 for op in &step.ops {
305 assert!(matches!(op, Op::SetCpuset { .. }));
306 }
307 }
308 }
309}