1 files changed, 5 insertions, 25 deletions

diff --git a/src/scheduler.rs b/src/scheduler.rs
index fa86ef2..0832049 100644
--- a/src/scheduler.rs
+++ b/src/scheduler.rs
@@ -10,10 +10,10 @@ use scx_utils::{Topology, UserExitInfo};
 use std::collections::{HashMap, VecDeque};
 use std::mem::MaybeUninit;
 use std::ops::{Range, RangeInclusive};
+use std::process;
 use std::sync::mpsc::TrySendError;
 use std::sync::{mpsc, Arc, RwLock};
 use std::time::Duration;
-use std::{process, usize};
 
 use crate::Pid;
 
@@ -24,23 +24,17 @@ pub struct Scheduler<'a> {
     task_queue: VecDeque<QueuedTask>,
     no_budget_task_queue: VecDeque<QueuedTask>,
     managed_tasks: HashMap<Pid, Arc<TaskInfo>>,
-    maximum_budget: u64,
     tasks_scheduled: u64,
     //TODO: also consider Pids of children
     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>,
-    p_core_selector: Box<dyn CoreSelector>,
     energy_sender: mpsc::SyncSender<EnergyRequest>,
     empty_task_infos: mpsc::Receiver<Arc<TaskInfo>>,
     frequency_sender: mpsc::SyncSender<FrequencyRequest>,
-    shared_cpu_frequency_ranges: Arc<RwLock<Vec<RangeInclusive<FrequencyKHZ>>>>,
-    shared_policy_frequency_ranges: Arc<RwLock<Vec<RangeInclusive<FrequencyKHZ>>>>,
-    shared_cpu_current_frequencies: Arc<RwLock<Vec<FrequencyKHZ>>>,
 }
 
 impl<'a> Scheduler<'a> {
@@ -55,12 +49,8 @@ impl<'a> Scheduler<'a> {
             Arc::new(RwLock::new(Vec::new()));
 
         // Start energy tracking service
-        let energy_sender = energy::start_energy_service(
-            use_mocking,
-            shared_cpu_frequency_ranges.clone(),
-            shared_policy_frequency_ranges.clone(),
-            shared_cpu_current_frequencies.clone(),
-        )?;
+        let energy_sender =
+            energy::start_energy_service(use_mocking, shared_cpu_current_frequencies.clone())?;
 
         let (task_sender, empty_task_infos) = mpsc::sync_channel(200);
         std::thread::spawn(move || loop {
@@ -91,7 +81,6 @@ impl<'a> Scheduler<'a> {
             None
         };
 
-        let p_core_selector = Box::new(RoundRobinSelector::new(&p_cores));
         let e_core_selector = if let Some(e_cores) = &e_cores {
             // reserve the last e core as garbage core
             Box::new(RoundRobinSelector::new(
@@ -113,10 +102,10 @@ impl<'a> Scheduler<'a> {
         )?;
 
         frequency_sender
-            .try_send(FrequencyRequest::GetPolicyCPUFrequency)
+            .try_send(FrequencyRequest::UpdatePolicyCPUFrequency)
             .unwrap();
         frequency_sender
-            .try_send(FrequencyRequest::GetPossibleCPUFrequencyRange)
+            .try_send(FrequencyRequest::UpdatePossibleCPUFrequencyRange)
             .unwrap();
 
         std::thread::sleep(Duration::from_secs(1));
@@ -133,22 +122,16 @@ impl<'a> Scheduler<'a> {
             task_queue: VecDeque::new(),
             no_budget_task_queue: VecDeque::new(),
             managed_tasks: HashMap::new(),
-            maximum_budget: u64::MAX,
             own_pid: process::id() as i32,
             p_cores,
             empty_task_infos,
             tasks_scheduled: 0,
             e_cores,
             garbage_core: 0,
-            topology,
             e_core_selector,
-            p_core_selector,
             energy_sender,
             to_remove,
             frequency_sender,
-            shared_cpu_frequency_ranges,
-            shared_policy_frequency_ranges,
-            shared_cpu_current_frequencies,
         })
     }
 
@@ -211,9 +194,6 @@ impl<'a> Scheduler<'a> {
             }
         }
     }
-    fn dispatch_next_task(&mut self) {
-        self.batch_dispatch_next_tasks(1);
-    }
 
     fn batch_dispatch_next_tasks(&mut self, tasks: i32) {
         for _ in 0..tasks {