timing changes

Author: Zoxc

src/librustc/Cargo.toml

@@ -59,4 +59,6 @@ chalk-engine = { version = "0.6.0", default-features=false }
 flate2 = "1.0"
 tempdir = "0.3"
 
-
+[target.'cfg(windows)'.dependencies]
+kernel32-sys = "0.2.2"
+winapi = "0.2.8"

src/librustc/lib.rs

@@ -40,6 +40,7 @@
        html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
        html_root_url = "https://doc.rust-lang.org/nightly/")]
 
+#![feature(asm)]
 #![feature(box_patterns)]
 #![feature(box_syntax)]
 #![feature(const_fn)]
@@ -86,6 +87,10 @@ extern crate graphviz;
 #[cfg(windows)]
 extern crate libc;
 extern crate polonius_engine;
+#[cfg(windows)]
+extern crate kernel32;
+#[cfg(windows)]
+extern crate winapi;
 extern crate rustc_target;
 #[macro_use] extern crate rustc_data_structures;
 extern crate serialize;

src/librustc/util/common.rs

@@ -176,6 +176,20 @@ pub fn time_ext<T, F>(do_it: bool, sess: Option<&Session>, what: &str, f: F) ->
             profq_msg(sess, ProfileQueriesMsg::TimeBegin(what.to_string()))
         }
     }
+
+    #[cfg(not(all(windows, parallel_queries, any(target_arch = "x86", target_arch = "x86_64"))))]
+    let rv = time_impl(sess, what, f);
+    #[cfg(all(windows, parallel_queries, any(target_arch = "x86", target_arch = "x86_64")))]
+    let rv = time_threads_impl(sess, what, f);
+
+    TIME_DEPTH.with(|slot| slot.set(old));
+
+    rv
+}
+
+fn time_impl<T, F>(sess: Option<&Session>, what: &str, f: F) -> T where
+    F: FnOnce() -> T,
+{
     let start = Instant::now();
     let rv = f();
     let dur = start.elapsed();
@@ -184,12 +198,98 @@ pub fn time_ext<T, F>(do_it: bool, sess: Option<&Session>, what: &str, f: F) ->
             profq_msg(sess, ProfileQueriesMsg::TimeEnd)
         }
     }
+    print_time_passes_entry_internal(what, duration_to_secs_str(dur));
+    rv
+}
 
-    print_time_passes_entry_internal(what, dur);
+#[cfg(all(windows, parallel_queries, any(target_arch = "x86", target_arch = "x86_64")))]
+fn time_threads_impl<T, F>(sess: Option<&Session>, what: &str, f: F) -> T where
+    F: FnOnce() -> T,
+{
+    use rayon_core::registry;
+    use std::iter;
+    use winapi;
+    use kernel32;
 
-    TIME_DEPTH.with(|slot| slot.set(old));
+    #[allow(unused_mut)]
+    fn read_counter() -> u64 {
+        let mut low: u32;
+        let mut high: u32;
 
-    rv
+        unsafe {
+            asm!("xor %rax, %rax; cpuid; rdtsc"
+                : "={eax}" (low), "={edx}" (high) :: "memory", "rbx", "rcx");
+        }
+
+        ((high as u64) << 32) | (low as u64)
+    }
+
+    let registry = registry::get_current_registry();
+    if let Some(registry) = registry {
+        let freq = unsafe {
+            let mut freq = 0;
+            assert!(kernel32::QueryPerformanceFrequency(&mut freq) == winapi::TRUE);
+            freq as u64 * 1000
+        };
+
+        let threads: Vec<_> = {
+            let threads = registry.handles.lock();
+            let current = unsafe {
+                iter::once(kernel32::GetCurrentThread())
+            };
+            current.chain(threads.iter().map(|t| t.0)).collect()
+        };
+        let mut begin: Vec<u64> = iter::repeat(0).take(threads.len()).collect();
+        let mut end: Vec<u64> = iter::repeat(0).take(threads.len()).collect();
+        for (i, &handle) in threads.iter().enumerate() {
+            unsafe {
+                assert!(kernel32::QueryThreadCycleTime(handle, &mut begin[i]) == winapi::TRUE);
+            }
+        }
+
+        let time_start = read_counter();
+        let result = f();
+        let time_end = read_counter();
+        for (i, &handle) in threads.iter().enumerate() {
+            unsafe {
+                assert!(kernel32::QueryThreadCycleTime(handle, &mut end[i]) == winapi::TRUE);
+            }
+        }
+        if let Some(sess) = sess {
+            if cfg!(debug_assertions) {
+                profq_msg(sess, ProfileQueriesMsg::TimeEnd)
+            }
+        }
+        let time = time_end - time_start;
+        let time_secs = time as f64 / freq as f64;
+
+        let thread_times: Vec<u64> = end.iter().zip(begin.iter()).map(|(e, b)| *e - *b).collect();
+
+        let total_thread_time: u64 = thread_times.iter().cloned().sum();
+        let core_usage = total_thread_time as f64 / time as f64;
+
+        let mut data = format!("{:.6} - cores {:.2}x - cpu {:.2} - threads (",
+                           time_secs,
+                           core_usage,
+                           core_usage / (thread_times.len() - 1) as f64);
+
+        for (i, thread_time) in thread_times.into_iter().enumerate() {
+            data.push_str(&format!("{:.2}", thread_time as f64 / time as f64));
+            if i == 0 {
+                data.push_str(" - ");
+            }
+            else if i < begin.len() - 1 {
+                data.push_str(" ");
+            }
+        }
+
+        data.push_str(")");
+
+        print_time_passes_entry_internal(what, data);
+        result
+    } else {
+        time_impl(sess, what, f)
+    }
 }
 
 pub fn print_time_passes_entry(do_it: bool, what: &str, dur: Duration) {
@@ -203,12 +303,12 @@ pub fn print_time_passes_entry(do_it: bool, what: &str, dur: Duration) {
         r
     });
 
-    print_time_passes_entry_internal(what, dur);
+    print_time_passes_entry_internal(what, duration_to_secs_str(dur));
 
     TIME_DEPTH.with(|slot| slot.set(old));
 }
 
-fn print_time_passes_entry_internal(what: &str, dur: Duration) {
+fn print_time_passes_entry_internal(what: &str, data: String) {
     let indentation = TIME_DEPTH.with(|slot| slot.get());
 
     let mem_string = match get_resident() {
@@ -220,7 +320,7 @@ fn print_time_passes_entry_internal(what: &str, dur: Duration) {
     };
     println!("{}time: {}{}\t{}",
              repeat("  ").take(indentation).collect::<String>(),
-             duration_to_secs_str(dur),
+             data,
              mem_string,
              what);
 }
@@ -232,7 +332,7 @@ pub fn duration_to_secs_str(dur: Duration) -> String {
     let secs = dur.as_secs() as f64 +
                dur.subsec_nanos() as f64 / NANOS_PER_SEC;
 
-    format!("{:.3}", secs)
+    format!("{:.6}", secs)
 }
 
 pub fn to_readable_str(mut val: usize) -> String {