Merge pull request #2435 from yaakov-stein/ystein/scx_chaos_seperate_kprobe_delays

scx_chaos: separate kprobe delays

Author: yaakov-stein

scheds/rust/scx_chaos/src/bpf/intf.h

@@ -30,6 +30,7 @@ enum chaos_trait_kind {
 	CHAOS_TRAIT_RANDOM_DELAYS,
 	CHAOS_TRAIT_CPU_FREQ,
 	CHAOS_TRAIT_DEGRADATION,
+	CHAOS_TRAIT_KPROBE_RANDOM_DELAYS,
 	CHAOS_TRAIT_MAX,
 };
 
@@ -49,6 +50,7 @@ enum chaos_stat_idx {
 	CHAOS_STAT_TRAIT_DEGRADATION,
 	CHAOS_STAT_CHAOS_EXCLUDED,
 	CHAOS_STAT_CHAOS_SKIPPED,
+	CHAOS_STAT_KPROBE_RANDOM_DELAYS,
 	CHAOS_STAT_TIMER_KICKS,
 	CHAOS_NR_STATS,
 };

scheds/rust/scx_chaos/src/bpf/main.bpf.c

@@ -51,6 +51,8 @@ const volatile u32 degradation_freq_frac32 = 1;
 const volatile u64 degradation_frac7 = 0;
 
 const volatile u32 kprobe_delays_freq_frac32 = 1;
+const volatile u64 kprobe_delays_min_ns = 1;
+const volatile u64 kprobe_delays_max_ns = 2;
 
 #define MIN(x, y) ((x) < (y) ? (x) : (y))
 #define MAX(x, y) ((x) > (y) ? (x) : (y))
@@ -251,17 +253,16 @@ static __always_inline s32 calculate_chaos_match(struct task_struct *p)
 }
 
 __weak s32 enqueue_random_delay(struct task_struct *p __arg_trusted, u64 enq_flags,
-				struct chaos_task_ctx *taskc __arg_nonnull)
+				struct chaos_task_ctx *taskc __arg_nonnull, u64 min_ns, u64 max_ns)
 {
 	u64 rand64 = ((u64)bpf_get_prandom_u32() << 32) | bpf_get_prandom_u32();
 
-	u64 vtime = bpf_ktime_get_ns() + random_delays_min_ns;
-	if (random_delays_min_ns != random_delays_max_ns) {
-		vtime += rand64 % (random_delays_max_ns - random_delays_min_ns);
+	u64 vtime = bpf_ktime_get_ns() + min_ns;
+	if (min_ns != max_ns) {
+		vtime += rand64 % (max_ns - min_ns);
 	}
 
 	scx_bpf_dsq_insert_vtime(p, get_cpu_delay_dsq(-1), 0, vtime, enq_flags);
-	chaos_stat_inc(CHAOS_STAT_TRAIT_RANDOM_DELAYS);
 
 	return true;
 }
@@ -272,10 +273,22 @@ __weak s32 enqueue_chaotic(struct task_struct *p __arg_trusted, u64 enq_flags,
 	bool out;
 
 	switch (taskc->next_trait) {
+	case CHAOS_TRAIT_KPROBE_RANDOM_DELAYS:
+		out = enqueue_random_delay(p,
+					   enq_flags,
+					   taskc,
+					   kprobe_delays_min_ns,
+					   kprobe_delays_max_ns);
+		chaos_stat_inc(CHAOS_STAT_KPROBE_RANDOM_DELAYS);
+		break;
 	case CHAOS_TRAIT_RANDOM_DELAYS:
-		out = enqueue_random_delay(p, enq_flags, taskc);
+		out = enqueue_random_delay(p,
+					   enq_flags,
+					   taskc,
+					   random_delays_min_ns,
+					   random_delays_max_ns);
+		chaos_stat_inc(CHAOS_STAT_TRAIT_RANDOM_DELAYS);
 		break;
-
 	case CHAOS_TRAIT_NONE:
 		chaos_stat_inc(CHAOS_STAT_CHAOS_SKIPPED);
 		out = false;
@@ -503,7 +516,8 @@ void BPF_STRUCT_OPS(chaos_enqueue, struct task_struct *p __arg_trusted, u64 enq_
 	if (promise.kind == P2DQ_ENQUEUE_PROMISE_FAILED)
 		goto cleanup;
 
-	if (taskc->next_trait == CHAOS_TRAIT_RANDOM_DELAYS &&
+	if ((taskc->next_trait == CHAOS_TRAIT_RANDOM_DELAYS ||
+		taskc->next_trait == CHAOS_TRAIT_KPROBE_RANDOM_DELAYS) &&
 	    enqueue_chaotic(p, enq_flags, taskc))
 		goto cleanup;
 
@@ -592,7 +606,7 @@ void BPF_STRUCT_OPS(chaos_tick, struct task_struct *p)
 	if (!(taskc = lookup_create_chaos_task_ctx(p)))
 		return;
 
-	if (taskc->pending_trait == CHAOS_TRAIT_RANDOM_DELAYS)
+	if (taskc->pending_trait == CHAOS_TRAIT_KPROBE_RANDOM_DELAYS)
 		p->scx.slice = 0;
 }
 
@@ -643,7 +657,7 @@ int generic(struct pt_regs *ctx)
 
 	u32 roll = bpf_get_prandom_u32();
 	if (roll <= kprobe_delays_freq_frac32) {
-		taskc->pending_trait = CHAOS_TRAIT_RANDOM_DELAYS;
+		taskc->pending_trait = CHAOS_TRAIT_KPROBE_RANDOM_DELAYS;
 		dbg("GENERIC: setting pending_trait to RANDOM_DELAYS - task[%d]", p->pid);
 	}
 

scheds/rust/scx_chaos/src/lib.rs

@@ -141,6 +141,8 @@ pub enum RequiresPpid {
 pub struct KprobeRandomDelays {
     pub kprobes: Vec<String>,
     pub freq: f64,
+    pub min_us: u64,
+    pub max_us: u64,
 }
 
 #[derive(Debug)]
@@ -197,6 +199,8 @@ impl Scheduler {
                 [bpf_intf::chaos_stat_idx_CHAOS_STAT_TRAIT_DEGRADATION as usize],
             chaos_excluded: stats[bpf_intf::chaos_stat_idx_CHAOS_STAT_CHAOS_EXCLUDED as usize],
             chaos_skipped: stats[bpf_intf::chaos_stat_idx_CHAOS_STAT_CHAOS_SKIPPED as usize],
+            kprobe_random_delays: stats
+                [bpf_intf::chaos_stat_idx_CHAOS_STAT_KPROBE_RANDOM_DELAYS as usize],
             timer_kicks: stats[bpf_intf::chaos_stat_idx_CHAOS_STAT_TIMER_KICKS as usize],
         }
     }
@@ -443,6 +447,8 @@ impl Builder<'_> {
         if let Some(kprobe_random_delays) = &self.kprobe_random_delays {
             rodata.kprobe_delays_freq_frac32 =
                 (kprobe_random_delays.freq * 2_f64.powf(32_f64)) as u32;
+            rodata.kprobe_delays_min_ns = kprobe_random_delays.min_us * 1000;
+            rodata.kprobe_delays_max_ns = kprobe_random_delays.max_us * 1000;
         }
 
         // Set up the frequency array. The first element means nothing, so should be what's
@@ -608,12 +614,20 @@ pub struct PerfDegradationArgs {
 #[derive(Debug, Parser)]
 pub struct KprobeArgs {
     /// Introduce random delays in the scheduler whenever a provided kprobe is hit.
-    #[clap(long, num_args = 1.., value_parser)]
+    #[clap(long, num_args = 1.., value_parser, requires = "kprobe_random_delay_min_us")]
     pub kprobes_for_random_delays: Vec<String>,
 
-    /// Chance of kprobe random delays. Must be between 0 and 1.
+    /// Chance of kprobe random delays. Must be between 0 and 1. [default=0.1]
     #[clap(long, requires = "kprobes_for_random_delays")]
     pub kprobe_random_delay_frequency: Option<f64>,
+
+    /// Minimum time to add for kprobe random delay.
+    #[clap(long, requires = "kprobe_random_delay_max_us")]
+    pub kprobe_random_delay_min_us: Option<u64>,
+
+    /// Maximum time to add for kprobe random delay.
+    #[clap(long, requires = "kprobes_for_random_delays")]
+    pub kprobe_random_delay_max_us: Option<u64>,
 }
 
 /// scx_chaos: A general purpose sched_ext scheduler designed to amplify race conditions
@@ -763,9 +777,13 @@ impl<'a> Iterator for BuilderIterator<'a> {
                 KprobeArgs {
                     kprobes_for_random_delays,
                     kprobe_random_delay_frequency,
+                    kprobe_random_delay_min_us: Some(min_us),
+                    kprobe_random_delay_max_us: Some(max_us),
                 } if !kprobes_for_random_delays.is_empty() => Some(KprobeRandomDelays {
                     kprobes: kprobes_for_random_delays.clone(),
                     freq: kprobe_random_delay_frequency.unwrap_or(0.1),
+                    min_us: *min_us,
+                    max_us: *max_us,
                 }),
                 _ => None,
             };

scheds/rust/scx_chaos/src/stats.rs

@@ -27,18 +27,21 @@ pub struct Metrics {
     pub chaos_skipped: u64,
     #[stat(desc = "Number of timer-based CPU kicks for delayed tasks")]
     pub timer_kicks: u64,
+    #[stat(desc = "Number of times a kprobe caused a random delay to be applied")]
+    pub kprobe_random_delays: u64,
 }
 
 impl Metrics {
     fn format<W: Write>(&self, w: &mut W) -> Result<()> {
         writeln!(
             w,
-            "chaos traits: random_delays/cpu_freq/degradation {}/{}/{}\n\tchaos excluded/skipped {}/{}\n\ttimer kicks: {}",
+            "chaos traits: random_delays/cpu_freq/degradation {}/{}/{}\n\tchaos excluded/skipped {}/{}\n\tkprobe_random_delays {}\n\ttimer kicks: {}",
             self.trait_random_delays,
             self.trait_cpu_freq,
             self.trait_degradation,
             self.chaos_excluded,
             self.chaos_skipped,
+            self.kprobe_random_delays,
             self.timer_kicks,
         )?;
         Ok(())
@@ -51,6 +54,7 @@ impl Metrics {
             trait_degradation: self.trait_degradation - rhs.trait_degradation,
             chaos_excluded: self.chaos_excluded - rhs.chaos_excluded,
             chaos_skipped: self.chaos_skipped - rhs.chaos_skipped,
+            kprobe_random_delays: self.kprobe_random_delays - rhs.kprobe_random_delays,
             timer_kicks: self.timer_kicks - rhs.timer_kicks,
         }
     }