Parallelize and optimize parts of HIR map creation

Author: Zoxc

src/librustc/hir/lowering.rs

@@ -90,6 +90,8 @@ pub struct LoweringContext<'a> {
     trait_impls: BTreeMap<DefId, Vec<NodeId>>,
     trait_auto_impl: BTreeMap<DefId, NodeId>,
 
+    modules: BTreeMap<NodeId, hir::ModuleItems>,
+
     is_generator: bool,
 
     catch_scopes: Vec<NodeId>,
@@ -228,6 +230,7 @@ pub fn lower_crate(
         bodies: BTreeMap::new(),
         trait_impls: BTreeMap::new(),
         trait_auto_impl: BTreeMap::new(),
+        modules: BTreeMap::new(),
         exported_macros: Vec::new(),
         catch_scopes: Vec::new(),
         loop_scopes: Vec::new(),
@@ -356,6 +359,15 @@ impl<'a> LoweringContext<'a> {
         }
 
         impl<'lcx, 'interner> Visitor<'lcx> for MiscCollector<'lcx, 'interner> {
+            fn visit_mod(&mut self, m: &'lcx Mod, _s: Span, _attrs: &[Attribute], n: NodeId) {
+                self.lctx.modules.insert(n, hir::ModuleItems {
+                    items: Vec::new(),
+                    trait_items: Vec::new(),
+                    impl_items: Vec::new(),
+                });
+                visit::walk_mod(self, m);
+            }
+
             fn visit_item(&mut self, item: &'lcx Item) {
                 self.lctx.allocate_hir_id_counter(item.id, item);
 
@@ -395,6 +407,7 @@ impl<'a> LoweringContext<'a> {
 
         struct ItemLowerer<'lcx, 'interner: 'lcx> {
             lctx: &'lcx mut LoweringContext<'interner>,
+            module: NodeId,
         }
 
         impl<'lcx, 'interner> ItemLowerer<'lcx, 'interner> {
@@ -414,11 +427,20 @@ impl<'a> LoweringContext<'a> {
         }
 
         impl<'lcx, 'interner> Visitor<'lcx> for ItemLowerer<'lcx, 'interner> {
+            fn visit_mod(&mut self, m: &'lcx Mod, _s: Span, _attrs: &[Attribute], n: NodeId) {
+                let old = self.module;
+                self.module = n;
+                visit::walk_mod(self, m);
+                self.module = old;
+            }
+
             fn visit_item(&mut self, item: &'lcx Item) {
                 let mut item_lowered = true;
+                let module = &self.module;
                 self.lctx.with_hir_id_owner(item.id, |lctx| {
                     if let Some(hir_item) = lctx.lower_item(item) {
                         lctx.items.insert(item.id, hir_item);
+                        lctx.modules.get_mut(module).unwrap().items.push(item.id);
                     } else {
                         item_lowered = false;
                     }
@@ -433,8 +455,9 @@ impl<'a> LoweringContext<'a> {
                         _ => HirVec::new(),
                     };
 
+                    let module = self.module;
                     self.lctx.with_parent_impl_lifetime_defs(&item_generics, |this| {
-                        let this = &mut ItemLowerer { lctx: this };
+                        let this = &mut ItemLowerer { lctx: this, module };
                         if let ItemKind::Impl(.., ref opt_trait_ref, _, _) = item.node {
                             this.with_trait_impl_ref(opt_trait_ref, |this| {
                                 visit::walk_item(this, item)
@@ -447,20 +470,24 @@ impl<'a> LoweringContext<'a> {
             }
 
             fn visit_trait_item(&mut self, item: &'lcx TraitItem) {
+                let module = &self.module;
                 self.lctx.with_hir_id_owner(item.id, |lctx| {
                     let id = hir::TraitItemId { node_id: item.id };
                     let hir_item = lctx.lower_trait_item(item);
                     lctx.trait_items.insert(id, hir_item);
+                    lctx.modules.get_mut(module).unwrap().trait_items.push(id);
                 });
 
                 visit::walk_trait_item(self, item);
             }
 
             fn visit_impl_item(&mut self, item: &'lcx ImplItem) {
+                let module = &self.module;
                 self.lctx.with_hir_id_owner(item.id, |lctx| {
                     let id = hir::ImplItemId { node_id: item.id };
                     let hir_item = lctx.lower_impl_item(item);
                     lctx.impl_items.insert(id, hir_item);
+                    lctx.modules.get_mut(module).unwrap().impl_items.push(id);
                 });
                 visit::walk_impl_item(self, item);
             }
@@ -470,7 +497,7 @@ impl<'a> LoweringContext<'a> {
         debug_assert!(self.node_id_to_hir_id[CRATE_NODE_ID] == hir::CRATE_HIR_ID);
 
         visit::walk_crate(&mut MiscCollector { lctx: &mut self }, c);
-        visit::walk_crate(&mut ItemLowerer { lctx: &mut self }, c);
+        visit::walk_crate(&mut ItemLowerer { lctx: &mut self, module: CRATE_NODE_ID }, c);
 
         let module = self.lower_mod(&c.module);
         let attrs = self.lower_attrs(&c.attrs);
@@ -492,6 +519,7 @@ impl<'a> LoweringContext<'a> {
             body_ids,
             trait_impls: self.trait_impls,
             trait_auto_impl: self.trait_auto_impl,
+            modules: self.modules,
         }
     }
 

src/librustc/hir/map/collector.rs

@@ -6,6 +6,7 @@ use rustc_data_structures::svh::Svh;
 use ich::Fingerprint;
 use middle::cstore::CrateStore;
 use session::CrateDisambiguator;
+use session::Session;
 use std::iter::repeat;
 use syntax::ast::{NodeId, CRATE_NODE_ID};
 use syntax::source_map::SourceMap;
@@ -45,11 +46,11 @@ pub(super) struct NodeCollector<'a, 'hir> {
 }
 
 impl<'a, 'hir> NodeCollector<'a, 'hir> {
-    pub(super) fn root(krate: &'hir Crate,
+    pub(super) fn root(sess: &'a Session,
+                       krate: &'hir Crate,
                        dep_graph: &'a DepGraph,
                        definitions: &'a definitions::Definitions,
-                       hcx: StableHashingContext<'a>,
-                       source_map: &'a SourceMap)
+                       hcx: StableHashingContext<'a>)
                 -> NodeCollector<'a, 'hir> {
         let root_mod_def_path_hash = definitions.def_path_hash(CRATE_DEF_INDEX);
 
@@ -71,6 +72,7 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
                 trait_impls: _,
                 trait_auto_impl: _,
                 body_ids: _,
+                modules: _,
             } = *krate;
 
             root_mod_sig_dep_index = dep_graph.input_task(
@@ -97,8 +99,8 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
 
         let mut collector = NodeCollector {
             krate,
-            source_map,
-            map: vec![],
+            source_map: sess.source_map(),
+            map: repeat(None).take(sess.current_node_id_count()).collect(),
             parent_node: CRATE_NODE_ID,
             current_signature_dep_index: root_mod_sig_dep_index,
             current_full_dep_index: root_mod_full_dep_index,
@@ -175,10 +177,6 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
 
     fn insert_entry(&mut self, id: NodeId, entry: Entry<'hir>) {
         debug!("hir_map: {:?} => {:?}", id, entry);
-        let len = self.map.len();
-        if id.as_usize() >= len {
-            self.map.extend(repeat(None).take(id.as_usize() - len + 1));
-        }
         self.map[id.as_usize()] = Some(entry);
     }
 

src/librustc/hir/map/hir_id_validator.rs

@@ -3,19 +3,24 @@ use hir::{self, intravisit, HirId, ItemLocalId};
 use syntax::ast::NodeId;
 use hir::itemlikevisit::ItemLikeVisitor;
 use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::sync::{Lock, ParallelIterator, par_iter};
 
 pub fn check_crate<'hir>(hir_map: &hir::map::Map<'hir>) {
-    let mut outer_visitor = OuterVisitor {
-        hir_map,
-        errors: vec![],
-    };
-
     hir_map.dep_graph.assert_ignored();
 
-    hir_map.krate().visit_all_item_likes(&mut outer_visitor);
-    if !outer_visitor.errors.is_empty() {
-        let message = outer_visitor
-            .errors
+    let errors = Lock::new(Vec::new());
+
+    par_iter(&hir_map.krate().modules).for_each(|(module_id, _)| {
+        hir_map.visit_module_item_likes(hir_map.local_def_id(*module_id), &mut OuterVisitor {
+            hir_map,
+            errors: &errors,
+        });
+    });
+
+    let errors = errors.into_inner();
+
+    if !errors.is_empty() {
+        let message = errors
             .iter()
             .fold(String::new(), |s1, s2| s1 + "\n" + s2);
         bug!("{}", message);
@@ -26,12 +31,12 @@ struct HirIdValidator<'a, 'hir: 'a> {
     hir_map: &'a hir::map::Map<'hir>,
     owner_def_index: Option<DefIndex>,
     hir_ids_seen: FxHashMap<ItemLocalId, NodeId>,
-    errors: Vec<String>,
+    errors: &'a Lock<Vec<String>>,
 }
 
 struct OuterVisitor<'a, 'hir: 'a> {
     hir_map: &'a hir::map::Map<'hir>,
-    errors: Vec<String>,
+    errors: &'a Lock<Vec<String>>,
 }
 
 impl<'a, 'hir: 'a> OuterVisitor<'a, 'hir> {
@@ -42,7 +47,7 @@ impl<'a, 'hir: 'a> OuterVisitor<'a, 'hir> {
             hir_map,
             owner_def_index: None,
             hir_ids_seen: Default::default(),
-            errors: Vec::new(),
+            errors: self.errors,
         }
     }
 }
@@ -51,23 +56,25 @@ impl<'a, 'hir: 'a> ItemLikeVisitor<'hir> for OuterVisitor<'a, 'hir> {
     fn visit_item(&mut self, i: &'hir hir::Item) {
         let mut inner_visitor = self.new_inner_visitor(self.hir_map);
         inner_visitor.check(i.id, |this| intravisit::walk_item(this, i));
-        self.errors.extend(inner_visitor.errors.drain(..));
     }
 
     fn visit_trait_item(&mut self, i: &'hir hir::TraitItem) {
         let mut inner_visitor = self.new_inner_visitor(self.hir_map);
         inner_visitor.check(i.id, |this| intravisit::walk_trait_item(this, i));
-        self.errors.extend(inner_visitor.errors.drain(..));
     }
 
     fn visit_impl_item(&mut self, i: &'hir hir::ImplItem) {
         let mut inner_visitor = self.new_inner_visitor(self.hir_map);
         inner_visitor.check(i.id, |this| intravisit::walk_impl_item(this, i));
-        self.errors.extend(inner_visitor.errors.drain(..));
     }
 }
 
 impl<'a, 'hir: 'a> HirIdValidator<'a, 'hir> {
+    #[cold]
+    #[inline(never)]
+    fn error(&self, f: impl FnOnce() -> String) {
+        self.errors.lock().push(f());
+    }
 
     fn check<F: FnOnce(&mut HirIdValidator<'a, 'hir>)>(&mut self,
                                                        node_id: NodeId,
@@ -119,7 +126,7 @@ impl<'a, 'hir: 'a> HirIdValidator<'a, 'hir> {
                                            local_id,
                                            self.hir_map.node_to_string(node_id)));
             }
-            self.errors.push(format!(
+            self.error(|| format!(
                 "ItemLocalIds not assigned densely in {}. \
                 Max ItemLocalId = {}, missing IDs = {:?}; seens IDs = {:?}",
                 self.hir_map.def_path(DefId::local(owner_def_index)).to_string_no_crate(),
@@ -145,14 +152,14 @@ impl<'a, 'hir: 'a> intravisit::Visitor<'hir> for HirIdValidator<'a, 'hir> {
         let stable_id = self.hir_map.definitions().node_to_hir_id[node_id];
 
         if stable_id == hir::DUMMY_HIR_ID {
-            self.errors.push(format!("HirIdValidator: No HirId assigned for NodeId {}: {:?}",
+            self.error(|| format!("HirIdValidator: No HirId assigned for NodeId {}: {:?}",
                                      node_id,
                                      self.hir_map.node_to_string(node_id)));
             return;
         }
 
         if owner != stable_id.owner {
-            self.errors.push(format!(
+            self.error(|| format!(
                 "HirIdValidator: The recorded owner of {} is {} instead of {}",
                 self.hir_map.node_to_string(node_id),
                 self.hir_map.def_path(DefId::local(stable_id.owner)).to_string_no_crate(),
@@ -161,7 +168,7 @@ impl<'a, 'hir: 'a> intravisit::Visitor<'hir> for HirIdValidator<'a, 'hir> {
 
         if let Some(prev) = self.hir_ids_seen.insert(stable_id.local_id, node_id) {
             if prev != node_id {
-                self.errors.push(format!(
+                self.error(|| format!(
                     "HirIdValidator: Same HirId {}/{} assigned for nodes {} and {}",
                     self.hir_map.def_path(DefId::local(stable_id.owner)).to_string_no_crate(),
                     stable_id.local_id.as_usize(),