Unverified Commit b933d3dc authored by Benjamin Woodruff's avatar Benjamin Woodruff Committed by GitHub

Turbopack: Remove tokio and turbo-task handles from Invalidator (#88242)

We may have many `Invalidator`s, and we're often looping over collections of them. Instead of storing a weak reference to `TurboTasksApi` and tokio's `Handle` inside of `Invalidator`, it's better for the callsite to track this.

`Weak<dyn TurboTasksApi>` and `Handle` are both 16-byte fat pointers, and there's some alignment overhead, so **this reduces the size of Invalidator from 40 bytes to 4 bytes** (according to RA), and reduces the number of refcount increment/decrements we have to do when using invalidators.  
  
These changes were LLM-generated, with careful manual review and cleanup.
parent d044c554
......@@ -5,7 +5,7 @@
use std::{collections::HashSet, mem::take, sync::Mutex};
use anyhow::Result;
use turbo_tasks::{Invalidator, ReadRef, Vc, get_invalidator};
use turbo_tasks::{Invalidator, ReadRef, Vc, get_invalidator, with_turbo_tasks};
use turbo_tasks_testing::{Registration, register, run_once};
static REGISTRATION: Registration = register!();
......@@ -60,11 +60,14 @@ struct Counter {
impl Counter {
fn incr(&self) {
let mut lock = self.value.lock().unwrap();
lock.0 += 1;
for i in take(&mut lock.1) {
i.invalidate();
}
with_turbo_tasks(|tt| {
let mut lock = self.value.lock().unwrap();
lock.0 += 1;
let invalidators = take(&mut lock.1);
for i in invalidators {
i.invalidate(&**tt);
}
});
}
}
......
......@@ -5,7 +5,7 @@
use std::{collections::HashSet, mem::take, sync::Mutex};
use anyhow::Result;
use turbo_tasks::{IntoTraitRef, Invalidator, TraitRef, Vc, get_invalidator};
use turbo_tasks::{IntoTraitRef, Invalidator, TraitRef, Vc, get_invalidator, with_turbo_tasks};
use turbo_tasks_testing::{Registration, register, run_once};
static REGISTRATION: Registration = register!();
......@@ -69,11 +69,14 @@ struct Counter {
impl Counter {
fn incr(&self) {
let mut lock = self.value.lock().unwrap();
lock.0 += 1;
for i in take(&mut lock.1) {
i.invalidate();
}
with_turbo_tasks(|tt| {
let mut lock = self.value.lock().unwrap();
lock.0 += 1;
let invalidators = take(&mut lock.1);
for i in invalidators {
i.invalidate(&**tt);
}
});
}
}
......
......@@ -41,7 +41,7 @@ use std::{
io::{self, BufRead, BufReader, ErrorKind, Read},
mem::take,
path::{MAIN_SEPARATOR, Path, PathBuf},
sync::{Arc, LazyLock},
sync::{Arc, LazyLock, Weak},
time::Duration,
};
......@@ -55,13 +55,16 @@ use jsonc_parser::{ParseOptions, parse_to_serde_value};
use mime::Mime;
use rustc_hash::FxHashSet;
use serde_json::Value;
use tokio::sync::{RwLock, RwLockReadGuard};
use tokio::{
runtime::Handle,
sync::{RwLock, RwLockReadGuard},
};
use tracing::Instrument;
use turbo_rcstr::{RcStr, rcstr};
use turbo_tasks::{
ApplyEffectsContext, Completion, InvalidationReason, Invalidator, NonLocalValue, ReadRef,
ResolvedVc, TaskInput, ValueToString, Vc, debug::ValueDebugFormat, effect,
mark_session_dependent, mark_stateful, parallel, trace::TraceRawVcs,
ResolvedVc, TaskInput, TurboTasksApi, ValueToString, Vc, debug::ValueDebugFormat, effect,
mark_session_dependent, mark_stateful, parallel, trace::TraceRawVcs, turbo_tasks_weak,
};
use turbo_tasks_hash::{DeterministicHash, DeterministicHasher, hash_xxh3_hash64};
use turbo_unix_path::{
......@@ -288,6 +291,15 @@ struct DiskFileSystemInner {
/// Root paths that we do not allow access to from this filesystem.
/// Useful for things like output directories to prevent accidental ouroboros situations.
denied_paths: Vec<RcStr>,
/// Used by invalidators when called from a non-turbo-tasks thread, specifically in the fs
/// watcher.
#[turbo_tasks(debug_ignore, trace_ignore)]
#[bincode(skip, default = "turbo_tasks_weak")]
turbo_tasks: Weak<dyn TurboTasksApi>,
/// Used by invalidators when called from a non-tokio thread, specifically in the fs watcher.
#[turbo_tasks(debug_ignore, trace_ignore)]
#[bincode(skip, default = "Handle::current")]
tokio_handle: Handle,
}
impl DiskFileSystemInner {
......@@ -371,6 +383,11 @@ impl DiskFileSystemInner {
fn invalidate(&self) {
let _span = tracing::info_span!("invalidate filesystem", name = &*self.root).entered();
let Some(turbo_tasks) = self.turbo_tasks.upgrade() else {
return;
};
let _guard = self.tokio_handle.enter();
let invalidator_map = take(&mut *self.invalidator_map.lock().unwrap());
let dir_invalidator_map = take(&mut *self.dir_invalidator_map.lock().unwrap());
let invalidators = invalidator_map
......@@ -378,7 +395,9 @@ impl DiskFileSystemInner {
.chain(dir_invalidator_map)
.flat_map(|(_, invalidators)| invalidators.into_keys())
.collect::<Vec<_>>();
parallel::for_each_owned(invalidators, |invalidator| invalidator.invalidate());
parallel::for_each_owned(invalidators, |invalidator| {
invalidator.invalidate(&*turbo_tasks)
});
}
/// Invalidates every tracked file in the filesystem.
......@@ -389,6 +408,11 @@ impl DiskFileSystemInner {
reason: impl Fn(&Path) -> R + Sync,
) {
let _span = tracing::info_span!("invalidate filesystem", name = &*self.root).entered();
let Some(turbo_tasks) = self.turbo_tasks.upgrade() else {
return;
};
let _guard = self.tokio_handle.enter();
let invalidator_map = take(&mut *self.invalidator_map.lock().unwrap());
let dir_invalidator_map = take(&mut *self.dir_invalidator_map.lock().unwrap());
let invalidators = invalidator_map
......@@ -402,7 +426,7 @@ impl DiskFileSystemInner {
})
.collect::<Vec<_>>();
parallel::for_each_owned(invalidators, |(reason, invalidator)| {
invalidator.invalidate_with_reason(reason)
invalidator.invalidate_with_reason(&*turbo_tasks, reason)
});
}
......@@ -412,18 +436,24 @@ impl DiskFileSystemInner {
invalidators: Vec<(Invalidator, Option<WriteContent>)>,
) {
if !invalidators.is_empty() {
let Some(turbo_tasks) = self.turbo_tasks.upgrade() else {
return;
};
let _guard = self.tokio_handle.enter();
if let Some(path) = format_absolute_fs_path(full_path, &self.name, self.root_path()) {
if invalidators.len() == 1 {
let (invalidator, _) = invalidators.into_iter().next().unwrap();
invalidator.invalidate_with_reason(Write { path });
invalidator.invalidate_with_reason(&*turbo_tasks, Write { path });
} else {
invalidators.into_iter().for_each(|(invalidator, _)| {
invalidator.invalidate_with_reason(Write { path: path.clone() });
invalidator
.invalidate_with_reason(&*turbo_tasks, Write { path: path.clone() });
});
}
} else {
invalidators.into_iter().for_each(|(invalidator, _)| {
invalidator.invalidate();
invalidator.invalidate(&*turbo_tasks);
});
}
}
......@@ -648,6 +678,8 @@ impl DiskFileSystem {
write_semaphore: create_write_semaphore(),
watcher: DiskWatcher::new(),
denied_paths,
turbo_tasks: turbo_tasks_weak(),
tokio_handle: Handle::current(),
}),
};
......
......@@ -21,8 +21,8 @@ use rustc_hash::FxHashSet;
use tracing::instrument;
use turbo_rcstr::RcStr;
use turbo_tasks::{
FxIndexSet, InvalidationReason, InvalidationReasonKind, Invalidator, parallel, spawn_thread,
util::StaticOrArc,
FxIndexSet, InvalidationReason, InvalidationReasonKind, Invalidator, TurboTasksApi, parallel,
spawn_thread, util::StaticOrArc,
};
use crate::{
......@@ -401,8 +401,9 @@ impl DiskWatcher {
// side-effect, this will call `ensure_watched` again, setting up any watchers needed.
//
// Best is to start_watching before starting to read
{
if let Some(turbo_tasks) = fs_inner.turbo_tasks.upgrade() {
let _span = tracing::info_span!("invalidate filesystem").entered();
let _guard = fs_inner.tokio_handle.enter();
let invalidator_map = take(&mut *fs_inner.invalidator_map.lock().unwrap());
let dir_invalidator_map = take(&mut *fs_inner.dir_invalidator_map.lock().unwrap());
let iter = invalidator_map.into_iter().chain(dir_invalidator_map);
......@@ -418,14 +419,14 @@ impl DiskWatcher {
})
.collect::<Vec<_>>();
parallel::for_each_owned(invalidators, |(reason, (invalidator, _))| {
invalidator.invalidate_with_reason(reason);
invalidator.invalidate_with_reason(&*turbo_tasks, reason);
});
} else {
let invalidators = iter
.flat_map(|(_, invalidators)| invalidators.into_keys())
.collect::<Vec<_>>();
parallel::for_each_owned(invalidators, |invalidator| {
invalidator.invalidate();
invalidator.invalidate(&*turbo_tasks);
});
}
}
......@@ -688,17 +689,25 @@ impl DiskWatcher {
}
}
let Some(turbo_tasks) = fs_inner.turbo_tasks.upgrade() else {
// TurboTasks was dropped, stop watching
break 'outer;
};
let _guard = fs_inner.tokio_handle.enter();
let _lock = fs_inner.invalidation_lock.blocking_write();
{
let mut invalidator_map = fs_inner.invalidator_map.lock().unwrap();
invalidate_path(
&fs_inner,
&*turbo_tasks,
report_invalidation_reason,
&mut invalidator_map,
batched_invalidate_path.drain(),
);
invalidate_path_and_children_execute(
&fs_inner,
&*turbo_tasks,
report_invalidation_reason,
&mut invalidator_map,
batched_invalidate_path_and_children.drain(),
......@@ -708,12 +717,14 @@ impl DiskWatcher {
let mut dir_invalidator_map = fs_inner.dir_invalidator_map.lock().unwrap();
invalidate_path(
&fs_inner,
&*turbo_tasks,
report_invalidation_reason,
&mut dir_invalidator_map,
batched_invalidate_path_dir.drain(),
);
invalidate_path_and_children_execute(
&fs_inner,
&*turbo_tasks,
report_invalidation_reason,
&mut dir_invalidator_map,
batched_invalidate_path_and_children_dir.drain(),
......@@ -751,6 +762,7 @@ impl DiskWatcher {
)]
fn invalidate(
inner: &DiskFileSystemInner,
turbo_tasks: &dyn TurboTasksApi,
report_invalidation_reason: bool,
path: &Path,
invalidator: Invalidator,
......@@ -758,38 +770,40 @@ fn invalidate(
if report_invalidation_reason
&& let Some(path) = format_absolute_fs_path(path, &inner.name, inner.root_path())
{
invalidator.invalidate_with_reason(WatchChange { path });
invalidator.invalidate_with_reason(turbo_tasks, WatchChange { path });
return;
}
invalidator.invalidate();
invalidator.invalidate(turbo_tasks);
}
fn invalidate_path(
inner: &DiskFileSystemInner,
turbo_tasks: &dyn TurboTasksApi,
report_invalidation_reason: bool,
invalidator_map: &mut LockedInvalidatorMap,
paths: impl Iterator<Item = PathBuf>,
) {
for path in paths {
if let Some(invalidators) = invalidator_map.remove(&path) {
invalidators
.into_iter()
.for_each(|(i, _)| invalidate(inner, report_invalidation_reason, &path, i));
invalidators.into_iter().for_each(|(i, _)| {
invalidate(inner, turbo_tasks, report_invalidation_reason, &path, i)
});
}
}
}
fn invalidate_path_and_children_execute(
inner: &DiskFileSystemInner,
turbo_tasks: &dyn TurboTasksApi,
report_invalidation_reason: bool,
invalidator_map: &mut LockedInvalidatorMap,
paths: impl Iterator<Item = PathBuf>,
) {
for path in paths {
for (_, invalidators) in invalidator_map.extract_path_with_children(&path) {
invalidators
.into_iter()
.for_each(|(i, _)| invalidate(inner, report_invalidation_reason, &path, i));
invalidators.into_iter().for_each(|(i, _)| {
invalidate(inner, turbo_tasks, report_invalidation_reason, &path, i)
});
}
}
}
......
use std::{
fmt::Display,
hash::Hash,
mem::replace,
sync::{Arc, Weak},
};
use std::{fmt::Display, mem::replace, sync::Arc};
use anyhow::Result;
use bincode::{
Decode, Encode,
de::Decoder,
enc::Encoder,
error::{DecodeError, EncodeError},
impl_borrow_decode,
};
use bincode::{Decode, Encode};
use indexmap::map::Entry;
use tokio::runtime::Handle;
use turbo_dyn_eq_hash::{
DynEq, DynHash, impl_eq_for_dyn, impl_hash_for_dyn, impl_partial_eq_for_dyn,
};
use crate::{
FxIndexMap, FxIndexSet, TaskId, TurboTasksApi,
manager::{current_task_if_available, mark_invalidator, with_turbo_tasks},
manager::{current_task_if_available, mark_invalidator},
trace::TraceRawVcs,
util::StaticOrArc,
};
......@@ -32,104 +19,53 @@ use crate::{
pub fn get_invalidator() -> Option<Invalidator> {
if let Some(task) = current_task_if_available("turbo_tasks::get_invalidator()") {
mark_invalidator();
let handle = Handle::current();
Some(Invalidator {
task,
turbo_tasks: with_turbo_tasks(Arc::downgrade),
handle,
})
Some(Invalidator { task })
} else {
None
}
}
/// A lightweight handle to invalidate a task. Only stores the task ID.
/// The caller must provide the `TurboTasksApi` when calling invalidation methods.
#[derive(Clone, Copy, Hash, PartialEq, Eq, Encode, Decode)]
pub struct Invalidator {
task: TaskId,
turbo_tasks: Weak<dyn TurboTasksApi>,
handle: Handle,
}
impl Invalidator {
pub fn invalidate(self) {
let Invalidator {
task,
turbo_tasks,
handle,
} = self;
let _guard = handle.enter();
if let Some(turbo_tasks) = turbo_tasks.upgrade() {
turbo_tasks.invalidate(task);
}
}
pub fn invalidate_with_reason<T: InvalidationReason>(self, reason: T) {
let Invalidator {
task,
turbo_tasks,
handle,
} = self;
let _guard = handle.enter();
if let Some(turbo_tasks) = turbo_tasks.upgrade() {
turbo_tasks.invalidate_with_reason(
task,
(Arc::new(reason) as Arc<dyn InvalidationReason>).into(),
);
}
}
pub fn invalidate_with_static_reason<T: InvalidationReason>(self, reason: &'static T) {
let Invalidator {
task,
turbo_tasks,
handle,
} = self;
let _guard = handle.enter();
if let Some(turbo_tasks) = turbo_tasks.upgrade() {
turbo_tasks
.invalidate_with_reason(task, (reason as &'static dyn InvalidationReason).into());
}
pub fn invalidate(self, turbo_tasks: &dyn TurboTasksApi) {
turbo_tasks.invalidate(self.task);
}
}
impl Hash for Invalidator {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
self.task.hash(state);
pub fn invalidate_with_reason<T: InvalidationReason>(
self,
turbo_tasks: &dyn TurboTasksApi,
reason: T,
) {
turbo_tasks.invalidate_with_reason(
self.task,
(Arc::new(reason) as Arc<dyn InvalidationReason>).into(),
);
}
}
impl PartialEq for Invalidator {
fn eq(&self, other: &Self) -> bool {
self.task == other.task
pub fn invalidate_with_static_reason<T: InvalidationReason>(
self,
turbo_tasks: &dyn TurboTasksApi,
reason: &'static T,
) {
turbo_tasks.invalidate_with_reason(
self.task,
(reason as &'static dyn InvalidationReason).into(),
);
}
}
impl Eq for Invalidator {}
impl TraceRawVcs for Invalidator {
fn trace_raw_vcs(&self, _context: &mut crate::trace::TraceRawVcsContext) {
// nothing here
}
}
impl Encode for Invalidator {
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
Encode::encode(&self.task, encoder)
}
}
impl<Context> Decode<Context> for Invalidator {
fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
Ok(Invalidator {
task: Decode::decode(decoder)?,
turbo_tasks: with_turbo_tasks(Arc::downgrade),
handle: tokio::runtime::Handle::current(),
})
}
}
impl_borrow_decode!(Invalidator);
/// A user-facing reason why a task was invalidated. This should only be used
/// for invalidation that were triggered by the user.
///
......
......@@ -113,7 +113,8 @@ pub use crate::{
CurrentCellRef, ReadConsistency, ReadTracking, TaskPersistence, TurboTasks, TurboTasksApi,
TurboTasksBackendApi, TurboTasksCallApi, Unused, UpdateInfo, dynamic_call, emit,
mark_finished, mark_root, mark_session_dependent, mark_stateful, prevent_gc, run, run_once,
run_once_with_reason, trait_call, turbo_tasks, turbo_tasks_scope,
run_once_with_reason, trait_call, turbo_tasks, turbo_tasks_scope, turbo_tasks_weak,
with_turbo_tasks,
},
output::OutputContent,
raw_vc::{CellId, RawVc, ReadRawVcFuture, ResolveTypeError},
......
......@@ -1593,6 +1593,10 @@ pub fn turbo_tasks() -> Arc<dyn TurboTasksApi> {
TURBO_TASKS.with(|arc| arc.clone())
}
pub fn turbo_tasks_weak() -> Weak<dyn TurboTasksApi> {
TURBO_TASKS.with(Arc::downgrade)
}
pub fn try_turbo_tasks() -> Option<Arc<dyn TurboTasksApi>> {
TURBO_TASKS.try_with(|arc| arc.clone()).ok()
}
......
......@@ -11,8 +11,8 @@ use parking_lot::{Mutex, MutexGuard};
use tracing::trace_span;
use crate::{
Invalidator, OperationValue, SerializationInvalidator, get_invalidator, mark_session_dependent,
mark_stateful, trace::TraceRawVcs,
Invalidator, OperationValue, SerializationInvalidator, get_invalidator,
manager::with_turbo_tasks, mark_session_dependent, mark_stateful, trace::TraceRawVcs,
};
#[derive(Encode, Decode)]
......@@ -36,8 +36,13 @@ impl<T> StateInner<T> {
pub fn set_unconditionally(&mut self, value: T) {
self.value = value;
let _span = trace_span!("state value changed", value_type = type_name::<T>()).entered();
for invalidator in take(&mut self.invalidators) {
invalidator.invalidate();
let invalidators = take(&mut self.invalidators);
if !invalidators.is_empty() {
with_turbo_tasks(|tt| {
for invalidator in invalidators {
invalidator.invalidate(&**tt);
}
});
}
}
......@@ -46,8 +51,13 @@ impl<T> StateInner<T> {
return false;
}
let _span = trace_span!("state value changed", value_type = type_name::<T>()).entered();
for invalidator in take(&mut self.invalidators) {
invalidator.invalidate();
let invalidators = take(&mut self.invalidators);
if !invalidators.is_empty() {
with_turbo_tasks(|tt| {
for invalidator in invalidators {
invalidator.invalidate(&**tt);
}
});
}
true
}
......@@ -60,8 +70,13 @@ impl<T: PartialEq> StateInner<T> {
}
let _span = trace_span!("state value changed", value_type = type_name::<T>()).entered();
self.value = value;
for invalidator in take(&mut self.invalidators) {
invalidator.invalidate();
let invalidators = take(&mut self.invalidators);
if !invalidators.is_empty() {
with_turbo_tasks(|tt| {
for invalidator in invalidators {
invalidator.invalidate(&**tt);
}
});
}
true
}
......@@ -92,8 +107,13 @@ impl<T> Drop for StateRef<'_, T> {
fn drop(&mut self) {
if self.mutated {
let _span = trace_span!("state value changed", value_type = type_name::<T>()).entered();
for invalidator in take(&mut self.inner.invalidators) {
invalidator.invalidate();
let invalidators = take(&mut self.inner.invalidators);
if !invalidators.is_empty() {
with_turbo_tasks(|tt| {
for invalidator in invalidators {
invalidator.invalidate(&**tt);
}
});
}
if let Some(serialization_invalidator) = self.serialization_invalidator {
serialization_invalidator.invalidate();
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment