1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-11-21 15:04:11 -05:00
denoland-deno/bench_util/js_runtime.rs
Nayeem Rahman 7a8bb3b611
fix(core): allow esm extensions not included in snapshot (#18980)
Fixes #18979.

This changes the predicate for allowing `ext:` specifier resolution from
`snapshot_loaded_and_not_snapshotting` to `ext_resolution_allowed` which
is only set to true during the extension module loading phase. Module
loaders as used in core
are now declared as `ExtModuleLoader` rather than `dyn ModuleLoader`.
2023-05-04 02:44:59 +02:00

120 lines
2.9 KiB
Rust

// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
use bencher::Bencher;
use deno_core::v8;
use deno_core::Extension;
use deno_core::JsRuntime;
use deno_core::RuntimeOptions;
use crate::profiling::is_profiling;
pub fn create_js_runtime(setup: impl FnOnce() -> Vec<Extension>) -> JsRuntime {
JsRuntime::new(RuntimeOptions {
extensions: setup(),
module_loader: None,
..Default::default()
})
}
fn loop_code(iters: u64, src: &str) -> String {
format!(r#"for(let i=0; i < {iters}; i++) {{ {src} }}"#,)
}
#[derive(Copy, Clone)]
pub struct BenchOptions {
pub benching_inner: u64,
pub profiling_inner: u64,
pub profiling_outer: u64,
}
impl Default for BenchOptions {
fn default() -> Self {
Self {
benching_inner: 1_000,
profiling_inner: 1_000,
profiling_outer: 10_000,
}
}
}
pub fn bench_js_sync(
b: &mut Bencher,
src: &str,
setup: impl FnOnce() -> Vec<Extension>,
) {
bench_js_sync_with(b, src, setup, Default::default())
}
pub fn bench_js_sync_with(
b: &mut Bencher,
src: &str,
setup: impl FnOnce() -> Vec<Extension>,
opts: BenchOptions,
) {
let mut runtime = create_js_runtime(setup);
let scope = &mut runtime.handle_scope();
// Increase JS iterations if profiling for nicer flamegraphs
let inner_iters = if is_profiling() {
opts.profiling_inner * opts.profiling_outer
} else {
opts.benching_inner
};
// Looped code
let looped_src = loop_code(inner_iters, src);
let code = v8::String::new(scope, looped_src.as_ref()).unwrap();
let script = v8::Script::compile(scope, code, None).unwrap();
// Run once if profiling, otherwise regular bench loop
if is_profiling() {
script.run(scope).unwrap();
} else {
b.iter(|| {
script.run(scope).unwrap();
});
}
}
pub fn bench_js_async(
b: &mut Bencher,
src: &str,
setup: impl FnOnce() -> Vec<Extension>,
) {
bench_js_async_with(b, src, setup, Default::default())
}
pub fn bench_js_async_with(
b: &mut Bencher,
src: &str,
setup: impl FnOnce() -> Vec<Extension>,
opts: BenchOptions,
) {
let mut runtime = create_js_runtime(setup);
let tokio_runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.unwrap();
// Looped code
let inner_iters = if is_profiling() {
opts.profiling_inner
} else {
opts.benching_inner
};
let looped = loop_code(inner_iters, src);
// Get a &'static str by leaking -- this is fine because it's benchmarking code
let src = Box::leak(looped.into_boxed_str());
if is_profiling() {
for _ in 0..opts.profiling_outer {
tokio_runtime.block_on(inner_async(src, &mut runtime));
}
} else {
b.iter(|| {
tokio_runtime.block_on(inner_async(src, &mut runtime));
});
}
}
async fn inner_async(src: &'static str, runtime: &mut JsRuntime) {
runtime.execute_script_static("inner_loop", src).unwrap();
runtime.run_event_loop(false).await.unwrap();
}