Auto merge of #51383 - Zoxc:parallel-stuff, r=nikomatsakis
Run some stuff in parallel
Requires https://github.com/rust-lang/rust/pull/50699 to actually work correctly.
r? @nikomatsakis
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index e4296a0..4f5f0c9 100644
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -44,7 +44,7 @@
use std::fmt;
use std::hash::{Hash, Hasher};
use std::ops::Deref;
-use rustc_data_structures::sync::Lrc;
+use rustc_data_structures::sync::{self, Lrc, ParallelIterator, par_iter};
use std::slice;
use std::vec::IntoIter;
use std::mem;
@@ -2436,6 +2436,12 @@
.map(move |&body_id| self.hir.body_owner_def_id(body_id))
}
+ pub fn par_body_owners<F: Fn(DefId) + sync::Sync + sync::Send>(self, f: F) {
+ par_iter(&self.hir.krate().body_ids).for_each(|&body_id| {
+ f(self.hir.body_owner_def_id(body_id))
+ });
+ }
+
pub fn expr_span(self, id: NodeId) -> Span {
match self.hir.find(id) {
Some(hir_map::NodeExpr(e)) => {
diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs
index 11d35de..684fd10 100644
--- a/src/librustc_borrowck/borrowck/mod.rs
+++ b/src/librustc_borrowck/borrowck/mod.rs
@@ -67,9 +67,9 @@
pub type LoanDataFlow<'a, 'tcx> = DataFlowContext<'a, 'tcx, LoanDataFlowOperator>;
pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
- for body_owner_def_id in tcx.body_owners() {
+ tcx.par_body_owners(|body_owner_def_id| {
tcx.borrowck(body_owner_def_id);
- }
+ });
}
pub fn provide(providers: &mut Providers) {
diff --git a/src/librustc_borrowck/lib.rs b/src/librustc_borrowck/lib.rs
index 52a357e..a5a20af 100644
--- a/src/librustc_borrowck/lib.rs
+++ b/src/librustc_borrowck/lib.rs
@@ -17,6 +17,8 @@
#![feature(from_ref)]
#![feature(quote)]
+#![recursion_limit="256"]
+
#[macro_use] extern crate log;
extern crate syntax;
extern crate syntax_pos;
diff --git a/src/librustc_data_structures/sync.rs b/src/librustc_data_structures/sync.rs
index 33f6eda..b82fe3e 100644
--- a/src/librustc_data_structures/sync.rs
+++ b/src/librustc_data_structures/sync.rs
@@ -26,6 +26,8 @@
//!
//! `MTLock` is a mutex which disappears if cfg!(parallel_queries) is false.
//!
+//! `MTRef` is a immutable refernce if cfg!(parallel_queries), and an mutable reference otherwise.
+//!
//! `rustc_erase_owner!` erases a OwningRef owner into Erased or Erased + Send + Sync
//! depending on the value of cfg!(parallel_queries).
@@ -126,6 +128,8 @@
}
}
+ pub type MTRef<'a, T> = &'a mut T;
+
#[derive(Debug)]
pub struct MTLock<T>(T);
@@ -151,13 +155,8 @@
}
#[inline(always)]
- pub fn borrow(&self) -> &T {
- &self.0
- }
-
- #[inline(always)]
- pub fn borrow_mut(&self) -> &T {
- &self.0
+ pub fn lock_mut(&mut self) -> &mut T {
+ &mut self.0
}
}
@@ -221,7 +220,37 @@
pub use std::sync::Arc as Lrc;
pub use std::sync::Weak as Weak;
- pub use self::Lock as MTLock;
+ pub type MTRef<'a, T> = &'a T;
+
+ #[derive(Debug)]
+ pub struct MTLock<T>(Lock<T>);
+
+ impl<T> MTLock<T> {
+ #[inline(always)]
+ pub fn new(inner: T) -> Self {
+ MTLock(Lock::new(inner))
+ }
+
+ #[inline(always)]
+ pub fn into_inner(self) -> T {
+ self.0.into_inner()
+ }
+
+ #[inline(always)]
+ pub fn get_mut(&mut self) -> &mut T {
+ self.0.get_mut()
+ }
+
+ #[inline(always)]
+ pub fn lock(&self) -> LockGuard<T> {
+ self.0.lock()
+ }
+
+ #[inline(always)]
+ pub fn lock_mut(&self) -> LockGuard<T> {
+ self.lock()
+ }
+ }
use parking_lot::Mutex as InnerLock;
use parking_lot::RwLock as InnerRwLock;
diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs
index 5d5baf76..c18a089 100644
--- a/src/librustc_driver/driver.rs
+++ b/src/librustc_driver/driver.rs
@@ -1272,11 +1272,9 @@
time(sess, "borrow checking", || borrowck::check_crate(tcx));
- time(sess, "MIR borrow checking", || {
- for def_id in tcx.body_owners() {
- tcx.mir_borrowck(def_id);
- }
- });
+ time(sess,
+ "MIR borrow checking",
+ || tcx.par_body_owners(|def_id| { tcx.mir_borrowck(def_id); }));
time(sess, "dumping chalk-like clauses", || {
rustc_traits::lowering::dump_program_clauses(tcx);
diff --git a/src/librustc_incremental/lib.rs b/src/librustc_incremental/lib.rs
index ababce6..3839c13 100644
--- a/src/librustc_incremental/lib.rs
+++ b/src/librustc_incremental/lib.rs
@@ -17,6 +17,8 @@
#![feature(fs_read_write)]
#![feature(specialization)]
+#![recursion_limit="256"]
+
extern crate graphviz;
#[macro_use] extern crate rustc;
extern crate rustc_data_structures;
diff --git a/src/librustc_incremental/persist/save.rs b/src/librustc_incremental/persist/save.rs
index be725b1..dcef0c6 100644
--- a/src/librustc_incremental/persist/save.rs
+++ b/src/librustc_incremental/persist/save.rs
@@ -13,6 +13,7 @@
use rustc::ty::TyCtxt;
use rustc::util::common::time;
use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::sync::join;
use rustc_serialize::Encodable as RustcEncodable;
use rustc_serialize::opaque::Encoder;
use std::io::{self, Cursor};
@@ -33,23 +34,28 @@
return;
}
- time(sess, "persist query result cache", || {
- save_in(sess,
- query_cache_path(sess),
- |e| encode_query_cache(tcx, e));
- });
+ let query_cache_path = query_cache_path(sess);
+ let dep_graph_path = dep_graph_path(sess);
- if tcx.sess.opts.debugging_opts.incremental_queries {
+ join(move || {
+ if tcx.sess.opts.debugging_opts.incremental_queries {
+ time(sess, "persist query result cache", || {
+ save_in(sess,
+ query_cache_path,
+ |e| encode_query_cache(tcx, e));
+ });
+ }
+ }, || {
time(sess, "persist dep-graph", || {
save_in(sess,
- dep_graph_path(sess),
+ dep_graph_path,
|e| {
time(sess, "encode dep-graph", || {
encode_dep_graph(tcx, e)
})
});
});
- }
+ });
dirty_clean::check_dirty_clean_annotations(tcx);
})
diff --git a/src/librustc_mir/lib.rs b/src/librustc_mir/lib.rs
index d815d4a..dc0d0b2 100644
--- a/src/librustc_mir/lib.rs
+++ b/src/librustc_mir/lib.rs
@@ -34,7 +34,10 @@
#![feature(specialization)]
#![feature(try_trait)]
+#![recursion_limit="256"]
+
extern crate arena;
+
#[macro_use]
extern crate bitflags;
#[macro_use] extern crate log;
diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs
index 1fb1217..96aeb96 100644
--- a/src/librustc_mir/monomorphize/collector.rs
+++ b/src/librustc_mir/monomorphize/collector.rs
@@ -207,10 +207,12 @@
use monomorphize::{self, Instance};
use rustc::util::nodemap::{FxHashSet, FxHashMap, DefIdMap};
+use rustc::util::common::time;
use monomorphize::item::{MonoItemExt, DefPathBasedNames, InstantiationMode};
use rustc_data_structures::bitvec::BitVector;
+use rustc_data_structures::sync::{MTRef, MTLock, ParallelIterator, par_iter};
#[derive(PartialEq, Eq, Hash, Clone, Copy, Debug)]
pub enum MonoItemCollectionMode {
@@ -298,22 +300,32 @@
mode: MonoItemCollectionMode)
-> (FxHashSet<MonoItem<'tcx>>,
InliningMap<'tcx>) {
- let roots = collect_roots(tcx, mode);
+ let roots = time(tcx.sess, "collecting roots", || {
+ collect_roots(tcx, mode)
+ });
debug!("Building mono item graph, beginning at roots");
- let mut visited = FxHashSet();
- let mut recursion_depths = DefIdMap();
- let mut inlining_map = InliningMap::new();
- for root in roots {
- collect_items_rec(tcx,
- root,
- &mut visited,
- &mut recursion_depths,
- &mut inlining_map);
+ let mut visited = MTLock::new(FxHashSet());
+ let mut inlining_map = MTLock::new(InliningMap::new());
+
+ {
+ let visited: MTRef<'_, _> = &mut visited;
+ let inlining_map: MTRef<'_, _> = &mut inlining_map;
+
+ time(tcx.sess, "collecting mono items", || {
+ par_iter(roots).for_each(|root| {
+ let mut recursion_depths = DefIdMap();
+ collect_items_rec(tcx,
+ root,
+ visited,
+ &mut recursion_depths,
+ inlining_map);
+ });
+ });
}
- (visited, inlining_map)
+ (visited.into_inner(), inlining_map.into_inner())
}
// Find all non-generic items by walking the HIR. These items serve as roots to
@@ -354,10 +366,10 @@
// Collect all monomorphized items reachable from `starting_point`
fn collect_items_rec<'a, 'tcx: 'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
starting_point: MonoItem<'tcx>,
- visited: &mut FxHashSet<MonoItem<'tcx>>,
+ visited: MTRef<'_, MTLock<FxHashSet<MonoItem<'tcx>>>>,
recursion_depths: &mut DefIdMap<usize>,
- inlining_map: &mut InliningMap<'tcx>) {
- if !visited.insert(starting_point.clone()) {
+ inlining_map: MTRef<'_, MTLock<InliningMap<'tcx>>>) {
+ if !visited.lock_mut().insert(starting_point.clone()) {
// We've been here already, no need to search again.
return;
}
@@ -428,7 +440,7 @@
fn record_accesses<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
caller: MonoItem<'tcx>,
callees: &[MonoItem<'tcx>],
- inlining_map: &mut InliningMap<'tcx>) {
+ inlining_map: MTRef<'_, MTLock<InliningMap<'tcx>>>) {
let is_inlining_candidate = |mono_item: &MonoItem<'tcx>| {
mono_item.instantiation_mode(tcx) == InstantiationMode::LocalCopy
};
@@ -438,7 +450,7 @@
(*mono_item, is_inlining_candidate(mono_item))
});
- inlining_map.record_accesses(caller, accesses);
+ inlining_map.lock_mut().record_accesses(caller, accesses);
}
fn check_recursion_limit<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index d68fc67..b70b61d 100644
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -702,9 +702,9 @@
{
debug_assert!(crate_num == LOCAL_CRATE);
Ok(tcx.sess.track_errors(|| {
- for body_owner_def_id in tcx.body_owners() {
+ tcx.par_body_owners(|body_owner_def_id| {
ty::query::queries::typeck_tables_of::ensure(tcx, body_owner_def_id);
- }
+ });
})?)
}
diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs
index ce7249b..80f57ad 100644
--- a/src/librustc_typeck/lib.rs
+++ b/src/librustc_typeck/lib.rs
@@ -83,6 +83,8 @@
#![feature(slice_sort_by_cached_key)]
#![feature(never_type)]
+#![recursion_limit="256"]
+
#[macro_use] extern crate log;
#[macro_use] extern crate syntax;
extern crate syntax_pos;