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