bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Unify with_task functions.

Browse source 
Remove with_eval_always_task.
This commit is contained in:
Camille GILLOT 2021-01-06 19:06:34 +01:00
parent f2c8707abb
commit eeb3c8f4b7
2 changed files with 78 additions and 105 deletions
Download patch file Download diff file Expand all files Collapse all files

73
compiler/rustc_query_system/src/dep_graph/graph.rs
View file

@ -215,24 +215,17 @@ impl<K: DepKind> DepGraph<K> {
cx: Ctxt,
arg: A,
task: fn(Ctxt, A) -> R,
hash_result: impl FnOnce(&mut Ctxt::StableHashingContext, &R) -> Option<Fingerprint>,
hash_result: fn(&mut Ctxt::StableHashingContext, &R) -> Option<Fingerprint>,
) -> (R, DepNodeIndex) {
self.with_task_impl(
key,
cx,
arg,
task,
|_key| {
Some(TaskDeps {
#[cfg(debug_assertions)]
node: Some(_key),
reads: SmallVec::new(),
read_set: Default::default(),
phantom_data: PhantomData,
})
},
hash_result,
)
if self.is_fully_enabled() {
self.with_task_impl(key, cx, arg, task, hash_result)
} else {
// Incremental compilation is turned off. We just execute the task
// without tracking. We still provide a dep-node index that uniquely
// identifies the task so that we have a cheap way of referring to
// the query for self-profiling.
(task(cx, arg), self.next_virtual_depnode_index())
}
}
fn with_task_impl<Ctxt: HasDepContext<DepKind = K>, A: Debug, R>(
@ -241,10 +234,11 @@ impl<K: DepKind> DepGraph<K> {
cx: Ctxt,
arg: A,
task: fn(Ctxt, A) -> R,
create_task: fn(DepNode<K>) -> Option<TaskDeps<K>>,
hash_result: impl FnOnce(&mut Ctxt::StableHashingContext, &R) -> Option<Fingerprint>,
hash_result: fn(&mut Ctxt::StableHashingContext, &R) -> Option<Fingerprint>,
) -> (R, DepNodeIndex) {
if let Some(ref data) = self.data {
// This function is only called when the graph is enabled.
let data = self.data.as_ref().unwrap();
// If the following assertion triggers, it can have two reasons:
// 1. Something is wrong with DepNode creation, either here or
// in `DepGraph::try_mark_green()`.
@ -259,11 +253,21 @@ impl<K: DepKind> DepGraph<K> {
key
);
let dcx = cx.dep_context();
let task_deps = create_task(key).map(Lock::new);
let task_deps = if key.kind.is_eval_always() {
None
} else {
Some(Lock::new(TaskDeps {
#[cfg(debug_assertions)]
node: Some(key),
reads: SmallVec::new(),
read_set: Default::default(),
phantom_data: PhantomData,
}))
};
let result = K::with_deps(task_deps.as_ref(), || task(cx, arg));
let edges = task_deps.map_or_else(|| smallvec![], |lock| lock.into_inner().reads);
let dcx = cx.dep_context();
let mut hcx = dcx.create_stable_hashing_context();
let hashing_timer = dcx.profiler().incr_result_hashing();
let current_fingerprint = hash_result(&mut hcx, &result);
@ -271,9 +275,8 @@ impl<K: DepKind> DepGraph<K> {
let print_status = cfg!(debug_assertions) && dcx.sess().opts.debugging_opts.dep_tasks;
// Get timer for profiling `DepNode` interning
let node_intern_timer = self
.node_intern_event_id
.map(|eid| dcx.profiler().generic_activity_with_event_id(eid));
let node_intern_timer =
self.node_intern_event_id.map(|eid| dcx.profiler().generic_activity_with_event_id(eid));
// Intern the new `DepNode`.
let (dep_node_index, prev_and_color) = data.current.intern_node(
dcx.profiler(),
@ -299,13 +302,6 @@ impl<K: DepKind> DepGraph<K> {
}
(result, dep_node_index)
} else {
// Incremental compilation is turned off. We just execute the task
// without tracking. We still provide a dep-node index that uniquely
// identifies the task so that we have a cheap way of referring to
// the query for self-profiling.
(task(cx, arg), self.next_virtual_depnode_index())
}
}
/// Executes something within an "anonymous" task, that is, a task the
@ -372,19 +368,6 @@ impl<K: DepKind> DepGraph<K> {
}
}
/// Executes something within an "eval-always" task which is a task
/// that runs whenever anything changes.
pub fn with_eval_always_task<Ctxt: HasDepContext<DepKind = K>, A: Debug, R>(
&self,
key: DepNode<K>,
cx: Ctxt,
arg: A,
task: fn(Ctxt, A) -> R,
hash_result: impl FnOnce(&mut Ctxt::StableHashingContext, &R) -> Option<Fingerprint>,
) -> (R, DepNodeIndex) {
self.with_task_impl(key, cx, arg, task, |_| None, hash_result)
}
#[inline]
pub fn read_index(&self, dep_node_index: DepNodeIndex) {
if let Some(ref data) = self.data {

10
compiler/rustc_query_system/src/query/plumbing.rs
View file

@ -491,15 +491,6 @@ where
// `to_dep_node` is expensive for some `DepKind`s.
let dep_node = dep_node_opt.unwrap_or_else(|| query.to_dep_node(*tcx.dep_context(), &key));
if query.eval_always {
tcx.dep_context().dep_graph().with_eval_always_task(
dep_node,
*tcx.dep_context(),
key,
compute,
query.hash_result,
)
} else {
tcx.dep_context().dep_graph().with_task(
dep_node,
*tcx.dep_context(),
@ -507,7 +498,6 @@ where
compute,
query.hash_result,
)
}
});
prof_timer.finish_with_query_invocation_id(dep_node_index.into());