1 files changed, 20 insertions, 13 deletions

diff --git a/src/scheduler.rs b/src/scheduler.rs
index f99d2ec..fa86ef2 100644
--- a/src/scheduler.rs
+++ b/src/scheduler.rs
@@ -30,6 +30,7 @@ pub struct Scheduler<'a> {
     own_pid: Pid,
     p_cores: Range<i32>,
     e_cores: Option<Range<i32>>,
+    garbage_core: i32,
     topology: Topology,
     to_remove: Vec<Pid>,
     e_core_selector: Box<dyn CoreSelector>,
@@ -138,6 +139,7 @@ impl<'a> Scheduler<'a> {
             empty_task_infos,
             tasks_scheduled: 0,
             e_cores,
+            garbage_core: 0,
             topology,
             e_core_selector,
             p_core_selector,
@@ -150,11 +152,17 @@ impl<'a> Scheduler<'a> {
         })
     }
 
-    fn try_set_up_garbage_cpu(&self) -> Result<bool, TrySendError<FrequencyRequest>> {
+    fn try_set_up_garbage_cpu(&mut self) -> Result<bool, TrySendError<FrequencyRequest>> {
         if let Some(e_cores) = &self.e_cores {
+            self.garbage_core = e_cores.end.saturating_sub(1);
+            self.frequency_sender
+                .try_send(FrequencyRequest::SetFrequencyRangeForCore(
+                    self.garbage_core as u32,
+                    800_000..=1_200_000,
+                ))?;
             self.frequency_sender
                 .try_send(FrequencyRequest::SetGovernorForCore(
-                    e_cores.end.saturating_sub(1) as u32,
+                    self.garbage_core as u32,
                     Governor::Powersave,
                 ))?;
             Ok(true)
@@ -164,7 +172,7 @@ impl<'a> Scheduler<'a> {
     }
 
     fn consume_all_tasks(&mut self) {
-        while let Ok(Some(task)) = self.bpf.dequeue_task() {
+        while let Ok(Some(mut task)) = self.bpf.dequeue_task() {
             // The scheduler itself has to be scheduled regardless of its energy usage
             if task.pid == self.own_pid {
                 self.task_queue.push_front(task);
@@ -193,6 +201,10 @@ impl<'a> Scheduler<'a> {
                     // Get current budget for this task
                     match e.get().read_budget() {
                         0 => self.no_budget_task_queue.push_back(task),
+                        x if x < 1000 => {
+                            task.weight = 0;
+                            self.task_queue.push_back(task)
+                        }
                         _ => self.task_queue.push_back(task),
                     }
                 }
@@ -217,14 +229,9 @@ impl<'a> Scheduler<'a> {
                     dispatched_task.flags |= RL_CPU_ANY as u64;
                 }
 
-                // if self
-                //     .e_cores
-                //     .as_ref()
-                //     .map(|e_cores| e_cores.contains(&dispatched_task.cpu))
-                //     .unwrap_or(false)
-                // {
-                //     dispatched_task.cpu = self.p_core_selector.next_core(task.cpu);
-                // }
+                if task.weight == 0 && self.p_cores.contains(&dispatched_task.cpu) {
+                    dispatched_task.cpu = self.e_core_selector.next_core(task.cpu);
+                }
 
                 if task.pid == self.own_pid {
                     dispatched_task.slice_ns = SLICE_US * 1000;
@@ -261,8 +268,8 @@ impl<'a> Scheduler<'a> {
             if let Some(task) = self.no_budget_task_queue.pop_front() {
                 let mut dispatched_task = DispatchedTask::new(&task);
 
-                // Low budget tasks go to e-cores
-                let cpu = self.e_core_selector.next_core(task.cpu);
+                // Low budget tasks go to garbage_core
+                let cpu = self.garbage_core;
 
                 if cpu >= 0 {
                     dispatched_task.cpu = cpu;