Add energy monitoring and characterization scripts

components/profile/time.rs

@@ -6,12 +6,14 @@
 
 use heartbeats;
 use ipc_channel::ipc::{self, IpcReceiver};
+use profile_traits::energy::{energy_interval_ms, read_energy_uj};
 use profile_traits::time::{ProfilerCategory, ProfilerChan, ProfilerMsg, TimerMetadata};
 use std::borrow::ToOwned;
 use std::cmp::Ordering;
 use std::collections::BTreeMap;
 use std::f64;
 use std::thread::sleep_ms;
+use std_time::precise_time_ns;
 use util::task::spawn_named;
 
 pub trait Formattable {
@@ -93,6 +95,7 @@ impl Formattable for ProfilerCategory {
             ProfilerCategory::ScriptWebSocketEvent => "Script Web Socket Event",
             ProfilerCategory::ScriptWorkerEvent => "Script Worker Event",
             ProfilerCategory::ScriptXhrEvent => "Script Xhr Event",
+            ProfilerCategory::ApplicationHeartbeat => "Application Heartbeat",
         };
         format!("{}{}", padding, name)
     }
@@ -141,8 +144,49 @@ impl Profiler {
             }
         }
         heartbeats::init();
+        let profiler_chan = ProfilerChan(chan);
 
-        ProfilerChan(chan)
+        // only spawn the application-level profiler thread if its heartbeat is enabled
+        let run_ap_thread = || {
+            heartbeats::is_heartbeat_enabled(&ProfilerCategory::ApplicationHeartbeat)
+        };
+        if run_ap_thread() {
+            let profiler_chan = profiler_chan.clone();
+            // min of 1 heartbeat/sec, max of 20 should provide accurate enough power/energy readings
+            // waking up more frequently allows the thread to end faster on exit
+            const SLEEP_MS: u32 = 10;
+            const MIN_ENERGY_INTERVAL_MS: u32 = 50;
+            const MAX_ENERGY_INTERVAL_MS: u32 = 1000;
+            let interval_ms = enforce_range(MIN_ENERGY_INTERVAL_MS, MAX_ENERGY_INTERVAL_MS, energy_interval_ms());
+            let loop_count: u32 = (interval_ms as f32 / SLEEP_MS as f32).ceil() as u32;
+            spawn_named("Application heartbeat profiler".to_owned(), move || {
+                let mut start_time = precise_time_ns();
+                let mut start_energy = read_energy_uj();
+                loop {
+                    for _ in 0..loop_count {
+                        match run_ap_thread() {
+                            true => sleep_ms(SLEEP_MS),
+                            false => return,
+                        }
+                    }
+                    let end_time = precise_time_ns();
+                    let end_energy = read_energy_uj();
+                    // send using the inner channel
+                    // (using ProfilerChan.send() forces an unwrap and sometimes panics for this background profiler)
+                    let ProfilerChan(ref c) = profiler_chan;
+                    match c.send(ProfilerMsg::Time((ProfilerCategory::ApplicationHeartbeat, None),
+                                                   (start_time, end_time),
+                                                   (start_energy, end_energy))) {
+                        Ok(_) => {},
+                        Err(_) => return,
+                    };
+                    start_time = end_time;
+                    start_energy = end_energy;
+                }
+            });
+        }
+
+        profiler_chan
     }
 
     pub fn new(port: IpcReceiver<ProfilerMsg>) -> Profiler {
@@ -178,8 +222,8 @@ impl Profiler {
 
     fn handle_msg(&mut self, msg: ProfilerMsg) -> bool {
         match msg.clone() {
-            ProfilerMsg::Time(k, t) => {
-                heartbeats::maybe_heartbeat(&k.0, t.0, t.1, 0, 0);
+            ProfilerMsg::Time(k, t, e) => {
+                heartbeats::maybe_heartbeat(&k.0, t.0, t.1, e.0, e.1);
                 let ms = (t.1 - t.0) as f64 / 1000000f64;
                 self.find_or_insert(k, ms);
             },
@@ -224,3 +268,16 @@ impl Profiler {
         println!("");
     }
 }
+
+fn enforce_range<T>(min: T, max: T, value: T) -> T where T: Ord {
+    assert!(min <= max);
+    match value.cmp(&max) {
+        Ordering::Equal | Ordering::Greater => max,
+        Ordering::Less => {
+            match value.cmp(&min) {
+                Ordering::Equal | Ordering::Less => min,
+                Ordering::Greater => value,
+            }
+        },
+    }
+}