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

refactor(turbo-tasks): Use an enum for `strongly_consistent`/`ReadConsistency`…

refactor(turbo-tasks): Use an enum for `strongly_consistent`/`ReadConsistency` instead of a bool (#68913)

This should be completely equivalent. Double checked the diff and made sure that the conversions from `true`/`false` to `ReadConsistency::Strong`/`ReadConsistency::Eventual` are correct.

## Why?

Without keyword arguments in the language, boolean arguments can be hard to read. Inlay hints and type-signature-on-hover with rust-analyzer help, but it's more obvious what these do if they use a clearly labeled enum.

E.g. discussion: https://www.reddit.com/r/rust/comments/bm6s3t/rust_patterns_enums_instead_of_booleans/

Unlike my other change from a bool to an enum in #68866, I don't expect that we'd ever introduce more levels of read consistency than eventual and strong, so this PR is only about readability.
parent 3bff1012
...@@ -10,7 +10,7 @@ use next_api::{ ...@@ -10,7 +10,7 @@ use next_api::{
project::{ProjectContainer, ProjectOptions}, project::{ProjectContainer, ProjectOptions},
route::{Endpoint, Route}, route::{Endpoint, Route},
}; };
use turbo_tasks::{RcStr, TransientInstance, TurboTasks, Vc}; use turbo_tasks::{RcStr, ReadConsistency, TransientInstance, TurboTasks, Vc};
use turbo_tasks_malloc::TurboMalloc; use turbo_tasks_malloc::TurboMalloc;
use turbo_tasks_memory::MemoryBackend; use turbo_tasks_memory::MemoryBackend;
...@@ -261,7 +261,8 @@ async fn hmr(tt: &TurboTasks<MemoryBackend>, project: Vc<ProjectContainer>) -> R ...@@ -261,7 +261,8 @@ async fn hmr(tt: &TurboTasks<MemoryBackend>, project: Vc<ProjectContainer>) -> R
Ok(Vc::<()>::cell(())) Ok(Vc::<()>::cell(()))
} }
}); });
tt.wait_task_completion(task, true).await?; tt.wait_task_completion(task, ReadConsistency::Strong)
.await?;
let e = start.elapsed(); let e = start.elapsed();
if e.as_millis() > 10 { if e.as_millis() > 10 {
tracing::info!("HMR: {:?} {:?}", ident, e); tracing::info!("HMR: {:?} {:?}", ident, e);
......
...@@ -22,8 +22,8 @@ use serde::Deserialize; ...@@ -22,8 +22,8 @@ use serde::Deserialize;
use serde::Serialize; use serde::Serialize;
use tokio::sync::mpsc::channel; use tokio::sync::mpsc::channel;
use turbo_tasks::{ use turbo_tasks::{
backend::Backend, util::FormatDuration, RcStr, TaskId, TransientInstance, TransientValue, backend::Backend, util::FormatDuration, RcStr, ReadConsistency, TaskId, TransientInstance,
TurboTasks, UpdateInfo, Value, Vc, TransientValue, TurboTasks, UpdateInfo, Value, Vc,
}; };
use turbo_tasks_fs::{ use turbo_tasks_fs::{
glob::Glob, DirectoryEntry, DiskFileSystem, FileSystem, FileSystemPath, ReadGlobResult, glob::Glob, DirectoryEntry, DiskFileSystem, FileSystem, FileSystemPath, ReadGlobResult,
...@@ -407,7 +407,10 @@ async fn run<B: Backend + 'static, F: Future<Output = ()>>( ...@@ -407,7 +407,10 @@ async fn run<B: Backend + 'static, F: Future<Output = ()>>(
let start = Instant::now(); let start = Instant::now();
let finish = |tt: Arc<TurboTasks<B>>, root_task: TaskId| async move { let finish = |tt: Arc<TurboTasks<B>>, root_task: TaskId| async move {
if watch { if watch {
if let Err(e) = tt.wait_task_completion(root_task, true).await { if let Err(e) = tt
.wait_task_completion(root_task, ReadConsistency::Strong)
.await
{
println!("{}", e); println!("{}", e);
} }
let UpdateInfo { let UpdateInfo {
...@@ -431,7 +434,9 @@ async fn run<B: Backend + 'static, F: Future<Output = ()>>( ...@@ -431,7 +434,9 @@ async fn run<B: Backend + 'static, F: Future<Output = ()>>(
println!("updated {} tasks in {}", tasks, FormatDuration(duration)); println!("updated {} tasks in {}", tasks, FormatDuration(duration));
} }
} else { } else {
let result = tt.wait_task_completion(root_task, true).await; let result = tt
.wait_task_completion(root_task, ReadConsistency::Strong)
.await;
let dur = start.elapsed(); let dur = start.elapsed();
let UpdateInfo { let UpdateInfo {
duration, tasks, .. duration, tasks, ..
......
...@@ -9,7 +9,7 @@ use std::{ ...@@ -9,7 +9,7 @@ use std::{
use anyhow::Result; use anyhow::Result;
use sha2::{Digest, Sha256}; use sha2::{Digest, Sha256};
use turbo_tasks::{util::FormatDuration, RcStr, TurboTasks, UpdateInfo, Vc}; use turbo_tasks::{util::FormatDuration, RcStr, ReadConsistency, TurboTasks, UpdateInfo, Vc};
use turbo_tasks_fs::{ use turbo_tasks_fs::{
register, DirectoryContent, DirectoryEntry, DiskFileSystem, FileContent, FileSystem, register, DirectoryContent, DirectoryEntry, DiskFileSystem, FileContent, FileSystem,
FileSystemPath, FileSystemPath,
...@@ -41,7 +41,9 @@ async fn main() -> Result<()> { ...@@ -41,7 +41,9 @@ async fn main() -> Result<()> {
Ok::<Vc<()>, _>(Default::default()) Ok::<Vc<()>, _>(Default::default())
}) })
}); });
tt.wait_task_completion(task, true).await.unwrap(); tt.wait_task_completion(task, ReadConsistency::Strong)
.await
.unwrap();
println!("done in {}", FormatDuration(start.elapsed())); println!("done in {}", FormatDuration(start.elapsed()));
loop { loop {
......
...@@ -9,7 +9,7 @@ use std::{ ...@@ -9,7 +9,7 @@ use std::{
use anyhow::Result; use anyhow::Result;
use sha2::{Digest, Sha256}; use sha2::{Digest, Sha256};
use turbo_tasks::{util::FormatDuration, RcStr, TurboTasks, UpdateInfo, Vc}; use turbo_tasks::{util::FormatDuration, RcStr, ReadConsistency, TurboTasks, UpdateInfo, Vc};
use turbo_tasks_fs::{ use turbo_tasks_fs::{
glob::Glob, register, DirectoryEntry, DiskFileSystem, FileContent, FileSystem, FileSystemPath, glob::Glob, register, DirectoryEntry, DiskFileSystem, FileContent, FileSystem, FileSystemPath,
ReadGlobResult, ReadGlobResult,
...@@ -40,7 +40,9 @@ async fn main() -> Result<()> { ...@@ -40,7 +40,9 @@ async fn main() -> Result<()> {
Ok::<Vc<()>, _>(Default::default()) Ok::<Vc<()>, _>(Default::default())
}) })
}); });
tt.wait_task_completion(task, true).await.unwrap(); tt.wait_task_completion(task, ReadConsistency::Strong)
.await
.unwrap();
println!("done in {}", FormatDuration(start.elapsed())); println!("done in {}", FormatDuration(start.elapsed()));
loop { loop {
......
use anyhow::Result; use anyhow::Result;
use criterion::{BenchmarkId, Criterion}; use criterion::{BenchmarkId, Criterion};
use turbo_tasks::{Completion, TryJoinIterExt, TurboTasks, Vc}; use turbo_tasks::{Completion, ReadConsistency, TryJoinIterExt, TurboTasks, Vc};
use turbo_tasks_memory::MemoryBackend; use turbo_tasks_memory::MemoryBackend;
use super::register; use super::register;
...@@ -49,7 +49,8 @@ pub fn scope_stress(c: &mut Criterion) { ...@@ -49,7 +49,8 @@ pub fn scope_stress(c: &mut Criterion) {
rectangle(a, b).strongly_consistent().await?; rectangle(a, b).strongly_consistent().await?;
Ok::<Vc<()>, _>(Default::default()) Ok::<Vc<()>, _>(Default::default())
}); });
tt.wait_task_completion(task, false).await tt.wait_task_completion(task, ReadConsistency::Eventual)
.await
} }
}) })
.try_join() .try_join()
......
use anyhow::Result; use anyhow::Result;
use criterion::{BenchmarkId, Criterion}; use criterion::{BenchmarkId, Criterion};
use turbo_tasks::{TryJoinIterExt, TurboTasks, Vc}; use turbo_tasks::{ReadConsistency, TryJoinIterExt, TurboTasks, Vc};
use turbo_tasks_memory::MemoryBackend; use turbo_tasks_memory::MemoryBackend;
use super::register; use super::register;
...@@ -43,7 +43,9 @@ pub fn fibonacci(c: &mut Criterion) { ...@@ -43,7 +43,9 @@ pub fn fibonacci(c: &mut Criterion) {
(0..size).map(|i| fib(i, i)).try_join().await?; (0..size).map(|i| fib(i, i)).try_join().await?;
Ok::<Vc<()>, _>(Default::default()) Ok::<Vc<()>, _>(Default::default())
}); });
tt.wait_task_completion(task, false).await.unwrap(); tt.wait_task_completion(task, ReadConsistency::Eventual)
.await
.unwrap();
tt tt
} }
}) })
......
...@@ -37,6 +37,7 @@ where ...@@ -37,6 +37,7 @@ where
/// Converted the given node to a fully aggregated node. To make the next call /// Converted the given node to a fully aggregated node. To make the next call
/// to `aggregation_data` instant. /// to `aggregation_data` instant.
#[cfg(test)]
pub fn prepare_aggregation_data<C: AggregationContext>(ctx: &C, node_id: &C::NodeRef) { pub fn prepare_aggregation_data<C: AggregationContext>(ctx: &C, node_id: &C::NodeRef) {
let mut balance_queue = BalanceQueue::new(); let mut balance_queue = BalanceQueue::new();
increase_aggregation_number_internal( increase_aggregation_number_internal(
......
...@@ -23,7 +23,7 @@ mod root_query; ...@@ -23,7 +23,7 @@ mod root_query;
mod tests; mod tests;
mod uppers; mod uppers;
pub use aggregation_data::{aggregation_data, prepare_aggregation_data, AggregationDataGuard}; pub use aggregation_data::{aggregation_data, AggregationDataGuard};
use balance_edge::balance_edge; use balance_edge::balance_edge;
use increase::increase_aggregation_number_internal; use increase::increase_aggregation_number_internal;
pub use new_edge::handle_new_edge; pub use new_edge::handle_new_edge;
......
...@@ -26,8 +26,8 @@ use turbo_tasks::{ ...@@ -26,8 +26,8 @@ use turbo_tasks::{
}, },
event::EventListener, event::EventListener,
util::{IdFactoryWithReuse, NoMoveVec}, util::{IdFactoryWithReuse, NoMoveVec},
CellId, FunctionId, RawVc, TaskId, TaskIdSet, TraitTypeId, TurboTasksBackendApi, Unused, CellId, FunctionId, RawVc, ReadConsistency, TaskId, TaskIdSet, TraitTypeId,
ValueTypeId, TRANSIENT_TASK_BIT, TurboTasksBackendApi, Unused, ValueTypeId, TRANSIENT_TASK_BIT,
}; };
use crate::{ use crate::{
...@@ -115,13 +115,13 @@ impl MemoryBackend { ...@@ -115,13 +115,13 @@ impl MemoryBackend {
fn try_get_output<T, F: FnOnce(&mut Output) -> Result<T>>( fn try_get_output<T, F: FnOnce(&mut Output) -> Result<T>>(
&self, &self,
id: TaskId, id: TaskId,
strongly_consistent: bool, consistency: ReadConsistency,
note: impl Fn() -> String + Sync + Send + 'static, note: impl Fn() -> String + Sync + Send + 'static,
turbo_tasks: &dyn TurboTasksBackendApi<MemoryBackend>, turbo_tasks: &dyn TurboTasksBackendApi<MemoryBackend>,
func: F, func: F,
) -> Result<Result<T, EventListener>> { ) -> Result<Result<T, EventListener>> {
self.with_task(id, |task| { self.with_task(id, |task| {
task.get_or_wait_output(strongly_consistent, func, note, self, turbo_tasks) task.get_or_wait_output(consistency, func, note, self, turbo_tasks)
}) })
} }
...@@ -517,7 +517,7 @@ impl Backend for MemoryBackend { ...@@ -517,7 +517,7 @@ impl Backend for MemoryBackend {
&self, &self,
task: TaskId, task: TaskId,
reader: TaskId, reader: TaskId,
strongly_consistent: bool, consistency: ReadConsistency,
turbo_tasks: &dyn TurboTasksBackendApi<MemoryBackend>, turbo_tasks: &dyn TurboTasksBackendApi<MemoryBackend>,
) -> Result<Result<RawVc, EventListener>> { ) -> Result<Result<RawVc, EventListener>> {
if task == reader { if task == reader {
...@@ -525,7 +525,7 @@ impl Backend for MemoryBackend { ...@@ -525,7 +525,7 @@ impl Backend for MemoryBackend {
} }
self.try_get_output( self.try_get_output(
task, task,
strongly_consistent, consistency,
move || format!("reading task output from {reader}"), move || format!("reading task output from {reader}"),
turbo_tasks, turbo_tasks,
|output| { |output| {
...@@ -538,12 +538,12 @@ impl Backend for MemoryBackend { ...@@ -538,12 +538,12 @@ impl Backend for MemoryBackend {
fn try_read_task_output_untracked( fn try_read_task_output_untracked(
&self, &self,
task: TaskId, task: TaskId,
strongly_consistent: bool, consistency: ReadConsistency,
turbo_tasks: &dyn TurboTasksBackendApi<MemoryBackend>, turbo_tasks: &dyn TurboTasksBackendApi<MemoryBackend>,
) -> Result<Result<RawVc, EventListener>> { ) -> Result<Result<RawVc, EventListener>> {
self.try_get_output( self.try_get_output(
task, task,
strongly_consistent, consistency,
|| "reading task output untracked".to_string(), || "reading task output untracked".to_string(),
turbo_tasks, turbo_tasks,
|output| output.read_untracked(), |output| output.read_untracked(),
......
...@@ -23,14 +23,13 @@ use turbo_prehash::PreHashed; ...@@ -23,14 +23,13 @@ use turbo_prehash::PreHashed;
use turbo_tasks::{ use turbo_tasks::{
backend::{CachedTaskType, CellContent, TaskCollectiblesMap, TaskExecutionSpec}, backend::{CachedTaskType, CellContent, TaskCollectiblesMap, TaskExecutionSpec},
event::{Event, EventListener}, event::{Event, EventListener},
get_invalidator, registry, CellId, Invalidator, RawVc, TaskId, TaskIdSet, TraitTypeId, get_invalidator, registry, CellId, Invalidator, RawVc, ReadConsistency, TaskId, TaskIdSet,
TurboTasksBackendApi, ValueTypeId, TraitTypeId, TurboTasksBackendApi, ValueTypeId,
}; };
use crate::{ use crate::{
aggregation::{ aggregation::{
aggregation_data, handle_new_edge, prepare_aggregation_data, query_root_info, aggregation_data, handle_new_edge, query_root_info, AggregationDataGuard, PreparedOperation,
AggregationDataGuard, PreparedOperation,
}, },
cell::{Cell, ReadContentError}, cell::{Cell, ReadContentError},
edges_set::{TaskEdge, TaskEdgesList, TaskEdgesSet}, edges_set::{TaskEdge, TaskEdgesList, TaskEdgesSet},
...@@ -1621,17 +1620,14 @@ impl Task { ...@@ -1621,17 +1620,14 @@ impl Task {
pub(crate) fn get_or_wait_output<T, F: FnOnce(&mut Output) -> Result<T>>( pub(crate) fn get_or_wait_output<T, F: FnOnce(&mut Output) -> Result<T>>(
&self, &self,
strongly_consistent: bool, consistency: ReadConsistency,
func: F, func: F,
note: impl Fn() -> String + Sync + Send + 'static, note: impl Fn() -> String + Sync + Send + 'static,
backend: &MemoryBackend, backend: &MemoryBackend,
turbo_tasks: &dyn TurboTasksBackendApi<MemoryBackend>, turbo_tasks: &dyn TurboTasksBackendApi<MemoryBackend>,
) -> Result<Result<T, EventListener>> { ) -> Result<Result<T, EventListener>> {
let mut aggregation_context = TaskAggregationContext::new(turbo_tasks, backend); let mut aggregation_context = TaskAggregationContext::new(turbo_tasks, backend);
if strongly_consistent { let mut state = if consistency == ReadConsistency::Strong {
prepare_aggregation_data(&aggregation_context, &self.id);
}
let mut state = if strongly_consistent {
let mut aggregation = aggregation_data(&aggregation_context, &self.id); let mut aggregation = aggregation_data(&aggregation_context, &self.id);
if aggregation.unfinished > 0 { if aggregation.unfinished > 0 {
if aggregation.root_type.is_none() { if aggregation.root_type.is_none() {
......
...@@ -20,8 +20,8 @@ use turbo_tasks::{ ...@@ -20,8 +20,8 @@ use turbo_tasks::{
registry, registry,
test_helpers::with_turbo_tasks_for_testing, test_helpers::with_turbo_tasks_for_testing,
util::{SharedError, StaticOrArc}, util::{SharedError, StaticOrArc},
CellId, ExecutionId, InvalidationReason, MagicAny, RawVc, TaskId, TaskPersistence, TraitTypeId, CellId, ExecutionId, InvalidationReason, MagicAny, RawVc, ReadConsistency, TaskId,
TurboTasksApi, TurboTasksCallApi, TaskPersistence, TraitTypeId, TurboTasksApi, TurboTasksCallApi,
}; };
pub use crate::run::{run, run_without_cache_check, Registration}; pub use crate::run::{run, run_without_cache_check, Registration};
...@@ -184,7 +184,7 @@ impl TurboTasksApi for VcStorage { ...@@ -184,7 +184,7 @@ impl TurboTasksApi for VcStorage {
fn try_read_task_output( fn try_read_task_output(
&self, &self,
id: TaskId, id: TaskId,
_strongly_consistent: bool, _consistency: ReadConsistency,
) -> Result<Result<RawVc, EventListener>> { ) -> Result<Result<RawVc, EventListener>> {
let tasks = self.tasks.lock().unwrap(); let tasks = self.tasks.lock().unwrap();
let i = *id - 1; let i = *id - 1;
...@@ -201,9 +201,9 @@ impl TurboTasksApi for VcStorage { ...@@ -201,9 +201,9 @@ impl TurboTasksApi for VcStorage {
fn try_read_task_output_untracked( fn try_read_task_output_untracked(
&self, &self,
task: TaskId, task: TaskId,
strongly_consistent: bool, consistency: ReadConsistency,
) -> Result<Result<RawVc, EventListener>> { ) -> Result<Result<RawVc, EventListener>> {
self.try_read_task_output(task, strongly_consistent) self.try_read_task_output(task, consistency)
} }
fn try_read_task_cell( fn try_read_task_cell(
......
...@@ -17,7 +17,7 @@ pub use crate::id::{BackendJobId, ExecutionId}; ...@@ -17,7 +17,7 @@ pub use crate::id::{BackendJobId, ExecutionId};
use crate::{ use crate::{
event::EventListener, event::EventListener,
magic_any::MagicAny, magic_any::MagicAny,
manager::TurboTasksBackendApi, manager::{ReadConsistency, TurboTasksBackendApi},
raw_vc::CellId, raw_vc::CellId,
registry, registry,
task::shared_reference::TypedSharedReference, task::shared_reference::TypedSharedReference,
...@@ -484,7 +484,7 @@ pub trait Backend: Sync + Send { ...@@ -484,7 +484,7 @@ pub trait Backend: Sync + Send {
&self, &self,
task: TaskId, task: TaskId,
reader: TaskId, reader: TaskId,
strongly_consistent: bool, consistency: ReadConsistency,
turbo_tasks: &dyn TurboTasksBackendApi<Self>, turbo_tasks: &dyn TurboTasksBackendApi<Self>,
) -> Result<Result<RawVc, EventListener>>; ) -> Result<Result<RawVc, EventListener>>;
...@@ -493,7 +493,7 @@ pub trait Backend: Sync + Send { ...@@ -493,7 +493,7 @@ pub trait Backend: Sync + Send {
fn try_read_task_output_untracked( fn try_read_task_output_untracked(
&self, &self,
task: TaskId, task: TaskId,
strongly_consistent: bool, consistency: ReadConsistency,
turbo_tasks: &dyn TurboTasksBackendApi<Self>, turbo_tasks: &dyn TurboTasksBackendApi<Self>,
) -> Result<Result<RawVc, EventListener>>; ) -> Result<Result<RawVc, EventListener>>;
......
...@@ -90,8 +90,8 @@ pub use magic_any::MagicAny; ...@@ -90,8 +90,8 @@ pub use magic_any::MagicAny;
pub use manager::{ pub use manager::{
dynamic_call, dynamic_this_call, emit, get_invalidator, mark_finished, mark_stateful, dynamic_call, dynamic_this_call, emit, get_invalidator, mark_finished, mark_stateful,
prevent_gc, run_once, run_once_with_reason, spawn_blocking, spawn_thread, trait_call, prevent_gc, run_once, run_once_with_reason, spawn_blocking, spawn_thread, trait_call,
turbo_tasks, CurrentCellRef, Invalidator, TaskPersistence, TurboTasks, TurboTasksApi, turbo_tasks, CurrentCellRef, Invalidator, ReadConsistency, TaskPersistence, TurboTasks,
TurboTasksBackendApi, TurboTasksCallApi, Unused, UpdateInfo, TurboTasksApi, TurboTasksBackendApi, TurboTasksCallApi, Unused, UpdateInfo,
}; };
pub use native_function::{FunctionMeta, NativeFunction}; pub use native_function::{FunctionMeta, NativeFunction};
pub use raw_vc::{CellId, RawVc, ReadRawVcFuture, ResolveTypeError}; pub use raw_vc::{CellId, RawVc, ReadRawVcFuture, ResolveTypeError};
......
...@@ -118,7 +118,7 @@ pub trait TurboTasksApi: TurboTasksCallApi + Sync + Send { ...@@ -118,7 +118,7 @@ pub trait TurboTasksApi: TurboTasksCallApi + Sync + Send {
fn try_read_task_output( fn try_read_task_output(
&self, &self,
task: TaskId, task: TaskId,
strongly_consistent: bool, consistency: ReadConsistency,
) -> Result<Result<RawVc, EventListener>>; ) -> Result<Result<RawVc, EventListener>>;
/// INVALIDATION: Be careful with this, it will not track dependencies, so /// INVALIDATION: Be careful with this, it will not track dependencies, so
...@@ -126,7 +126,7 @@ pub trait TurboTasksApi: TurboTasksCallApi + Sync + Send { ...@@ -126,7 +126,7 @@ pub trait TurboTasksApi: TurboTasksCallApi + Sync + Send {
fn try_read_task_output_untracked( fn try_read_task_output_untracked(
&self, &self,
task: TaskId, task: TaskId,
strongly_consistent: bool, consistency: ReadConsistency,
) -> Result<Result<RawVc, EventListener>>; ) -> Result<Result<RawVc, EventListener>>;
fn try_read_task_cell( fn try_read_task_cell(
...@@ -277,6 +277,18 @@ pub enum TaskPersistence { ...@@ -277,6 +277,18 @@ pub enum TaskPersistence {
LocalCells, LocalCells,
} }
#[derive(Clone, Copy, Eq, PartialEq)]
pub enum ReadConsistency {
/// The default behavior for most APIs. Reads are faster, but may return stale values, which
/// may later trigger re-computation.
Eventual,
/// Ensures all dependencies are fully resolved before returning the cell or output data, at
/// the cost of slower reads.
///
/// Top-level code that returns data to the user should use strongly consistent reads.
Strong,
}
pub struct TurboTasks<B: Backend + 'static> { pub struct TurboTasks<B: Backend + 'static> {
this: Weak<Self>, this: Weak<Self>,
backend: B, backend: B,
...@@ -443,7 +455,8 @@ impl<B: Backend + 'static> TurboTasks<B> { ...@@ -443,7 +455,8 @@ impl<B: Backend + 'static> TurboTasks<B> {
}); });
// INVALIDATION: A Once task will never invalidate, therefore we don't need to // INVALIDATION: A Once task will never invalidate, therefore we don't need to
// track a dependency // track a dependency
let raw_result = read_task_output_untracked(self, task_id, false).await?; let raw_result =
read_task_output_untracked(self, task_id, ReadConsistency::Eventual).await?;
ReadVcFuture::<Completion>::from(raw_result.into_read_untracked_with_turbo_tasks(self)) ReadVcFuture::<Completion>::from(raw_result.into_read_untracked_with_turbo_tasks(self))
.await?; .await?;
...@@ -797,10 +810,25 @@ impl<B: Backend + 'static> TurboTasks<B> { ...@@ -797,10 +810,25 @@ impl<B: Backend + 'static> TurboTasks<B> {
self.currently_scheduled_tasks.load(Ordering::Acquire) self.currently_scheduled_tasks.load(Ordering::Acquire)
} }
pub async fn wait_task_completion(&self, id: TaskId, fully_settled: bool) -> Result<()> { /// Waits for the given task to finish executing. This works by performing an untracked read,
/// and discarding the value of the task output.
///
/// [`ReadConsistency::Weak`] means that this will return after the task executes, but before
/// all dependencies have completely settled.
///
/// [`ReadConsistency::Strong`] means that this will also wait for the task and all dependencies
/// to fully settle before returning.
///
/// As this function is typically called in top-level code that waits for results to be ready
/// for the user to access, most callers should use [`ReadConsistency::Strong`].
pub async fn wait_task_completion(
&self,
id: TaskId,
consistency: ReadConsistency,
) -> Result<()> {
// INVALIDATION: This doesn't return a value, only waits for it to be ready. // INVALIDATION: This doesn't return a value, only waits for it to be ready.
let result = read_task_output_untracked(self, id, fully_settled).await; read_task_output_untracked(self, id, consistency).await?;
result.map(|_| ()) Ok(())
} }
#[deprecated(note = "Use get_or_wait_aggregated_update_info instead")] #[deprecated(note = "Use get_or_wait_aggregated_update_info instead")]
...@@ -1143,23 +1171,19 @@ impl<B: Backend + 'static> TurboTasksApi for TurboTasks<B> { ...@@ -1143,23 +1171,19 @@ impl<B: Backend + 'static> TurboTasksApi for TurboTasks<B> {
fn try_read_task_output( fn try_read_task_output(
&self, &self,
task: TaskId, task: TaskId,
strongly_consistent: bool, consistency: ReadConsistency,
) -> Result<Result<RawVc, EventListener>> { ) -> Result<Result<RawVc, EventListener>> {
self.backend.try_read_task_output( self.backend
task, .try_read_task_output(task, current_task("reading Vcs"), consistency, self)
current_task("reading Vcs"),
strongly_consistent,
self,
)
} }
fn try_read_task_output_untracked( fn try_read_task_output_untracked(
&self, &self,
task: TaskId, task: TaskId,
strongly_consistent: bool, consistency: ReadConsistency,
) -> Result<Result<RawVc, EventListener>> { ) -> Result<Result<RawVc, EventListener>> {
self.backend self.backend
.try_read_task_output_untracked(task, strongly_consistent, self) .try_read_task_output_untracked(task, consistency, self)
} }
fn try_read_task_cell( fn try_read_task_cell(
...@@ -1521,7 +1545,7 @@ pub async fn run_once<T: Send + 'static>( ...@@ -1521,7 +1545,7 @@ pub async fn run_once<T: Send + 'static>(
// INVALIDATION: A Once task will never invalidate, therefore we don't need to // INVALIDATION: A Once task will never invalidate, therefore we don't need to
// track a dependency // track a dependency
let raw_result = read_task_output_untracked(&*tt, task_id, false).await?; let raw_result = read_task_output_untracked(&*tt, task_id, ReadConsistency::Eventual).await?;
ReadVcFuture::<Completion>::from(raw_result.into_read_untracked_with_turbo_tasks(&*tt)).await?; ReadVcFuture::<Completion>::from(raw_result.into_read_untracked_with_turbo_tasks(&*tt)).await?;
Ok(rx.await?) Ok(rx.await?)
...@@ -1546,7 +1570,7 @@ pub async fn run_once_with_reason<T: Send + 'static>( ...@@ -1546,7 +1570,7 @@ pub async fn run_once_with_reason<T: Send + 'static>(
// INVALIDATION: A Once task will never invalidate, therefore we don't need to // INVALIDATION: A Once task will never invalidate, therefore we don't need to
// track a dependency // track a dependency
let raw_result = read_task_output_untracked(&*tt, task_id, false).await?; let raw_result = read_task_output_untracked(&*tt, task_id, ReadConsistency::Eventual).await?;
ReadVcFuture::<Completion>::from(raw_result.into_read_untracked_with_turbo_tasks(&*tt)).await?; ReadVcFuture::<Completion>::from(raw_result.into_read_untracked_with_turbo_tasks(&*tt)).await?;
Ok(rx.await?) Ok(rx.await?)
...@@ -1694,10 +1718,10 @@ pub fn spawn_thread(func: impl FnOnce() + Send + 'static) { ...@@ -1694,10 +1718,10 @@ pub fn spawn_thread(func: impl FnOnce() + Send + 'static) {
pub(crate) async fn read_task_output( pub(crate) async fn read_task_output(
this: &dyn TurboTasksApi, this: &dyn TurboTasksApi,
id: TaskId, id: TaskId,
strongly_consistent: bool, consistency: ReadConsistency,
) -> Result<RawVc> { ) -> Result<RawVc> {
loop { loop {
match this.try_read_task_output(id, strongly_consistent)? { match this.try_read_task_output(id, consistency)? {
Ok(result) => return Ok(result), Ok(result) => return Ok(result),
Err(listener) => listener.await, Err(listener) => listener.await,
} }
...@@ -1709,10 +1733,10 @@ pub(crate) async fn read_task_output( ...@@ -1709,10 +1733,10 @@ pub(crate) async fn read_task_output(
pub(crate) async fn read_task_output_untracked( pub(crate) async fn read_task_output_untracked(
this: &dyn TurboTasksApi, this: &dyn TurboTasksApi,
id: TaskId, id: TaskId,
strongly_consistent: bool, consistency: ReadConsistency,
) -> Result<RawVc> { ) -> Result<RawVc> {
loop { loop {
match this.try_read_task_output_untracked(id, strongly_consistent)? { match this.try_read_task_output_untracked(id, consistency)? {
Ok(result) => return Ok(result), Ok(result) => return Ok(result),
Err(listener) => listener.await, Err(listener) => listener.await,
} }
......
...@@ -21,7 +21,8 @@ use crate::{ ...@@ -21,7 +21,8 @@ use crate::{
TurboTasksApi, TurboTasksApi,
}, },
registry::{self, get_value_type}, registry::{self, get_value_type},
turbo_tasks, CollectiblesSource, TaskId, TraitTypeId, ValueType, ValueTypeId, Vc, VcValueTrait, turbo_tasks, CollectiblesSource, ReadConsistency, TaskId, TraitTypeId, ValueType, ValueTypeId,
Vc, VcValueTrait,
}; };
#[derive(Error, Debug)] #[derive(Error, Debug)]
...@@ -143,7 +144,7 @@ impl RawVc { ...@@ -143,7 +144,7 @@ impl RawVc {
loop { loop {
match current { match current {
RawVc::TaskOutput(task) => { RawVc::TaskOutput(task) => {
current = read_task_output(&*tt, task, false) current = read_task_output(&*tt, task, ReadConsistency::Eventual)
.await .await
.map_err(|source| ResolveTypeError::TaskError { source })?; .map_err(|source| ResolveTypeError::TaskError { source })?;
} }
...@@ -180,15 +181,15 @@ impl RawVc { ...@@ -180,15 +181,15 @@ impl RawVc {
/// See [`crate::Vc::resolve`]. /// See [`crate::Vc::resolve`].
pub(crate) async fn resolve(self) -> Result<RawVc> { pub(crate) async fn resolve(self) -> Result<RawVc> {
self.resolve_inner(/* strongly_consistent */ false).await self.resolve_inner(ReadConsistency::Eventual).await
} }
/// See [`crate::Vc::resolve_strongly_consistent`]. /// See [`crate::Vc::resolve_strongly_consistent`].
pub(crate) async fn resolve_strongly_consistent(self) -> Result<RawVc> { pub(crate) async fn resolve_strongly_consistent(self) -> Result<RawVc> {
self.resolve_inner(/* strongly_consistent */ true).await self.resolve_inner(ReadConsistency::Strong).await
} }
async fn resolve_inner(self, strongly_consistent: bool) -> Result<RawVc> { async fn resolve_inner(self, consistency: ReadConsistency) -> Result<RawVc> {
let tt = turbo_tasks(); let tt = turbo_tasks();
let mut current = self; let mut current = self;
let mut notified = false; let mut notified = false;
...@@ -199,7 +200,7 @@ impl RawVc { ...@@ -199,7 +200,7 @@ impl RawVc {
tt.notify_scheduled_tasks(); tt.notify_scheduled_tasks();
notified = true; notified = true;
} }
current = read_task_output(&*tt, task, strongly_consistent).await?; current = read_task_output(&*tt, task, consistency).await?;
} }
RawVc::TaskCell(_, _) => return Ok(current), RawVc::TaskCell(_, _) => return Ok(current),
RawVc::LocalCell(execution_id, local_cell_id) => { RawVc::LocalCell(execution_id, local_cell_id) => {
...@@ -250,7 +251,7 @@ impl CollectiblesSource for RawVc { ...@@ -250,7 +251,7 @@ impl CollectiblesSource for RawVc {
pub struct ReadRawVcFuture { pub struct ReadRawVcFuture {
turbo_tasks: Arc<dyn TurboTasksApi>, turbo_tasks: Arc<dyn TurboTasksApi>,
strongly_consistent: bool, consistency: ReadConsistency,
current: RawVc, current: RawVc,
untracked: bool, untracked: bool,
listener: Option<EventListener>, listener: Option<EventListener>,
...@@ -261,7 +262,7 @@ impl ReadRawVcFuture { ...@@ -261,7 +262,7 @@ impl ReadRawVcFuture {
let tt = turbo_tasks(); let tt = turbo_tasks();
ReadRawVcFuture { ReadRawVcFuture {
turbo_tasks: tt, turbo_tasks: tt,
strongly_consistent: false, consistency: ReadConsistency::Eventual,
current: vc, current: vc,
untracked: false, untracked: false,
listener: None, listener: None,
...@@ -272,7 +273,7 @@ impl ReadRawVcFuture { ...@@ -272,7 +273,7 @@ impl ReadRawVcFuture {
let tt = turbo_tasks.pin(); let tt = turbo_tasks.pin();
ReadRawVcFuture { ReadRawVcFuture {
turbo_tasks: tt, turbo_tasks: tt,
strongly_consistent: false, consistency: ReadConsistency::Eventual,
current: vc, current: vc,
untracked: true, untracked: true,
listener: None, listener: None,
...@@ -283,7 +284,7 @@ impl ReadRawVcFuture { ...@@ -283,7 +284,7 @@ impl ReadRawVcFuture {
let tt = turbo_tasks(); let tt = turbo_tasks();
ReadRawVcFuture { ReadRawVcFuture {
turbo_tasks: tt, turbo_tasks: tt,
strongly_consistent: false, consistency: ReadConsistency::Eventual,
current: vc, current: vc,
untracked: true, untracked: true,
listener: None, listener: None,
...@@ -294,7 +295,7 @@ impl ReadRawVcFuture { ...@@ -294,7 +295,7 @@ impl ReadRawVcFuture {
let tt = turbo_tasks(); let tt = turbo_tasks();
ReadRawVcFuture { ReadRawVcFuture {
turbo_tasks: tt, turbo_tasks: tt,
strongly_consistent: true, consistency: ReadConsistency::Strong,
current: vc, current: vc,
untracked: false, untracked: false,
listener: None, listener: None,
...@@ -305,7 +306,7 @@ impl ReadRawVcFuture { ...@@ -305,7 +306,7 @@ impl ReadRawVcFuture {
let tt = turbo_tasks(); let tt = turbo_tasks();
ReadRawVcFuture { ReadRawVcFuture {
turbo_tasks: tt, turbo_tasks: tt,
strongly_consistent: true, consistency: ReadConsistency::Strong,
current: vc, current: vc,
untracked: true, untracked: true,
listener: None, listener: None,
...@@ -333,17 +334,17 @@ impl Future for ReadRawVcFuture { ...@@ -333,17 +334,17 @@ impl Future for ReadRawVcFuture {
RawVc::TaskOutput(task) => { RawVc::TaskOutput(task) => {
let read_result = if this.untracked { let read_result = if this.untracked {
this.turbo_tasks this.turbo_tasks
.try_read_task_output_untracked(task, this.strongly_consistent) .try_read_task_output_untracked(task, this.consistency)
} else { } else {
this.turbo_tasks this.turbo_tasks
.try_read_task_output(task, this.strongly_consistent) .try_read_task_output(task, this.consistency)
}; };
match read_result { match read_result {
Ok(Ok(vc)) => { Ok(Ok(vc)) => {
// We no longer need to read strongly consistent, as any Vc returned // We no longer need to read strongly consistent, as any Vc returned
// from the first task will be inside of the scope of the first task. So // from the first task will be inside of the scope of the first task. So
// it's already strongly consistent. // it's already strongly consistent.
this.strongly_consistent = false; this.consistency = ReadConsistency::Eventual;
this.current = vc; this.current = vc;
continue 'outer; continue 'outer;
} }
......
...@@ -6,7 +6,9 @@ use std::{ ...@@ -6,7 +6,9 @@ use std::{
}; };
use anyhow::{bail, Context, Result}; use anyhow::{bail, Context, Result};
use turbo_tasks::{RcStr, TransientInstance, TryJoinIterExt, TurboTasks, Value, Vc}; use turbo_tasks::{
RcStr, ReadConsistency, TransientInstance, TryJoinIterExt, TurboTasks, Value, Vc,
};
use turbo_tasks_fs::FileSystem; use turbo_tasks_fs::FileSystem;
use turbo_tasks_memory::MemoryBackend; use turbo_tasks_memory::MemoryBackend;
use turbopack_cli_utils::issue::{ConsoleUi, LogOptions}; use turbopack_cli_utils::issue::{ConsoleUi, LogOptions};
...@@ -148,7 +150,9 @@ impl TurbopackBuildBuilder { ...@@ -148,7 +150,9 @@ impl TurbopackBuildBuilder {
Ok(Default::default()) Ok(Default::default())
}); });
self.turbo_tasks.wait_task_completion(task, true).await?; self.turbo_tasks
.wait_task_completion(task, ReadConsistency::Strong)
.await?;
Ok(()) Ok(())
} }
......
...@@ -12,7 +12,9 @@ use anyhow::{bail, Context, Result}; ...@@ -12,7 +12,9 @@ use anyhow::{bail, Context, Result};
use dunce::canonicalize; use dunce::canonicalize;
use serde::Deserialize; use serde::Deserialize;
use serde_json::json; use serde_json::json;
use turbo_tasks::{RcStr, ReadRef, TryJoinIterExt, TurboTasks, Value, ValueToString, Vc}; use turbo_tasks::{
RcStr, ReadConsistency, ReadRef, TryJoinIterExt, TurboTasks, Value, ValueToString, Vc,
};
use turbo_tasks_env::DotenvProcessEnv; use turbo_tasks_env::DotenvProcessEnv;
use turbo_tasks_fs::{ use turbo_tasks_fs::{
json::parse_json_with_source_context, util::sys_to_unix, DiskFileSystem, FileSystem, json::parse_json_with_source_context, util::sys_to_unix, DiskFileSystem, FileSystem,
...@@ -170,7 +172,8 @@ async fn run(resource: PathBuf) -> Result<()> { ...@@ -170,7 +172,8 @@ async fn run(resource: PathBuf) -> Result<()> {
.context("Unable to handle issues")?; .context("Unable to handle issues")?;
Ok(Vc::<()>::default()) Ok(Vc::<()>::default())
}); });
tt.wait_task_completion(task, true).await?; tt.wait_task_completion(task, ReadConsistency::Strong)
.await?;
Ok(()) Ok(())
} }
......
...@@ -2,7 +2,7 @@ use std::{collections::HashMap, fs, path::PathBuf}; ...@@ -2,7 +2,7 @@ use std::{collections::HashMap, fs, path::PathBuf};
use criterion::{Bencher, BenchmarkId, Criterion}; use criterion::{Bencher, BenchmarkId, Criterion};
use regex::Regex; use regex::Regex;
use turbo_tasks::{RcStr, TurboTasks, Value, Vc}; use turbo_tasks::{RcStr, ReadConsistency, TurboTasks, Value, Vc};
use turbo_tasks_fs::{DiskFileSystem, FileSystem, NullFileSystem}; use turbo_tasks_fs::{DiskFileSystem, FileSystem, NullFileSystem};
use turbo_tasks_memory::MemoryBackend; use turbo_tasks_memory::MemoryBackend;
use turbopack::{ use turbopack::{
...@@ -113,7 +113,9 @@ fn bench_emit(b: &mut Bencher, bench_input: &BenchInput) { ...@@ -113,7 +113,9 @@ fn bench_emit(b: &mut Bencher, bench_input: &BenchInput) {
Ok::<Vc<()>, _>(Default::default()) Ok::<Vc<()>, _>(Default::default())
}); });
tt.wait_task_completion(task, true).await.unwrap(); tt.wait_task_completion(task, ReadConsistency::Strong)
.await
.unwrap();
} }
}) })
} }
...@@ -8,7 +8,9 @@ use std::{ ...@@ -8,7 +8,9 @@ use std::{
use anyhow::Result; use anyhow::Result;
use tokio::{spawn, time::sleep}; use tokio::{spawn, time::sleep};
use turbo_tasks::{util::FormatDuration, RcStr, TurboTasks, UpdateInfo, Value, Vc}; use turbo_tasks::{
util::FormatDuration, RcStr, ReadConsistency, TurboTasks, UpdateInfo, Value, Vc,
};
use turbo_tasks_fs::{DiskFileSystem, FileSystem}; use turbo_tasks_fs::{DiskFileSystem, FileSystem};
use turbo_tasks_memory::MemoryBackend; use turbo_tasks_memory::MemoryBackend;
use turbopack::{emit_with_completion, rebase::RebasedAsset, register}; use turbopack::{emit_with_completion, rebase::RebasedAsset, register};
...@@ -72,7 +74,9 @@ async fn main() -> Result<()> { ...@@ -72,7 +74,9 @@ async fn main() -> Result<()> {
spawn({ spawn({
let tt = tt.clone(); let tt = tt.clone();
async move { async move {
tt.wait_task_completion(task, true).await.unwrap(); tt.wait_task_completion(task, ReadConsistency::Strong)
.await
.unwrap();
println!("done in {}", FormatDuration(start.elapsed())); println!("done in {}", FormatDuration(start.elapsed()));
loop { loop {
......
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