From d00ed018767f5ffb4d17971147fadeb860891f8d Mon Sep 17 00:00:00 2001 From: Aaron Hill Date: Thu, 19 Nov 2020 15:49:45 -0500 Subject: [PATCH] Only create `OnDiskCache` in incremental compilation mode This lets us skip doing useless work when we're not in incremental compilation mode. --- compiler/rustc_incremental/src/persist/load.rs | 15 +++++++++++---- compiler/rustc_macros/src/query.rs | 2 +- compiler/rustc_middle/src/dep_graph/mod.rs | 14 +++++++++++--- compiler/rustc_middle/src/query/mod.rs | 8 ++++---- compiler/rustc_middle/src/ty/context.rs | 4 ++-- compiler/rustc_middle/src/ty/query/plumbing.rs | 7 ++++--- 6 files changed, 33 insertions(+), 17 deletions(-) diff --git a/compiler/rustc_incremental/src/persist/load.rs b/compiler/rustc_incremental/src/persist/load.rs index 578c045a2b4e5..201f381f88940 100644 --- a/compiler/rustc_incremental/src/persist/load.rs +++ b/compiler/rustc_incremental/src/persist/load.rs @@ -199,9 +199,14 @@ pub fn load_dep_graph(sess: &Session) -> DepGraphFuture { })) } -pub fn load_query_result_cache(sess: &Session) -> OnDiskCache<'_> { +/// Attempts to load the query result cache from disk +/// +/// If we are not in incremental compilation mode, returns `None`. +/// Otherwise, tries to load the query result cache from disk, +/// creating an empty cache if it could not be loaded. +pub fn load_query_result_cache(sess: &Session) -> Option> { if sess.opts.incremental.is_none() { - return OnDiskCache::new_empty(sess.source_map()); + return None; } let _prof_timer = sess.prof.generic_activity("incr_comp_load_query_result_cache"); @@ -211,7 +216,9 @@ pub fn load_query_result_cache(sess: &Session) -> OnDiskCache<'_> { &query_cache_path(sess), sess.is_nightly_build(), ) { - LoadResult::Ok { data: (bytes, start_pos) } => OnDiskCache::new(sess, bytes, start_pos), - _ => OnDiskCache::new_empty(sess.source_map()), + LoadResult::Ok { data: (bytes, start_pos) } => { + Some(OnDiskCache::new(sess, bytes, start_pos)) + } + _ => Some(OnDiskCache::new_empty(sess.source_map())), } } diff --git a/compiler/rustc_macros/src/query.rs b/compiler/rustc_macros/src/query.rs index fd85919636949..12990ae2d94a5 100644 --- a/compiler/rustc_macros/src/query.rs +++ b/compiler/rustc_macros/src/query.rs @@ -353,7 +353,7 @@ fn add_query_description_impl( tcx: TyCtxt<'tcx>, id: SerializedDepNodeIndex ) -> Option { - tcx.queries.on_disk_cache.try_load_query_result(tcx, id) + tcx.queries.on_disk_cache.as_ref().and_then(|c| c.try_load_query_result(tcx, id)) } } }; diff --git a/compiler/rustc_middle/src/dep_graph/mod.rs b/compiler/rustc_middle/src/dep_graph/mod.rs index 6697524279874..a85b66b65daac 100644 --- a/compiler/rustc_middle/src/dep_graph/mod.rs +++ b/compiler/rustc_middle/src/dep_graph/mod.rs @@ -164,11 +164,17 @@ impl<'tcx> DepContext for TyCtxt<'tcx> { } fn load_diagnostics(&self, prev_dep_node_index: SerializedDepNodeIndex) -> Vec { - self.queries.on_disk_cache.load_diagnostics(*self, prev_dep_node_index) + self.queries + .on_disk_cache + .as_ref() + .map(|c| c.load_diagnostics(*self, prev_dep_node_index)) + .unwrap_or_default() } fn store_diagnostics(&self, dep_node_index: DepNodeIndex, diagnostics: ThinVec) { - self.queries.on_disk_cache.store_diagnostics(dep_node_index, diagnostics) + if let Some(c) = self.queries.on_disk_cache.as_ref() { + c.store_diagnostics(dep_node_index, diagnostics) + } } fn store_diagnostics_for_anon_node( @@ -176,7 +182,9 @@ impl<'tcx> DepContext for TyCtxt<'tcx> { dep_node_index: DepNodeIndex, diagnostics: ThinVec, ) { - self.queries.on_disk_cache.store_diagnostics_for_anon_node(dep_node_index, diagnostics) + if let Some(c) = self.queries.on_disk_cache.as_ref() { + c.store_diagnostics_for_anon_node(dep_node_index, diagnostics) + } } fn profiler(&self) -> &SelfProfilerRef { diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs index 634d50368bd88..175b108dd24d4 100644 --- a/compiler/rustc_middle/src/query/mod.rs +++ b/compiler/rustc_middle/src/query/mod.rs @@ -130,8 +130,8 @@ rustc_queries! { storage(ArenaCacheSelector<'tcx>) cache_on_disk_if { key.is_local() } load_cached(tcx, id) { - let generics: Option = tcx.queries.on_disk_cache - .try_load_query_result(tcx, id); + let generics: Option = tcx.queries.on_disk_cache.as_ref() + .and_then(|c| c.try_load_query_result(tcx, id)); generics } } @@ -688,8 +688,8 @@ rustc_queries! { cache_on_disk_if { true } load_cached(tcx, id) { let typeck_results: Option> = tcx - .queries.on_disk_cache - .try_load_query_result(tcx, id); + .queries.on_disk_cache.as_ref() + .and_then(|c| c.try_load_query_result(tcx, id)); typeck_results.map(|x| &*tcx.arena.alloc(x)) } diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs index 36cbd36a7705f..82acca403db67 100644 --- a/compiler/rustc_middle/src/ty/context.rs +++ b/compiler/rustc_middle/src/ty/context.rs @@ -1094,7 +1094,7 @@ impl<'tcx> TyCtxt<'tcx> { krate: &'tcx hir::Crate<'tcx>, definitions: &'tcx Definitions, dep_graph: DepGraph, - on_disk_query_result_cache: query::OnDiskCache<'tcx>, + on_disk_query_result_cache: Option>, crate_name: &str, output_filenames: &OutputFilenames, ) -> GlobalCtxt<'tcx> { @@ -1343,7 +1343,7 @@ impl<'tcx> TyCtxt<'tcx> { where E: ty::codec::OpaqueEncoder, { - self.queries.on_disk_cache.serialize(self, encoder) + self.queries.on_disk_cache.as_ref().map(|c| c.serialize(self, encoder)).unwrap_or(Ok(())) } /// If `true`, we should use the MIR-based borrowck, but also diff --git a/compiler/rustc_middle/src/ty/query/plumbing.rs b/compiler/rustc_middle/src/ty/query/plumbing.rs index d038695283c10..9e97ed2fb2926 100644 --- a/compiler/rustc_middle/src/ty/query/plumbing.rs +++ b/compiler/rustc_middle/src/ty/query/plumbing.rs @@ -507,10 +507,11 @@ macro_rules! define_queries_struct { (tcx: $tcx:tt, input: ($(([$($modifiers:tt)*] [$($attr:tt)*] [$name:ident]))*)) => { pub struct Queries<$tcx> { - /// This provides access to the incrimental comilation on-disk cache for query results. + /// This provides access to the incremental comilation on-disk cache for query results. /// Do not access this directly. It is only meant to be used by /// `DepGraph::try_mark_green()` and the query infrastructure. - pub(crate) on_disk_cache: OnDiskCache<'tcx>, + /// This is `None` if we are not incremental compilation mode + pub(crate) on_disk_cache: Option>, providers: IndexVec, fallback_extern_providers: Box, @@ -526,7 +527,7 @@ macro_rules! define_queries_struct { pub(crate) fn new( providers: IndexVec, fallback_extern_providers: Providers, - on_disk_cache: OnDiskCache<'tcx>, + on_disk_cache: Option>, ) -> Self { Queries { providers,