Unverified Commit 1c08a029 authored by Niklas Mischkulnig's avatar Niklas Mischkulnig Committed by GitHub

Turbopack: add benchmark for JS analysis (#83042)

```
full/full/packages/next/dist/compiled/babel-packages/packages-bundle.js
                        time:   [176.60 ms 177.59 ms 178.86 ms]
Found 5 outliers among 100 measurements (5.00%)
  2 (2.00%) high mild
  3 (3.00%) high severe
full/full/node_modules/.pnpm/react-dom@19.2.0-canary-03fda05d-20250820_react@19.2.0-canary-03fda05d-...
                        time:   [65.679 ms 66.265 ms 67.000 ms]
                        Performance has improved.
Found 5 outliers among 100 measurements (5.00%)
  2 (2.00%) high mild
  3 (3.00%) high severe
```
parent c9d4a974
...@@ -9768,6 +9768,7 @@ dependencies = [ ...@@ -9768,6 +9768,7 @@ dependencies = [
"turbo-esregex", "turbo-esregex",
"turbo-rcstr", "turbo-rcstr",
"turbo-tasks", "turbo-tasks",
"turbo-tasks-backend",
"turbo-tasks-build", "turbo-tasks-build",
"turbo-tasks-fs", "turbo-tasks-fs",
"turbo-tasks-hash", "turbo-tasks-hash",
...@@ -9776,6 +9777,7 @@ dependencies = [ ...@@ -9776,6 +9777,7 @@ dependencies = [
"turbopack-core", "turbopack-core",
"turbopack-resolve", "turbopack-resolve",
"turbopack-swc-utils", "turbopack-swc-utils",
"turbopack-test-utils",
"url", "url",
] ]
......
...@@ -76,8 +76,10 @@ swc_core = { workspace = true, features = [ ...@@ -76,8 +76,10 @@ swc_core = { workspace = true, features = [
[dev-dependencies] [dev-dependencies]
criterion = { workspace = true, features = ["async_tokio"] } criterion = { workspace = true, features = ["async_tokio"] }
turbo-tasks-backend = { workspace = true }
turbo-tasks-malloc = { workspace = true } turbo-tasks-malloc = { workspace = true }
turbo-tasks-testing = { workspace = true } turbo-tasks-testing = { workspace = true }
turbopack-test-utils = { workspace = true }
[build-dependencies] [build-dependencies]
turbo-tasks-build = { workspace = true } turbo-tasks-build = { workspace = true }
......
use std::{path::PathBuf, sync::Arc, time::Duration};
use criterion::{Bencher, BenchmarkId, Criterion};
use turbo_rcstr::rcstr;
use turbo_tasks::{ResolvedVc, TurboTasks};
use turbo_tasks_backend::{
BackendOptions, BackingStorage, TurboTasksBackend, noop_backing_storage,
};
use turbo_tasks_fs::{DiskFileSystem, FileSystem};
use turbopack_core::{
compile_time_info::CompileTimeInfo,
environment::{Environment, ExecutionEnvironment, NodeJsEnvironment},
file_source::FileSource,
ident::Layer,
};
use turbopack_ecmascript::{
EcmascriptInputTransforms, EcmascriptModuleAsset, EcmascriptOptions, TreeShakingMode,
references::analyse_ecmascript_module_internal,
};
use turbopack_test_utils::noop_asset_context::NoopAssetContext;
pub fn benchmark(c: &mut Criterion) {
turbopack_ecmascript::register();
turbopack_test_utils::register();
let rt = tokio::runtime::Builder::new_current_thread()
.build()
.unwrap();
let tt = TurboTasks::new(TurboTasksBackend::new(
BackendOptions {
dependency_tracking: false,
storage_mode: None,
..Default::default()
},
noop_backing_storage(),
));
let cases = rt
.block_on(tt.run_once(async {
let root_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../../");
let fs = DiskFileSystem::new(rcstr!("project"), root_dir.to_str().unwrap().into());
let environment = Environment::new(ExecutionEnvironment::NodeJsLambda(
NodeJsEnvironment::default().resolved_cell(),
));
let compile_time_info = CompileTimeInfo::new(environment).to_resolved().await?;
let layer = Layer::new(rcstr!("test"));
let module_asset_context = NoopAssetContext {
compile_time_info,
layer,
}
.resolved_cell();
let mut cases = vec![];
for file in [
r#"packages/next/dist/compiled/babel-packages/packages-bundle.js"#,
r#"node_modules/.pnpm/react-dom@19.2.0-canary-03fda05d-20250820_react@19.2.0-canary-03fda05d-20250820/node_modules/react-dom/cjs/react-dom-client.development.js"#,
] {
let module = EcmascriptModuleAsset::builder(
ResolvedVc::upcast(
FileSource::new(fs.root().await?.join(file).unwrap())
.to_resolved()
.await?,
),
ResolvedVc::upcast(module_asset_context),
EcmascriptInputTransforms::empty().to_resolved().await?,
EcmascriptOptions {
tree_shaking_mode: Some(TreeShakingMode::ReexportsOnly),
..Default::default()
}
.resolved_cell(),
compile_time_info,
)
.build()
.to_resolved()
.await?;
cases.push((file, module));
}
anyhow::Ok(cases)
}))
.unwrap();
let mut group = c.benchmark_group("full");
group.warm_up_time(Duration::from_secs(1));
group.measurement_time(Duration::from_secs(20));
for case in cases {
group.bench_with_input(
BenchmarkId::new("full", case.0),
&BenchInput {
module: case.1,
storage: tt.clone(),
},
bench_full,
);
}
}
struct BenchInput<B>
where
B: BackingStorage,
{
storage: Arc<TurboTasks<TurboTasksBackend<B>>>,
module: ResolvedVc<EcmascriptModuleAsset>,
}
fn bench_full<B>(b: &mut Bencher, input: &BenchInput<B>)
where
B: BackingStorage,
{
let rt = tokio::runtime::Builder::new_current_thread()
.build()
.unwrap();
b.to_async(rt).iter(|| {
input
.storage
.run_once(analyse_ecmascript_module_internal(input.module, None))
});
}
...@@ -3,6 +3,8 @@ extern crate turbo_tasks_malloc; ...@@ -3,6 +3,8 @@ extern crate turbo_tasks_malloc;
use criterion::{criterion_group, criterion_main}; use criterion::{criterion_group, criterion_main};
mod analyzer; mod analyzer;
mod full;
criterion_group!(analyzer_benches, analyzer::benchmark); criterion_group!(analyzer_benches, analyzer::benchmark);
criterion_main!(analyzer_benches); criterion_group!(full_benches, full::benchmark);
criterion_main!(analyzer_benches, full_benches);
...@@ -499,7 +499,7 @@ pub(crate) async fn analyse_ecmascript_module( ...@@ -499,7 +499,7 @@ pub(crate) async fn analyse_ecmascript_module(
} }
} }
pub(crate) async fn analyse_ecmascript_module_internal( pub async fn analyse_ecmascript_module_internal(
module: ResolvedVc<EcmascriptModuleAsset>, module: ResolvedVc<EcmascriptModuleAsset>,
part: Option<ModulePart>, part: Option<ModulePart>,
) -> Result<Vc<AnalyzeEcmascriptModuleResult>> { ) -> Result<Vc<AnalyzeEcmascriptModuleResult>> {
......
...@@ -3,4 +3,13 @@ ...@@ -3,4 +3,13 @@
#![feature(arbitrary_self_types_pointers)] #![feature(arbitrary_self_types_pointers)]
pub mod jest; pub mod jest;
pub mod noop_asset_context;
pub mod snapshot; pub mod snapshot;
pub fn register() {
turbo_tasks::register();
turbo_tasks_fs::register();
turbopack_core::register();
turbopack_cli_utils::register();
include!(concat!(env!("OUT_DIR"), "/register.rs"));
}
use anyhow::Result;
use turbo_rcstr::{RcStr, rcstr};
use turbo_tasks::{ResolvedVc, Vc};
use turbo_tasks_fs::{FileSystemPath, glob::Glob};
use turbopack_core::{
compile_time_info::CompileTimeInfo,
context::{AssetContext, ProcessResult},
ident::Layer,
reference_type::ReferenceType,
resolve::{ModuleResolveResult, ResolveResult, options::ResolveOptions, parse::Request},
source::Source,
};
#[turbo_tasks::value(shared)]
pub struct NoopAssetContext {
pub compile_time_info: ResolvedVc<CompileTimeInfo>,
pub layer: Layer,
}
#[turbo_tasks::value_impl]
impl AssetContext for NoopAssetContext {
#[turbo_tasks::function]
fn compile_time_info(&self) -> Vc<CompileTimeInfo> {
*self.compile_time_info
}
fn layer(&self) -> Layer {
self.layer.clone()
}
#[turbo_tasks::function]
async fn resolve_options(
self: Vc<Self>,
_origin_path: FileSystemPath,
_reference_type: ReferenceType,
) -> Result<Vc<ResolveOptions>> {
Ok(ResolveOptions::default().cell())
}
#[turbo_tasks::function]
async fn resolve_asset(
self: Vc<Self>,
_origin_path: FileSystemPath,
_request: Vc<Request>,
_resolve_options: Vc<ResolveOptions>,
_reference_type: ReferenceType,
) -> Result<Vc<ModuleResolveResult>> {
Ok(*ModuleResolveResult::unresolvable())
}
#[turbo_tasks::function]
async fn process_resolve_result(
self: Vc<Self>,
_result: Vc<ResolveResult>,
_reference_type: ReferenceType,
) -> Result<Vc<ModuleResolveResult>> {
Ok(*ModuleResolveResult::unresolvable())
}
#[turbo_tasks::function]
async fn process(
self: Vc<Self>,
_asset: ResolvedVc<Box<dyn Source>>,
_reference_type: ReferenceType,
) -> Result<Vc<ProcessResult>> {
Ok(ProcessResult::Ignore.cell())
}
#[turbo_tasks::function]
async fn with_transition(
self: Vc<Self>,
_transition: RcStr,
) -> Result<Vc<Box<dyn AssetContext>>> {
Ok(Vc::upcast(self))
}
#[turbo_tasks::function]
async fn side_effect_free_packages(&self) -> Result<Vc<Glob>> {
Ok(Glob::new(rcstr!(""), Default::default()))
}
}
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