Introduce non-incremental queries and load the dep graph with a query

Author: Zoxc

src/librustc/dep_graph/dep_node.rs

@@ -229,7 +229,7 @@ macro_rules! define_dep_nodes {
                                    (tcx.sess.opts.debugging_opts.incremental_info ||
                                     tcx.sess.opts.debugging_opts.query_dep_graph)
                                 {
-                                    tcx.dep_graph.register_dep_node_debug_str(dep_node, || {
+                                    tcx.dep_graph().register_dep_node_debug_str(dep_node, || {
                                         arg.to_debug_str(tcx)
                                     });
                                 }
@@ -252,7 +252,7 @@ macro_rules! define_dep_nodes {
                                    (tcx.sess.opts.debugging_opts.incremental_info ||
                                     tcx.sess.opts.debugging_opts.query_dep_graph)
                                 {
-                                    tcx.dep_graph.register_dep_node_debug_str(dep_node, || {
+                                    tcx.dep_graph().register_dep_node_debug_str(dep_node, || {
                                         tupled_args.to_debug_str(tcx)
                                     });
                                 }
@@ -373,7 +373,7 @@ impl fmt::Debug for DepNode {
             if let Some(tcx) = opt_tcx {
                 if let Some(def_id) = self.extract_def_id(tcx) {
                     write!(f, "{}", tcx.def_path_debug_str(def_id))?;
-                } else if let Some(ref s) = tcx.dep_graph.dep_node_debug_str(*self) {
+                } else if let Some(ref s) = tcx.dep_graph().dep_node_debug_str(*self) {
                     write!(f, "{}", s)?;
                 } else {
                     write!(f, "{}", self.hash)?;
@@ -407,6 +407,10 @@ rustc_dep_node_append!([define_dep_nodes!][ <'tcx>
     // We use this for most things when incr. comp. is turned off.
     [] Null,
 
+    // Represents all queries which are not incremental.
+    // This is always treated as a red dep node.
+    [] NonIncremental,
+
     // Represents the `Krate` as a whole (the `hir::Krate` value) (as
     // distinct from the krate module). This is basically a hash of
     // the entire krate, so if you read from `Krate` (e.g., by calling
@@ -435,8 +439,6 @@ rustc_dep_node_append!([define_dep_nodes!][ <'tcx>
     [anon] TraitSelect,
 
     [] CompileCodegenUnit(InternedString),
-
-    [eval_always] Analysis(CrateNum),
 ]);
 
 pub trait RecoverKey<'tcx>: Sized {

src/librustc/dep_graph/graph.rs

@@ -20,6 +20,32 @@ use super::safe::DepGraphSafe;
 use super::serialized::{SerializedDepGraph, SerializedDepNodeIndex};
 use super::prev::PreviousDepGraph;
 
+pub type WorkProductMap = FxHashMap<WorkProductId, WorkProduct>;
+
+pub enum LoadResult<T> {
+    Ok { data: T },
+    DataOutOfDate,
+    Error { message: String },
+}
+
+/// Either a result that has already be computed or a
+/// handle that will let us wait until it is computed
+/// by a background thread.
+pub enum MaybeAsync<T> {
+    Sync(T),
+    Async(std::thread::JoinHandle<T>)
+}
+impl<T> MaybeAsync<T> {
+    pub fn open(self) -> std::thread::Result<T> {
+        match self {
+            MaybeAsync::Sync(result) => Ok(result),
+            MaybeAsync::Async(handle) => handle.join()
+        }
+    }
+}
+
+pub type DepGraphFuture = MaybeAsync<LoadResult<(PreviousDepGraph, WorkProductMap)>>;
+
 #[derive(Clone)]
 pub struct DepGraph {
     data: Option<Lrc<DepGraphData>>,
@@ -30,7 +56,7 @@ newtype_index! {
 }
 
 impl DepNodeIndex {
-    const INVALID: DepNodeIndex = DepNodeIndex::MAX;
+    pub(crate) const INVALID: DepNodeIndex = DepNodeIndex::MAX;
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
@@ -95,17 +121,29 @@ impl DepGraph {
                prev_work_products: FxHashMap<WorkProductId, WorkProduct>) -> DepGraph {
         let prev_graph_node_count = prev_graph.node_count();
 
+        let mut data = DepGraphData {
+            previous_work_products: prev_work_products,
+            dep_node_debug: Default::default(),
+            current: Lock::new(CurrentDepGraph::new(prev_graph_node_count)),
+            emitted_diagnostics: Default::default(),
+            emitted_diagnostics_cond_var: Condvar::new(),
+            previous: prev_graph,
+            colors: DepNodeColorMap::new(prev_graph_node_count),
+            loaded_from_cache: Default::default(),
+        };
+
+        let non_incr_dep_node = DepNode::new_no_params(DepKind::NonIncremental);
+
+        // Allocate the NonIncremental node
+        data.current.get_mut().alloc_node(non_incr_dep_node, smallvec![], Fingerprint::ZERO);
+
+        data.previous.node_to_index_opt(&non_incr_dep_node).map(|prev_index| {
+            // Color previous NonIncremental node as red
+            data.colors.insert(prev_index, DepNodeColor::Red);
+        });
+
         DepGraph {
-            data: Some(Lrc::new(DepGraphData {
-                previous_work_products: prev_work_products,
-                dep_node_debug: Default::default(),
-                current: Lock::new(CurrentDepGraph::new(prev_graph_node_count)),
-                emitted_diagnostics: Default::default(),
-                emitted_diagnostics_cond_var: Condvar::new(),
-                previous: prev_graph,
-                colors: DepNodeColorMap::new(prev_graph_node_count),
-                loaded_from_cache: Default::default(),
-            })),
+            data: Some(Lrc::new(data)),
         }
     }
 
@@ -136,18 +174,21 @@ impl DepGraph {
         DepGraphQuery::new(&nodes[..], &edges[..])
     }
 
-    pub fn assert_ignored(&self)
-    {
-        if let Some(..) = self.data {
-            ty::tls::with_context_opt(|icx| {
-                let icx = if let Some(icx) = icx { icx } else { return };
-                assert!(icx.task_deps.is_none(), "expected no task dependency tracking");
-            })
-        }
+    pub fn assert_ignored() {
+        ty::tls::with_context_opt(|icx| {
+            let icx = if let Some(icx) = icx { icx } else { return };
+            assert!(icx.task_deps.is_none(), "expected no task dependency tracking");
+        })
     }
 
     pub fn with_ignore<OP,R>(&self, op: OP) -> R
         where OP: FnOnce() -> R
+    {
+        Self::ignore_deps(op)
+    }
+
+    pub fn ignore_deps<OP,R>(op: OP) -> R
+       where OP: FnOnce() -> R
     {
         ty::tls::with_context(|icx| {
             let icx = ty::tls::ImplicitCtxt {
@@ -395,6 +436,16 @@ impl DepGraph {
             hash_result)
     }
 
+    #[inline]
+    pub fn read_non_incr(tcx: TyCtxt<'_, '_, '_>) {
+        // Avoid loading the `dep_graph` here if we don't need to track dependencies.
+        // We want to load the `dep_graph` in the background.
+        if ty::tls::with_context(|icx| icx.task_deps.is_none()) {
+            return;
+        }
+        tcx.dep_graph().read(DepNode::new_no_params(DepKind::NonIncremental));
+    }
+
     #[inline]
     pub fn read(&self, v: DepNode) {
         if let Some(ref data) = self.data {

src/librustc/dep_graph/mod.rs

@@ -11,7 +11,7 @@ pub mod cgu_reuse_tracker;
 pub use self::dep_tracking_map::{DepTrackingMap, DepTrackingMapConfig};
 pub use self::dep_node::{DepNode, DepKind, DepConstructor, WorkProductId, RecoverKey, label_strs};
 pub use self::graph::{DepGraph, WorkProduct, DepNodeIndex, DepNodeColor, TaskDeps, hash_result};
-pub use self::graph::WorkProductFileKind;
+pub use self::graph::{WorkProductFileKind, DepGraphFuture, LoadResult, WorkProductMap, MaybeAsync};
 pub use self::prev::PreviousDepGraph;
 pub use self::query::DepGraphQuery;
 pub use self::safe::AssertDepGraphSafe;

src/librustc/hir/lowering.rs

@@ -212,14 +212,13 @@ impl<'a> ImplTraitContext<'a> {
 pub fn lower_crate(
     sess: &Session,
     cstore: &dyn CrateStore,
-    dep_graph: &DepGraph,
     krate: &Crate,
     resolver: &mut dyn Resolver,
 ) -> hir::Crate {
     // We're constructing the HIR here; we don't care what we will
     // read, since we haven't even constructed the *input* to
     // incr. comp. yet.
-    dep_graph.assert_ignored();
+    DepGraph::assert_ignored();
 
     LoweringContext {
         crate_root: std_inject::injected_crate_name(),

src/librustc/hir/map/hir_id_validator.rs

@@ -1,12 +1,13 @@
 use crate::hir::def_id::{DefId, DefIndex, CRATE_DEF_INDEX};
 use crate::hir::{self, intravisit, HirId, ItemLocalId};
+use crate::dep_graph::DepGraph;
 use syntax::ast::NodeId;
 use crate::hir::itemlikevisit::ItemLikeVisitor;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::sync::{Lock, ParallelIterator, par_iter};
 
 pub fn check_crate<'hir>(hir_map: &hir::map::Map<'hir>) {
-    hir_map.dep_graph.assert_ignored();
+    DepGraph::assert_ignored();
 
     let errors = Lock::new(Vec::new());
 

src/librustc/hir/map/mod.rs

@@ -1244,7 +1244,7 @@ pub fn map_crate<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>) -> Map<'tcx> {
         let mut collector = NodeCollector::root(
             tcx.sess,
             krate,
-            &tcx.dep_graph,
+            &tcx.dep_graph(),
             &hir.defs,
             &hir_to_node_id,
             hcx
@@ -1274,7 +1274,7 @@ pub fn map_crate<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>) -> Map<'tcx> {
 
     let map = Map {
         forest: &hir.forest,
-        dep_graph: tcx.dep_graph.clone(),
+        dep_graph: tcx.dep_graph().clone(),
         crate_hash,
         map,
         hir_to_node_id,

src/librustc/query/mod.rs

@@ -30,6 +30,18 @@ use syntax_pos::symbol::InternedString;
 // as they will raise an fatal error on query cycles instead.
 rustc_queries! {
     Other {
+        query dep_graph_future(_: LocalCrate) -> Lrc<Steal<Option<DepGraphFuture>>> {
+            no_hash
+            eval_always
+            desc { "loading the dependency graph in the background" }
+        }
+
+        query load_dep_graph(_: LocalCrate) -> &'tcx DepGraph {
+            no_hash
+            eval_always
+            desc { "loading the dependency graph" }
+        }
+
         query parse(_: LocalCrate) -> Result<Lrc<Steal<ast::Crate>>, ErrorReported> {
             no_hash
             eval_always
@@ -76,6 +88,13 @@ rustc_queries! {
             desc { "indexing HIR" }
         }
 
+        /// Run analysis passes on the crate
+        query analysis(_: CrateNum) -> Result<(), ErrorReported> {
+            no_hash
+            eval_always
+            desc { "running analysis passes on this crate" }
+        }
+
         /// Records the type of every item.
         query type_of(key: DefId) -> Ty<'tcx> {
             cache { key.is_local() }

src/librustc/traits/select.rs

@@ -1190,10 +1190,9 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
     where
         OP: FnOnce(&mut Self) -> R,
     {
-        let (result, dep_node) = self.tcx()
-            .dep_graph
-            .with_anon_task(DepKind::TraitSelect, || op(self));
-        self.tcx().dep_graph.read_index(dep_node);
+        let dep_graph = self.tcx().dep_graph();
+        let (result, dep_node) = dep_graph.with_anon_task(DepKind::TraitSelect, || op(self));
+        dep_graph.read_index(dep_node);
         (result, dep_node)
     }
 
@@ -3944,7 +3943,7 @@ impl<T: Clone> WithDepNode<T> {
     }
 
     pub fn get(&self, tcx: TyCtxt<'_, '_, '_>) -> T {
-        tcx.dep_graph.read_index(self.dep_node);
+        tcx.dep_graph().read_index(self.dep_node);
         self.cached_value.clone()
     }
 }

src/librustc/ty/context.rs

@@ -1012,7 +1012,10 @@ pub struct GlobalCtxt<'tcx> {
 
     pub sess: &'tcx Session,
 
-    pub dep_graph: DepGraph,
+    pub dep_graph_store: Once<DepGraph>,
+
+    // FIXME: Get rid of the double indirection here
+    dep_graph: AtomicOnce<&'tcx DepGraph>,
 
     /// Common types, pre-interned for your convenience.
     pub types: CommonTypes<'tcx>,
@@ -1082,17 +1085,25 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         self.lowered_hir().def_path_hash_to_def_id.as_ref()
     }
 
+    #[inline(always)]
+    pub fn dep_graph(self) -> &'gcx DepGraph {
+        self.dep_graph.get_or_init(|| {
+            // We shouldn't be tracking dependencies beforing loading the dep graph
+            DepGraph::assert_ignored();
+            self.load_dep_graph(LocalCrate)
+        })
+    }
+
     #[inline(always)]
     pub fn lowered_hir(self) -> &'gcx hir::LoweredHir {
         self.lowered_hir.get_or_init(|| {
-            // FIXME: The ignore here is only sound because all queries
-            // used to compute LoweredHir are eval_always
-            self.dep_graph.with_ignore(|| {
-                let map = self.lower_ast_to_hir(LocalCrate).unwrap();
-                self.lowered_hir.init(map);
-                self.allocate_metadata_dep_nodes();
-                map
-            })
+            // We shouldn't have loaded the dep graph yet here,
+            // so we should not be tracking dependencies.
+            DepGraph::assert_ignored();
+            let map = self.lower_ast_to_hir(LocalCrate).unwrap();
+            self.lowered_hir.init(map);
+            self.allocate_metadata_dep_nodes();
+            map
         })
     }
 
@@ -1104,7 +1115,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     pub fn hir(self) -> &'gcx hir_map::Map<'gcx> {
         self.hir_map.get_or_init(|| {
             // We can use `with_ignore` here because the hir map does its own tracking
-            self.dep_graph.with_ignore(|| self.hir_map(LOCAL_CRATE))
+            DepGraph::ignore_deps(|| self.hir_map(LOCAL_CRATE))
         })
     }
 
@@ -1209,7 +1220,6 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         local_providers: ty::query::Providers<'tcx>,
         extern_providers: ty::query::Providers<'tcx>,
         arenas: &'tcx AllArenas<'tcx>,
-        dep_graph: DepGraph,
         on_disk_query_result_cache: query::OnDiskCache<'tcx>,
         crate_name: Option<String>,
         tx: mpsc::Sender<Box<dyn Any + Send>>,
@@ -1231,7 +1241,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
             sess_rc: s.clone(),
             global_arenas: &arenas.global,
             global_interners: interners,
-            dep_graph,
+            dep_graph: AtomicOnce::new(),
+            dep_graph_store: Once::new(),
             types: common_types,
             lowered_hir: AtomicOnce::new(),
             hir_map: AtomicOnce::new(),
@@ -1400,7 +1411,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     // With full-fledged red/green, the method will probably become unnecessary
     // as this will be done on-demand.
     pub fn allocate_metadata_dep_nodes(self) {
-        if !self.dep_graph.is_fully_enabled() {
+        if !self.dep_graph().is_fully_enabled() {
             return
         }
 
@@ -1410,11 +1421,12 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
             for cnum in self.cstore.crates_untracked() {
                 let dep_node = DepNode::new(self, DepConstructor::CrateMetadata(cnum));
                 let crate_hash = self.cstore.crate_hash_untracked(cnum);
-                self.dep_graph.with_task(dep_node,
-                                        self,
-                                        crate_hash,
-                                        |_, x| x, // No transformation needed
-                                        Some(dep_graph::hash_result),
+                self.dep_graph().with_task(
+                    dep_node,
+                    self,
+                    crate_hash,
+                    |_, x| x, // No transformation needed
+                    Some(dep_graph::hash_result),
                 );
             }
         });