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::{
project::{ProjectContainer, ProjectOptions},
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_memory::MemoryBackend;
......@@ -261,7 +261,8 @@ async fn hmr(tt: &TurboTasks<MemoryBackend>, project: Vc<ProjectContainer>) -> R
Ok(Vc::<()>::cell(()))
}
});
tt.wait_task_completion(task, true).await?;
tt.wait_task_completion(task, ReadConsistency::Strong)
.await?;
let e = start.elapsed();
if e.as_millis() > 10 {
tracing::info!("HMR: {:?} {:?}", ident, e);
......
......@@ -22,8 +22,8 @@ use serde::Deserialize;
use serde::Serialize;
use tokio::sync::mpsc::channel;
use turbo_tasks::{
backend::Backend, util::FormatDuration, RcStr, TaskId, TransientInstance, TransientValue,
TurboTasks, UpdateInfo, Value, Vc,
backend::Backend, util::FormatDuration, RcStr, ReadConsistency, TaskId, TransientInstance,
TransientValue, TurboTasks, UpdateInfo, Value, Vc,
};
use turbo_tasks_fs::{
glob::Glob, DirectoryEntry, DiskFileSystem, FileSystem, FileSystemPath, ReadGlobResult,
......@@ -407,7 +407,10 @@ async fn run<B: Backend + 'static, F: Future<Output = ()>>(
let start = Instant::now();
let finish = |tt: Arc<TurboTasks<B>>, root_task: TaskId| async move {
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);
}
let UpdateInfo {
......@@ -431,7 +434,9 @@ async fn run<B: Backend + 'static, F: Future<Output = ()>>(
println!("updated {} tasks in {}", tasks, FormatDuration(duration));
}
} 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 UpdateInfo {
duration, tasks, ..
......
......@@ -9,7 +9,7 @@ use std::{
use anyhow::Result;
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::{
register, DirectoryContent, DirectoryEntry, DiskFileSystem, FileContent, FileSystem,
FileSystemPath,
......@@ -41,7 +41,9 @@ async fn main() -> Result<()> {
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()));
loop {
......
......@@ -9,7 +9,7 @@ use std::{
use anyhow::Result;
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::{
glob::Glob, register, DirectoryEntry, DiskFileSystem, FileContent, FileSystem, FileSystemPath,
ReadGlobResult,
......@@ -40,7 +40,9 @@ async fn main() -> Result<()> {
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()));
loop {
......
use anyhow::Result;
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 super::register;
......@@ -49,7 +49,8 @@ pub fn scope_stress(c: &mut Criterion) {
rectangle(a, b).strongly_consistent().await?;
Ok::<Vc<()>, _>(Default::default())
});
tt.wait_task_completion(task, false).await
tt.wait_task_completion(task, ReadConsistency::Eventual)
.await
}
})
.try_join()
......
use anyhow::Result;
use criterion::{BenchmarkId, Criterion};
use turbo_tasks::{TryJoinIterExt, TurboTasks, Vc};
use turbo_tasks::{ReadConsistency, TryJoinIterExt, TurboTasks, Vc};
use turbo_tasks_memory::MemoryBackend;
use super::register;
......@@ -43,7 +43,9 @@ pub fn fibonacci(c: &mut Criterion) {
(0..size).map(|i| fib(i, i)).try_join().await?;
Ok::<Vc<()>, _>(Default::default())
});
tt.wait_task_completion(task, false).await.unwrap();
tt.wait_task_completion(task, ReadConsistency::Eventual)
.await
.unwrap();
tt
}
})
......
......@@ -37,6 +37,7 @@ where
/// Converted the given node to a fully aggregated node. To make the next call
/// to `aggregation_data` instant.
#[cfg(test)]
pub fn prepare_aggregation_data<C: AggregationContext>(ctx: &C, node_id: &C::NodeRef) {
let mut balance_queue = BalanceQueue::new();
increase_aggregation_number_internal(
......
......@@ -23,7 +23,7 @@ mod root_query;
mod tests;
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 increase::increase_aggregation_number_internal;
pub use new_edge::handle_new_edge;
......
......@@ -26,8 +26,8 @@ use turbo_tasks::{
},
event::EventListener,
util::{IdFactoryWithReuse, NoMoveVec},
CellId, FunctionId, RawVc, TaskId, TaskIdSet, TraitTypeId, TurboTasksBackendApi, Unused,
ValueTypeId, TRANSIENT_TASK_BIT,
CellId, FunctionId, RawVc, ReadConsistency, TaskId, TaskIdSet, TraitTypeId,
TurboTasksBackendApi, Unused, ValueTypeId, TRANSIENT_TASK_BIT,
};
use crate::{
......@@ -115,13 +115,13 @@ impl MemoryBackend {
fn try_get_output<T, F: FnOnce(&mut Output) -> Result<T>>(
&self,
id: TaskId,
strongly_consistent: bool,
consistency: ReadConsistency,
note: impl Fn() -> String + Sync + Send + 'static,
turbo_tasks: &dyn TurboTasksBackendApi<MemoryBackend>,
func: F,
) -> Result<Result<T, EventListener>> {
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 {
&self,
task: TaskId,
reader: TaskId,
strongly_consistent: bool,
consistency: ReadConsistency,
turbo_tasks: &dyn TurboTasksBackendApi<MemoryBackend>,
) -> Result<Result<RawVc, EventListener>> {
if task == reader {
......@@ -525,7 +525,7 @@ impl Backend for MemoryBackend {
}
self.try_get_output(
task,
strongly_consistent,
consistency,
move || format!("reading task output from {reader}"),
turbo_tasks,
|output| {
......@@ -538,12 +538,12 @@ impl Backend for MemoryBackend {
fn try_read_task_output_untracked(
&self,
task: TaskId,
strongly_consistent: bool,
consistency: ReadConsistency,
turbo_tasks: &dyn TurboTasksBackendApi<MemoryBackend>,
) -> Result<Result<RawVc, EventListener>> {
self.try_get_output(
task,
strongly_consistent,
consistency,
|| "reading task output untracked".to_string(),
turbo_tasks,
|output| output.read_untracked(),
......
......@@ -23,14 +23,13 @@ use turbo_prehash::PreHashed;
use turbo_tasks::{
backend::{CachedTaskType, CellContent, TaskCollectiblesMap, TaskExecutionSpec},
event::{Event, EventListener},
get_invalidator, registry, CellId, Invalidator, RawVc, TaskId, TaskIdSet, TraitTypeId,
TurboTasksBackendApi, ValueTypeId,
get_invalidator, registry, CellId, Invalidator, RawVc, ReadConsistency, TaskId, TaskIdSet,
TraitTypeId, TurboTasksBackendApi, ValueTypeId,
};
use crate::{
aggregation::{
aggregation_data, handle_new_edge, prepare_aggregation_data, query_root_info,
AggregationDataGuard, PreparedOperation,
aggregation_data, handle_new_edge, query_root_info, AggregationDataGuard, PreparedOperation,
},
cell::{Cell, ReadContentError},
edges_set::{TaskEdge, TaskEdgesList, TaskEdgesSet},
......@@ -1621,17 +1620,14 @@ impl Task {
pub(crate) fn get_or_wait_output<T, F: FnOnce(&mut Output) -> Result<T>>(
&self,
strongly_consistent: bool,
consistency: ReadConsistency,
func: F,
note: impl Fn() -> String + Sync + Send + 'static,
backend: &MemoryBackend,
turbo_tasks: &dyn TurboTasksBackendApi<MemoryBackend>,
) -> Result<Result<T, EventListener>> {
let mut aggregation_context = TaskAggregationContext::new(turbo_tasks, backend);
if strongly_consistent {
prepare_aggregation_data(&aggregation_context, &self.id);
}
let mut state = if strongly_consistent {
let mut state = if consistency == ReadConsistency::Strong {
let mut aggregation = aggregation_data(&aggregation_context, &self.id);
if aggregation.unfinished > 0 {
if aggregation.root_type.is_none() {
......
......@@ -20,8 +20,8 @@ use turbo_tasks::{
registry,
test_helpers::with_turbo_tasks_for_testing,
util::{SharedError, StaticOrArc},
CellId, ExecutionId, InvalidationReason, MagicAny, RawVc, TaskId, TaskPersistence, TraitTypeId,
TurboTasksApi, TurboTasksCallApi,
CellId, ExecutionId, InvalidationReason, MagicAny, RawVc, ReadConsistency, TaskId,
TaskPersistence, TraitTypeId, TurboTasksApi, TurboTasksCallApi,
};
pub use crate::run::{run, run_without_cache_check, Registration};
......@@ -184,7 +184,7 @@ impl TurboTasksApi for VcStorage {
fn try_read_task_output(
&self,
id: TaskId,
_strongly_consistent: bool,
_consistency: ReadConsistency,
) -> Result<Result<RawVc, EventListener>> {
let tasks = self.tasks.lock().unwrap();
let i = *id - 1;
......@@ -201,9 +201,9 @@ impl TurboTasksApi for VcStorage {
fn try_read_task_output_untracked(
&self,
task: TaskId,
strongly_consistent: bool,
consistency: ReadConsistency,
) -> Result<Result<RawVc, EventListener>> {
self.try_read_task_output(task, strongly_consistent)
self.try_read_task_output(task, consistency)
}
fn try_read_task_cell(
......
......@@ -17,7 +17,7 @@ pub use crate::id::{BackendJobId, ExecutionId};
use crate::{
event::EventListener,
magic_any::MagicAny,
manager::TurboTasksBackendApi,
manager::{ReadConsistency, TurboTasksBackendApi},
raw_vc::CellId,
registry,
task::shared_reference::TypedSharedReference,
......@@ -484,7 +484,7 @@ pub trait Backend: Sync + Send {
&self,
task: TaskId,
reader: TaskId,
strongly_consistent: bool,
consistency: ReadConsistency,
turbo_tasks: &dyn TurboTasksBackendApi<Self>,
) -> Result<Result<RawVc, EventListener>>;
......@@ -493,7 +493,7 @@ pub trait Backend: Sync + Send {
fn try_read_task_output_untracked(
&self,
task: TaskId,
strongly_consistent: bool,
consistency: ReadConsistency,
turbo_tasks: &dyn TurboTasksBackendApi<Self>,
) -> Result<Result<RawVc, EventListener>>;
......
......@@ -90,8 +90,8 @@ pub use magic_any::MagicAny;
pub use manager::{
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,
turbo_tasks, CurrentCellRef, Invalidator, TaskPersistence, TurboTasks, TurboTasksApi,
TurboTasksBackendApi, TurboTasksCallApi, Unused, UpdateInfo,
turbo_tasks, CurrentCellRef, Invalidator, ReadConsistency, TaskPersistence, TurboTasks,
TurboTasksApi, TurboTasksBackendApi, TurboTasksCallApi, Unused, UpdateInfo,
};
pub use native_function::{FunctionMeta, NativeFunction};
pub use raw_vc::{CellId, RawVc, ReadRawVcFuture, ResolveTypeError};
......
......@@ -118,7 +118,7 @@ pub trait TurboTasksApi: TurboTasksCallApi + Sync + Send {
fn try_read_task_output(
&self,
task: TaskId,
strongly_consistent: bool,
consistency: ReadConsistency,
) -> Result<Result<RawVc, EventListener>>;
/// INVALIDATION: Be careful with this, it will not track dependencies, so
......@@ -126,7 +126,7 @@ pub trait TurboTasksApi: TurboTasksCallApi + Sync + Send {
fn try_read_task_output_untracked(
&self,
task: TaskId,
strongly_consistent: bool,
consistency: ReadConsistency,
) -> Result<Result<RawVc, EventListener>>;
fn try_read_task_cell(
......@@ -277,6 +277,18 @@ pub enum TaskPersistence {
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> {
this: Weak<Self>,
backend: B,
......@@ -443,7 +455,8 @@ impl<B: Backend + 'static> TurboTasks<B> {
});
// INVALIDATION: A Once task will never invalidate, therefore we don't need to
// 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))
.await?;
......@@ -797,10 +810,25 @@ impl<B: Backend + 'static> TurboTasks<B> {
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.
let result = read_task_output_untracked(self, id, fully_settled).await;
result.map(|_| ())
read_task_output_untracked(self, id, consistency).await?;
Ok(())
}
#[deprecated(note = "Use get_or_wait_aggregated_update_info instead")]
......@@ -1143,23 +1171,19 @@ impl<B: Backend + 'static> TurboTasksApi for TurboTasks<B> {
fn try_read_task_output(
&self,
task: TaskId,
strongly_consistent: bool,
consistency: ReadConsistency,
) -> Result<Result<RawVc, EventListener>> {
self.backend.try_read_task_output(
task,
current_task("reading Vcs"),
strongly_consistent,
self,
)
self.backend
.try_read_task_output(task, current_task("reading Vcs"), consistency, self)
}
fn try_read_task_output_untracked(
&self,
task: TaskId,
strongly_consistent: bool,
consistency: ReadConsistency,
) -> Result<Result<RawVc, EventListener>> {
self.backend
.try_read_task_output_untracked(task, strongly_consistent, self)
.try_read_task_output_untracked(task, consistency, self)
}
fn try_read_task_cell(
......@@ -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
// 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?;
Ok(rx.await?)
......@@ -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
// 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?;
Ok(rx.await?)
......@@ -1694,10 +1718,10 @@ pub fn spawn_thread(func: impl FnOnce() + Send + 'static) {
pub(crate) async fn read_task_output(
this: &dyn TurboTasksApi,
id: TaskId,
strongly_consistent: bool,
consistency: ReadConsistency,
) -> Result<RawVc> {
loop {
match this.try_read_task_output(id, strongly_consistent)? {
match this.try_read_task_output(id, consistency)? {
Ok(result) => return Ok(result),
Err(listener) => listener.await,
}
......@@ -1709,10 +1733,10 @@ pub(crate) async fn read_task_output(
pub(crate) async fn read_task_output_untracked(
this: &dyn TurboTasksApi,
id: TaskId,
strongly_consistent: bool,
consistency: ReadConsistency,
) -> Result<RawVc> {
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),
Err(listener) => listener.await,
}
......
......@@ -21,7 +21,8 @@ use crate::{
TurboTasksApi,
},
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)]
......@@ -143,7 +144,7 @@ impl RawVc {
loop {
match current {
RawVc::TaskOutput(task) => {
current = read_task_output(&*tt, task, false)
current = read_task_output(&*tt, task, ReadConsistency::Eventual)
.await
.map_err(|source| ResolveTypeError::TaskError { source })?;
}
......@@ -180,15 +181,15 @@ impl RawVc {
/// See [`crate::Vc::resolve`].
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`].
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 mut current = self;
let mut notified = false;
......@@ -199,7 +200,7 @@ impl RawVc {
tt.notify_scheduled_tasks();
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::LocalCell(execution_id, local_cell_id) => {
......@@ -250,7 +251,7 @@ impl CollectiblesSource for RawVc {
pub struct ReadRawVcFuture {
turbo_tasks: Arc<dyn TurboTasksApi>,
strongly_consistent: bool,
consistency: ReadConsistency,
current: RawVc,
untracked: bool,
listener: Option<EventListener>,
......@@ -261,7 +262,7 @@ impl ReadRawVcFuture {
let tt = turbo_tasks();
ReadRawVcFuture {
turbo_tasks: tt,
strongly_consistent: false,
consistency: ReadConsistency::Eventual,
current: vc,
untracked: false,
listener: None,
......@@ -272,7 +273,7 @@ impl ReadRawVcFuture {
let tt = turbo_tasks.pin();
ReadRawVcFuture {
turbo_tasks: tt,
strongly_consistent: false,
consistency: ReadConsistency::Eventual,
current: vc,
untracked: true,
listener: None,
......@@ -283,7 +284,7 @@ impl ReadRawVcFuture {
let tt = turbo_tasks();
ReadRawVcFuture {
turbo_tasks: tt,
strongly_consistent: false,
consistency: ReadConsistency::Eventual,
current: vc,
untracked: true,
listener: None,
......@@ -294,7 +295,7 @@ impl ReadRawVcFuture {
let tt = turbo_tasks();
ReadRawVcFuture {
turbo_tasks: tt,
strongly_consistent: true,
consistency: ReadConsistency::Strong,
current: vc,
untracked: false,
listener: None,
......@@ -305,7 +306,7 @@ impl ReadRawVcFuture {
let tt = turbo_tasks();
ReadRawVcFuture {
turbo_tasks: tt,
strongly_consistent: true,
consistency: ReadConsistency::Strong,
current: vc,
untracked: true,
listener: None,
......@@ -333,17 +334,17 @@ impl Future for ReadRawVcFuture {
RawVc::TaskOutput(task) => {
let read_result = if this.untracked {
this.turbo_tasks
.try_read_task_output_untracked(task, this.strongly_consistent)
.try_read_task_output_untracked(task, this.consistency)
} else {
this.turbo_tasks
.try_read_task_output(task, this.strongly_consistent)
.try_read_task_output(task, this.consistency)
};
match read_result {
Ok(Ok(vc)) => {
// 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
// it's already strongly consistent.
this.strongly_consistent = false;
this.consistency = ReadConsistency::Eventual;
this.current = vc;
continue 'outer;
}
......
......@@ -6,7 +6,9 @@ use std::{
};
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_memory::MemoryBackend;
use turbopack_cli_utils::issue::{ConsoleUi, LogOptions};
......@@ -148,7 +150,9 @@ impl TurbopackBuildBuilder {
Ok(Default::default())
});
self.turbo_tasks.wait_task_completion(task, true).await?;
self.turbo_tasks
.wait_task_completion(task, ReadConsistency::Strong)
.await?;
Ok(())
}
......
......@@ -12,7 +12,9 @@ use anyhow::{bail, Context, Result};
use dunce::canonicalize;
use serde::Deserialize;
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_fs::{
json::parse_json_with_source_context, util::sys_to_unix, DiskFileSystem, FileSystem,
......@@ -170,7 +172,8 @@ async fn run(resource: PathBuf) -> Result<()> {
.context("Unable to handle issues")?;
Ok(Vc::<()>::default())
});
tt.wait_task_completion(task, true).await?;
tt.wait_task_completion(task, ReadConsistency::Strong)
.await?;
Ok(())
}
......
......@@ -2,7 +2,7 @@ use std::{collections::HashMap, fs, path::PathBuf};
use criterion::{Bencher, BenchmarkId, Criterion};
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_memory::MemoryBackend;
use turbopack::{
......@@ -113,7 +113,9 @@ fn bench_emit(b: &mut Bencher, bench_input: &BenchInput) {
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::{
use anyhow::Result;
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_memory::MemoryBackend;
use turbopack::{emit_with_completion, rebase::RebasedAsset, register};
......@@ -72,7 +74,9 @@ async fn main() -> Result<()> {
spawn({
let tt = tt.clone();
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()));
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