Split query stats into its own file

diff --git a/src/librustc/ty/query/mod.rs b/src/librustc/ty/query/mod.rs
index 91ae11b327ed95f729ae3c6e59ebc7cf52a320ea..540344a11edf1aeff94574c9b0d5386e9e297d60 100644 (file)
--- a/src/librustc/ty/query/mod.rs
+++ b/src/librustc/ty/query/mod.rs
@@ -52,7 +52,6 @@
 use rustc_attr as attr;
 use rustc_span::symbol::Symbol;
 use rustc_span::{Span, DUMMY_SP};
-use std::any::type_name;
 use std::borrow::Cow;
 use std::convert::TryFrom;
 use std::ops::Deref;
@@ -64,6 +63,9 @@
 use self::plumbing::*;
 pub use self::plumbing::{force_from_dep_node, CycleError};
 
+mod stats;
+pub use self::stats::print_stats;
+
 mod job;
 #[cfg(parallel_compiler)]
 pub use self::job::handle_deadlock;

diff --git a/src/librustc/ty/query/plumbing.rs b/src/librustc/ty/query/plumbing.rs
index 13132739f89a3de127ffd113dda459296683af9e..c724209f8786263042567ca0bedab6763df267f6 100644 (file)
--- a/src/librustc/ty/query/plumbing.rs
+++ b/src/librustc/ty/query/plumbing.rs
@@ -883,101 +883,6 @@ pub fn try_collect_active_jobs(
 
                 Some(jobs)
             }
-
-            pub fn print_stats(&self) {
-                let mut queries = Vec::new();
-
-                #[derive(Clone)]
-                struct QueryStats {
-                    name: &'static str,
-                    cache_hits: usize,
-                    key_size: usize,
-                    key_type: &'static str,
-                    value_size: usize,
-                    value_type: &'static str,
-                    entry_count: usize,
-                }
-
-                fn stats<'tcx, Q: QueryAccessors<'tcx>>(
-                    name: &'static str,
-                    map: &QueryState<'tcx, Q>,
-                ) -> QueryStats {
-                    QueryStats {
-                        name,
-                        #[cfg(debug_assertions)]
-                        cache_hits: map.cache_hits,
-                        #[cfg(not(debug_assertions))]
-                        cache_hits: 0,
-                        key_size: mem::size_of::<Q::Key>(),
-                        key_type: type_name::<Q::Key>(),
-                        value_size: mem::size_of::<Q::Value>(),
-                        value_type: type_name::<Q::Value>(),
-                        entry_count: map.iter_results(|results| results.count()),
-                    }
-                }
-
-                $(
-                    queries.push(stats::<queries::$name<'_>>(
-                        stringify!($name),
-                        &self.$name,
-                    ));
-                )*
-
-                if cfg!(debug_assertions) {
-                    let hits: usize = queries.iter().map(|s| s.cache_hits).sum();
-                    let results: usize = queries.iter().map(|s| s.entry_count).sum();
-                    println!("\nQuery cache hit rate: {}", hits as f64 / (hits + results) as f64);
-                }
-
-                let mut query_key_sizes = queries.clone();
-                query_key_sizes.sort_by_key(|q| q.key_size);
-                println!("\nLarge query keys:");
-                for q in query_key_sizes.iter().rev()
-                                        .filter(|q| q.key_size > 8) {
-                    println!(
-                        "   {} - {} x {} - {}",
-                        q.name,
-                        q.key_size,
-                        q.entry_count,
-                        q.key_type
-                    );
-                }
-
-                let mut query_value_sizes = queries.clone();
-                query_value_sizes.sort_by_key(|q| q.value_size);
-                println!("\nLarge query values:");
-                for q in query_value_sizes.iter().rev()
-                                          .filter(|q| q.value_size > 8) {
-                    println!(
-                        "   {} - {} x {} - {}",
-                        q.name,
-                        q.value_size,
-                        q.entry_count,
-                        q.value_type
-                    );
-                }
-
-                if cfg!(debug_assertions) {
-                    let mut query_cache_hits = queries.clone();
-                    query_cache_hits.sort_by_key(|q| q.cache_hits);
-                    println!("\nQuery cache hits:");
-                    for q in query_cache_hits.iter().rev() {
-                        println!(
-                            "   {} - {} ({}%)",
-                            q.name,
-                            q.cache_hits,
-                            q.cache_hits as f64 / (q.cache_hits + q.entry_count) as f64
-                        );
-                    }
-                }
-
-                let mut query_value_count = queries.clone();
-                query_value_count.sort_by_key(|q| q.entry_count);
-                println!("\nQuery value count:");
-                for q in query_value_count.iter().rev() {
-                    println!("   {} - {}", q.name, q.entry_count);
-                }
-            }
         }
 
         #[allow(nonstandard_style)]

diff --git a/src/librustc/ty/query/stats.rs b/src/librustc/ty/query/stats.rs
new file mode 100644 (file)
index 0000000..0c775e5
--- /dev/null
+++ b/src/librustc/ty/query/stats.rs
@@ -0,0 +1,102 @@
+use crate::ty::query::config::QueryAccessors;
+use crate::ty::query::plumbing::QueryState;
+use crate::ty::query::queries;
+use crate::ty::TyCtxt;
+
+use std::any::type_name;
+use std::mem;
+
+#[derive(Clone)]
+struct QueryStats {
+    name: &'static str,
+    cache_hits: usize,
+    key_size: usize,
+    key_type: &'static str,
+    value_size: usize,
+    value_type: &'static str,
+    entry_count: usize,
+}
+
+fn stats<'tcx, Q: QueryAccessors<'tcx>>(
+    name: &'static str,
+    map: &QueryState<'tcx, Q>,
+) -> QueryStats {
+    QueryStats {
+        name,
+        #[cfg(debug_assertions)]
+        cache_hits: map.cache_hits,
+        #[cfg(not(debug_assertions))]
+        cache_hits: 0,
+        key_size: mem::size_of::<Q::Key>(),
+        key_type: type_name::<Q::Key>(),
+        value_size: mem::size_of::<Q::Value>(),
+        value_type: type_name::<Q::Value>(),
+        entry_count: map.iter_results(|results| results.count()),
+    }
+}
+
+pub fn print_stats(tcx: TyCtxt<'_>) {
+    let queries = query_stats(tcx);
+
+    if cfg!(debug_assertions) {
+        let hits: usize = queries.iter().map(|s| s.cache_hits).sum();
+        let results: usize = queries.iter().map(|s| s.entry_count).sum();
+        println!("\nQuery cache hit rate: {}", hits as f64 / (hits + results) as f64);
+    }
+
+    let mut query_key_sizes = queries.clone();
+    query_key_sizes.sort_by_key(|q| q.key_size);
+    println!("\nLarge query keys:");
+    for q in query_key_sizes.iter().rev().filter(|q| q.key_size > 8) {
+        println!("   {} - {} x {} - {}", q.name, q.key_size, q.entry_count, q.key_type);
+    }
+
+    let mut query_value_sizes = queries.clone();
+    query_value_sizes.sort_by_key(|q| q.value_size);
+    println!("\nLarge query values:");
+    for q in query_value_sizes.iter().rev().filter(|q| q.value_size > 8) {
+        println!("   {} - {} x {} - {}", q.name, q.value_size, q.entry_count, q.value_type);
+    }
+
+    if cfg!(debug_assertions) {
+        let mut query_cache_hits = queries.clone();
+        query_cache_hits.sort_by_key(|q| q.cache_hits);
+        println!("\nQuery cache hits:");
+        for q in query_cache_hits.iter().rev() {
+            println!(
+                "   {} - {} ({}%)",
+                q.name,
+                q.cache_hits,
+                q.cache_hits as f64 / (q.cache_hits + q.entry_count) as f64
+            );
+        }
+    }
+
+    let mut query_value_count = queries.clone();
+    query_value_count.sort_by_key(|q| q.entry_count);
+    println!("\nQuery value count:");
+    for q in query_value_count.iter().rev() {
+        println!("   {} - {}", q.name, q.entry_count);
+    }
+}
+
+macro_rules! print_stats {
+    (<$tcx:tt> $($category:tt {
+        $($(#[$attr:meta])* [$($modifiers:tt)*] fn $name:ident: $node:ident($K:ty) -> $V:ty,)*
+    },)*) => {
+        fn query_stats(tcx: TyCtxt<'_>) -> Vec<QueryStats> {
+            let mut queries = Vec::new();
+
+            $($(
+                queries.push(stats::<queries::$name<'_>>(
+                    stringify!($name),
+                    &tcx.queries.$name,
+                ));
+            )*)*
+
+            queries
+        }
+    }
+}
+
+rustc_query_append! { [print_stats!][<'tcx>] }

diff --git a/src/librustc_interface/passes.rs b/src/librustc_interface/passes.rs
index 0b4a337051f01ac440c1bf2518eff0918c580c9e..96a2ac08f2c49c7e5a5d553665ec614c4dd97106 100644 (file)
--- a/src/librustc_interface/passes.rs
+++ b/src/librustc_interface/passes.rs
@@ -696,8 +696,8 @@ pub fn enter<F, R>(&mut self, f: F) -> R
         ty::tls::enter_global(self.0, |tcx| f(tcx))
     }
 
-    pub fn print_stats(&self) {
-        self.0.queries.print_stats()
+    pub fn print_stats(&mut self) {
+        self.enter(|tcx| ty::query::print_stats(tcx))
     }
 }
 

diff --git a/src/librustc_interface/queries.rs b/src/librustc_interface/queries.rs
index 720d162ac819e439e3ece957dd6df9031faf527c..0c77ab57500a0785bc66eece5de3a82df6210129 100644 (file)
--- a/src/librustc_interface/queries.rs
+++ b/src/librustc_interface/queries.rs
@@ -340,7 +340,7 @@ pub fn enter<F, T>(&self, f: F) -> T
 
         if self.session().opts.debugging_opts.query_stats {
             if let Ok(gcx) = queries.global_ctxt() {
-                gcx.peek().print_stats();
+                gcx.peek_mut().print_stats();
             }
         }