Determine core types

2 files changed, 27 insertions, 6 deletions

diff --git a/src/e_core_selector.rs b/src/e_core_selector.rs
index 58cefb9..c4c2c4a 100644
--- a/src/e_core_selector.rs
+++ b/src/e_core_selector.rs
@@ -12,9 +12,9 @@ pub struct RoundRobinSelector {
 }
 
 impl RoundRobinSelector {
-    pub fn new(e_cores: Range<u32>) -> RoundRobinSelector {
+    pub fn new(e_cores: &Range<i32>) -> RoundRobinSelector {
         Self {
-            offset: e_cores.start,
+            offset: e_cores.start as u32,
             num_cores: e_cores.len() as u32,
             last_used: 0,
         }
diff --git a/src/main.rs b/src/main.rs
index 747b913..36f22eb 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -19,6 +19,8 @@ use task_state::TaskState;
 use mock::{MockModule, KernelModule, KernelDriver};
 
 use std::collections::{HashMap, VecDeque};
+use std::fs::File;
+use std::io::{BufRead, BufReader};
 use std::mem::MaybeUninit;
 use std::process;
 use std::ops::Range;
@@ -55,7 +57,26 @@ impl<'a> Scheduler<'a> {
         } else { 
             Box::new(KernelDriver::default())
         };
-        let selector = Box::new(RoundRobinSelector::new(8..16)); //TODO: get real value
+
+        let e_cores_file = File::open("/sys/devices/cpu_atom/cpus")?;
+        let e_cores_reader = BufReader::new(e_cores_file);
+        let e_cores = if let Some(Ok(line)) = e_cores_reader.lines().next() {
+            let cores: Vec<&str> = line.split('-').collect();
+            cores[0].parse::<i32>().unwrap()..cores[1].parse::<i32>().unwrap()
+        } else {
+            panic!("Was not able to differentiate between core types. Does the system have e cores?")
+        };
+
+        let p_cores_file = File::open("/sys/devices/cpu_core/cpus")?;
+        let p_cores_reader = BufReader::new(p_cores_file);
+        let p_cores = if let Some(Ok(line)) = p_cores_reader.lines().next() {
+            let cores: Vec<&str> = line.split('-').collect();
+            cores[0].parse::<i32>().unwrap()..cores[1].parse::<i32>().unwrap()
+        } else {
+            panic!("Was not able to differentiate between core types. Does the system have e cores?")
+        };
+
+        let selector = Box::new(RoundRobinSelector::new(&e_cores));
         Ok(Self {
             bpf,
             module,
@@ -65,8 +86,8 @@ impl<'a> Scheduler<'a> {
             maximum_budget: u64::MAX,
             power_cap,
             own_pid: process::id(),
-            p_cores: 0..8, //TODO: real value
-            e_cores: 8..16, //TODO: real value
+            p_cores,
+            e_cores,
             e_core_selector: selector,
         })
     }
@@ -174,7 +195,7 @@ impl<'a> Scheduler<'a> {
 
     fn dispatch_tasks(&mut self) {
         loop {
-            //TODO: we should probably not do this every time but after a predefined amount of time
+            //TODO: we should probably not do this every time, and instead wait a predefined amount of time
             self.reset_budgets_and_garbage_collect();
 
             // Consume all tasks before dispatching any.