mirror of
https://github.com/hanzoai/next.js.git
synced 2026-10-30 14:46:38 +00:00
f65b10a54d
### What? Replace the `async fn resolve()`, `async fn resolve_strongly_consistent()`, and `async fn to_resolved()` methods on `RawVc`, `Vc<T>`, and `OperationVc<T>` with hand-written custom `Future` implementations, following the existing `ReadRawVcFuture` pattern. New types: - **`ResolveRawVcFuture`** (`raw_vc.rs`) — core implementation, replaces `async fn resolve_inner()` - **`ResolveVcFuture<T>`** (`vc/mod.rs`) — typed wrapper over `ResolveRawVcFuture`, returned by `Vc::resolve()` - **`ResolveOperationVcFuture<T>`** (`vc/operation.rs`) — typed wrapper, returned by `OperationVc::resolve()` - **`ToResolvedVcFuture<T>`** (`vc/mod.rs`) — typed wrapper, returned by `Vc::to_resolved()` All new future types expose a `.strongly_consistent()` builder method, enabling `resolve_strongly_consistent()` to be replaced by `.resolve().strongly_consistent()` at call sites. `ReadRawVcFuture` is also updated to delegate its phase-1 resolve loop to `ResolveRawVcFuture` instead of duplicating the logic. `std::task::ready!` is used throughout to simplify poll implementations. Also adds `#[inline(never)]` to `ReadRawVcFuture::poll` and `ResolveRawVcFuture::poll` to avoid inlining large poll implementations into every await site. ### Why? Performance, binary size, and improved API ergonomics: - The hand-written `Future` pattern (already used by `ReadRawVcFuture`) gives the compiler more predictable, smaller code than the state machines generated for `async fn`. The `#[inline(never)]` attributes on `poll` prevent large poll bodies from being duplicated at every await site, which the async desugaring otherwise allows. - The new builder API (`.resolve().strongly_consistent()`) is more composable and removes the need for separate `_strongly_consistent` method variants, reducing the number of methods on `RawVc`/`Vc`/`OperationVc`. - Having `ReadRawVcFuture` delegate to `ResolveRawVcFuture` removes the duplicated resolve loop and ensures both paths stay in sync. ### How? - `ResolveRawVcFuture` stores `current: RawVc`, `read_output_options: ReadOutputOptions`, `strongly_consistent: bool`, and `listener: Option<EventListener>`. Its `poll` replicates the loop from the old `resolve_inner` using `try_read_task_output` / `try_read_local_output`. - On `Err(listener)` from a `try_*` call, the listener is stored in `self.listener` and `Poll::Pending` is returned. At the top of the loop, `ready!(poll_listener(...))` re-polls it and short-circuits if still pending. - Consistency is downgraded to `Eventual` after the first `TaskOutput` hop, matching the previous behavior. - `strongly_consistent: true` keeps the `SUPPRESS_EVENTUAL_CONSISTENCY_TOP_LEVEL_TASK_CHECK` suppression across all polls (same logic as `ReadRawVcFuture`). - `ReadRawVcFuture` now holds a `ResolveRawVcFuture` for phase 1 and drives it via `Pin::new(&mut self.resolve).poll(cx)` before proceeding to the cell read in phase 2. This eliminates the duplicated loop that previously existed in both types. - Typed wrappers (`ResolveVcFuture<T>`, `ResolveOperationVcFuture<T>`, `ToResolvedVcFuture<T>`) delegate `poll` to the inner `ResolveRawVcFuture` and map the output to the appropriate typed result. - `OperationVc::resolve_strongly_consistent()` is removed; 16 call sites updated to `.resolve().strongly_consistent()`. - All new types implement `Unpin` and are exported from `lib.rs`. - `std::task::ready!` is used in all `poll` implementations to reduce boilerplate. No behavioral changes — this is a pure implementation refactor. ### Binary size impact A release build (`pnpm swc-build-native --release`) was measured before and after the branch changes on the same merge-base commit (`a41bef94`): | | Size | |---|---| | Base (`a41bef94`, before branch) | 199,690,656 bytes (~190.4 MB) | | Branch (`6f7846f9`, after changes) | 199,252,384 bytes (~190.0 MB) | | **Difference** | **−438,272 bytes (−428 KB, −0.22%)** | The branch produces a slightly smaller binary. The reduction comes primarily from the `#[inline(never)]` attributes preventing large `poll` bodies from being duplicated at every await site. --------- Co-authored-by: Tobias Koppers <[email protected]> Co-authored-by: Claude <[email protected]>
85 lines
2.4 KiB
Rust
85 lines
2.4 KiB
Rust
#![feature(arbitrary_self_types)]
|
|
#![feature(arbitrary_self_types_pointers)]
|
|
#![allow(clippy::needless_return)] // tokio macro-generated code doesn't respect this
|
|
|
|
use anyhow::Result;
|
|
use turbo_tasks::{ResolvedVc, State, Vc};
|
|
use turbo_tasks_testing::{Registration, register, run};
|
|
|
|
static REGISTRATION: Registration = register!();
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn test_emptied_cells() {
|
|
run(®ISTRATION, || async {
|
|
let input_op = get_state_operation();
|
|
let input_vc = input_op.resolve().strongly_consistent().await?;
|
|
let input = input_op.read_strongly_consistent().await?;
|
|
input.state.set(0);
|
|
|
|
let output = compute_operation(input_vc);
|
|
assert_eq!(*output.read_strongly_consistent().await?, 0);
|
|
|
|
println!("changing input");
|
|
input.state.set(10);
|
|
assert_eq!(*output.read_strongly_consistent().await?, 10);
|
|
|
|
println!("changing input");
|
|
input.state.set(5);
|
|
assert_eq!(*output.read_strongly_consistent().await?, 5);
|
|
|
|
println!("changing input");
|
|
input.state.set(20);
|
|
assert_eq!(*output.read_strongly_consistent().await?, 20);
|
|
|
|
println!("changing input");
|
|
input.state.set(15);
|
|
assert_eq!(*output.read_strongly_consistent().await?, 15);
|
|
|
|
println!("changing input");
|
|
input.state.set(1);
|
|
assert_eq!(*output.read_strongly_consistent().await?, 1);
|
|
|
|
anyhow::Ok(())
|
|
})
|
|
.await
|
|
.unwrap();
|
|
}
|
|
|
|
#[turbo_tasks::function(operation)]
|
|
fn get_state_operation() -> Vc<ChangingInput> {
|
|
ChangingInput {
|
|
state: State::new(0),
|
|
}
|
|
.cell()
|
|
}
|
|
|
|
#[turbo_tasks::value]
|
|
struct ChangingInput {
|
|
state: State<u32>,
|
|
}
|
|
|
|
#[turbo_tasks::function(operation)]
|
|
async fn compute_operation(input: ResolvedVc<ChangingInput>) -> Result<Vc<u32>> {
|
|
println!("compute_operation()");
|
|
let value = *inner_compute(*input).await?;
|
|
Ok(Vc::cell(value))
|
|
}
|
|
|
|
#[turbo_tasks::function]
|
|
async fn inner_compute(input: Vc<ChangingInput>) -> Result<Vc<u32>> {
|
|
println!("inner_compute()");
|
|
let state_value = *input.await?.state.get();
|
|
let mut last = None;
|
|
for i in 0..=state_value {
|
|
last = Some(compute2(Vc::cell(i)));
|
|
}
|
|
Ok(last.unwrap())
|
|
}
|
|
|
|
#[turbo_tasks::function]
|
|
async fn compute2(input: Vc<u32>) -> Result<Vc<u32>> {
|
|
println!("compute2()");
|
|
let value = *input.await?;
|
|
Ok(Vc::cell(value))
|
|
}
|