feat: 添加基准测试基础设施

crates/oxide_vm/Cargo.toml

@@ -26,3 +26,24 @@ tracing.workspace = true
 oxide_compiler = { path = "../oxide_compiler" }
 proptest.workspace = true
 oxide_parser = { path = "../oxide_parser" }
+criterion = { version = "0.5", features = ["html_reports"] }
+
+[[bench]]
+name = "dispatch"
+harness = false
+
+[[bench]]
+name = "property"
+harness = false
+
+[[bench]]
+name = "coercion"
+harness = false
+
+[[bench]]
+name = "gc_mark_sweep"
+harness = false
+
+[[bench]]
+name = "call"
+harness = false

crates/oxide_vm/benches/call.rs

@@ -0,0 +1,27 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use oxide_compiler::compiler::Compiler;
+use oxide_kernel::kernel::{KernelConfig, KernelCore};
+use oxide_vm::vm::Vm;
+use std::sync::Arc;
+
+fn bench_call(c: &mut Criterion) {
+    let kernel = KernelCore::new(KernelConfig::minimal());
+    let js = "function fib(n) { if (n < 2) return n; return fib(n-1) + fib(n-2); } fib(15);";
+    let alloc = oxide_parser::Allocator::default();
+    let program = oxide_parser::parse(&alloc, js).expect("parse");
+    let module = Compiler.compile(&program).expect("compile");
+
+    c.bench_function("call", |b| {
+        b.iter_batched(
+            || Vm::with_kernel_core(Arc::clone(&kernel)),
+            |mut vm| {
+                vm.run(&module).ok();
+                black_box(vm)
+            },
+            criterion::BatchSize::SmallInput,
+        );
+    });
+}
+
+criterion_group!(benches, bench_call);
+criterion_main!(benches);

crates/oxide_vm/benches/coercion.rs

@@ -0,0 +1,27 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use oxide_compiler::compiler::Compiler;
+use oxide_kernel::kernel::{KernelConfig, KernelCore};
+use oxide_vm::vm::Vm;
+use std::sync::Arc;
+
+fn bench_coercion(c: &mut Criterion) {
+    let kernel = KernelCore::new(KernelConfig::minimal());
+    let js = "var x = \"42\"; var y = \"3.14\"; var r = 0; for (var i = 0; i < 5000; i++) { r += (+x) + (+y); } r";
+    let alloc = oxide_parser::Allocator::default();
+    let program = oxide_parser::parse(&alloc, js).expect("parse");
+    let module = Compiler.compile(&program).expect("compile");
+
+    c.bench_function("coercion", |b| {
+        b.iter_batched(
+            || Vm::with_kernel_core(Arc::clone(&kernel)),
+            |mut vm| {
+                vm.run(&module).ok();
+                black_box(vm)
+            },
+            criterion::BatchSize::SmallInput,
+        );
+    });
+}
+
+criterion_group!(benches, bench_coercion);
+criterion_main!(benches);

crates/oxide_vm/benches/dispatch.rs

@@ -0,0 +1,27 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use oxide_compiler::compiler::Compiler;
+use oxide_kernel::kernel::{KernelConfig, KernelCore};
+use oxide_vm::vm::Vm;
+use std::sync::Arc;
+
+fn bench_dispatch(c: &mut Criterion) {
+    let kernel = KernelCore::new(KernelConfig::minimal());
+    let js = "var x = 0; for (var i = 0; i < 10000; i++) { x = x + i - i * 2 + (i % 3); } x";
+    let alloc = oxide_parser::Allocator::default();
+    let program = oxide_parser::parse(&alloc, js).expect("parse");
+    let module = Compiler.compile(&program).expect("compile");
+
+    c.bench_function("dispatch", |b| {
+        b.iter_batched(
+            || Vm::with_kernel_core(Arc::clone(&kernel)),
+            |mut vm| {
+                vm.run(&module).ok();
+                black_box(vm)
+            },
+            criterion::BatchSize::SmallInput,
+        );
+    });
+}
+
+criterion_group!(benches, bench_dispatch);
+criterion_main!(benches);

crates/oxide_vm/benches/gc_mark_sweep.rs

@@ -0,0 +1,29 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use oxide_compiler::compiler::Compiler;
+use oxide_kernel::kernel::{KernelConfig, KernelCore};
+use oxide_vm::vm::Vm;
+use std::sync::Arc;
+
+fn bench_gc(c: &mut Criterion) {
+    let mut config = KernelConfig::minimal();
+    config.session_gc_threshold = 1024 * 1024;
+    let kernel = KernelCore::new(config);
+    let js = "var g = {}; for (var i = 0; i < 500; i++) { var obj = { x: i, y: i * 2 }; g[i] = obj; } g[\"x\"]";
+    let alloc = oxide_parser::Allocator::default();
+    let program = oxide_parser::parse(&alloc, js).expect("parse");
+    let module = Compiler.compile(&program).expect("compile");
+
+    c.bench_function("gc_mark_sweep", |b| {
+        b.iter_batched(
+            || Vm::with_kernel_core(Arc::clone(&kernel)),
+            |mut vm| {
+                vm.run(&module).ok();
+                black_box(vm)
+            },
+            criterion::BatchSize::SmallInput,
+        );
+    });
+}
+
+criterion_group!(benches, bench_gc);
+criterion_main!(benches);

crates/oxide_vm/benches/property.rs

@@ -0,0 +1,27 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use oxide_compiler::compiler::Compiler;
+use oxide_kernel::kernel::{KernelConfig, KernelCore};
+use oxide_vm::vm::Vm;
+use std::sync::Arc;
+
+fn bench_property(c: &mut Criterion) {
+    let kernel = KernelCore::new(KernelConfig::minimal());
+    let js = "var obj = { a: 1, b: 2, c: 3, d: 4, e: 5 }; var sum = 0; for (var i = 0; i < 10000; i++) { sum += obj.a + obj.b + obj.c + obj.d + obj.e; } sum";
+    let alloc = oxide_parser::Allocator::default();
+    let program = oxide_parser::parse(&alloc, js).expect("parse");
+    let module = Compiler.compile(&program).expect("compile");
+
+    c.bench_function("property", |b| {
+        b.iter_batched(
+            || Vm::with_kernel_core(Arc::clone(&kernel)),
+            |mut vm| {
+                vm.run(&module).ok();
+                black_box(vm)
+            },
+            criterion::BatchSize::SmallInput,
+        );
+    });
+}
+
+criterion_group!(benches, bench_property);
+criterion_main!(benches);

crates/oxide_vm/src/dispatch/property.rs

@@ -203,8 +203,10 @@ impl Vm {
 
         if let Some(value) = ic_get_hit(obj, cached_shape_id, cached_slot) {
             self.regs[a] = value;
+            self.ic_hits.set(self.ic_hits.get() + 1);
             ic_trace!("IC_GET hit shape={} slot={}", cached_shape_id, cached_slot);
         } else if let Some(template) = self.kernel_core.prop_forge().get_template(obj.shape_id()) {
+            self.ic_misses.set(self.ic_misses.get() + 1);
             prop_cache_miss();
             if template.prop_name == prop_name_si {
                 if template.position < obj.prop_vec_len() as u32 {
@@ -271,13 +273,16 @@ impl Vm {
         let cached_slot = ext1;
 
         if ic_set_hit(obj, cached_shape_id, cached_slot, value) {
+            self.ic_hits.set(self.ic_hits.get() + 1);
             ic_trace!("IC_SET hit shape={} slot={}", cached_shape_id, cached_slot);
         } else if let Some(pos) = self.kernel_core.shape_forge().lookup_position(obj.shape_id(), prop_name_si) {
+            self.ic_misses.set(self.ic_misses.get() + 1);
             prop_cache_miss();
             obj.set_prop_at(pos, value);
             self.write_ic_back(obj.shape_id(), pos);
             ic_debug!("IC_SET write-back shape={} slot={}", obj.shape_id(), pos);
         } else {
+            self.ic_misses.set(self.ic_misses.get() + 1);
             prop_cache_miss();
             let old_shape = obj.shape_id();
             self.ordinary_set_dispatch(obj, prop_name_si, value, receiver)?;

crates/oxide_vm/src/vm.rs

@@ -180,6 +180,9 @@ pub struct Vm {
     /// The dispatch loop checks this flag and skips writing `regs[target_reg]` from the
     /// call result — the value will be delivered by the RETURN handler instead.
     pub(crate) accessor_frame_target_reg: Option<u8>,
+    pub(crate) ic_hits: std::cell::Cell<u64>,
+    pub(crate) ic_misses: std::cell::Cell<u64>,
+    pub(crate) instruction_count: u64,
 }
 
 impl Vm {
@@ -328,6 +331,43 @@ impl Vm {
         &self.session_gc
     }
 
+    pub fn session_object_count(&self) -> usize {
+        self.session_object_ptrs.len()
+    }
+
+    pub fn session_bytes_allocated(&self) -> usize {
+        self.session_bytes_allocated
+    }
+
+    pub fn epoch_object_count(&self) -> usize {
+        self.epoch_object_ptrs.len()
+    }
+
+    pub fn ic_hit_rate(&self) -> f64 {
+        let total = self.ic_hits.get() + self.ic_misses.get();
+        if total == 0 {
+            0.0
+        } else {
+            self.ic_hits.get() as f64 / total as f64
+        }
+    }
+
+    pub fn instruction_count(&self) -> u64 {
+        self.instruction_count
+    }
+
+    pub fn symbol_registry_len(&self) -> usize {
+        self.symbol_registry.len()
+    }
+
+    pub fn ic_hit_count(&self) -> u64 {
+        self.ic_hits.get()
+    }
+
+    pub fn ic_miss_count(&self) -> u64 {
+        self.ic_misses.get()
+    }
+
     pub(crate) fn checked_object_ptr(
         &mut self, val: JsValue, error_msg: &str,
     ) -> Result<Option<*mut JsObject>, String> {
@@ -649,10 +689,12 @@ impl Vm {
             steps += 1;
             if let Some(max_steps) = self.kernel_core.config.max_steps {
                 if steps > max_steps {
+                    self.instruction_count = steps;
                     return Err(format!("VM step limit exceeded at pc={}", self.pc));
                 }
             }
             if self.pc >= self.bytecode.len() {
+                self.instruction_count = steps;
                 return Err("program counter out of bounds".into());
             }
 
@@ -666,7 +708,10 @@ impl Vm {
             match op {
                 OpCode::NOP => {}
 
-                OpCode::HALT => return Ok(self.regs[0]),
+                OpCode::HALT => {
+                    self.instruction_count = steps;
+                    return Ok(self.regs[0]);
+                }
 
                 OpCode::LOAD_CONST => {
                     self.dispatch_load_const(rd, instr)?;

crates/oxide_vm/src/vm_support.rs

@@ -54,6 +54,9 @@ impl Vm {
             active_reg_limit: 0,
             native_call_depth: 0,
             accessor_frame_target_reg: None,
+            ic_hits: std::cell::Cell::new(0),
+            ic_misses: std::cell::Cell::new(0),
+            instruction_count: 0,
         }
     }
 
@@ -96,6 +99,9 @@ impl Vm {
             active_reg_limit: 0,
             native_call_depth: 0,
             accessor_frame_target_reg: None,
+            ic_hits: std::cell::Cell::new(0),
+            ic_misses: std::cell::Cell::new(0),
+            instruction_count: 0,
         }
     }