test: add vm benchmarks

ristretto_classloader/benches/class_loader.rs

@@ -1,5 +1,5 @@
 use criterion::{criterion_group, criterion_main, Criterion};
-use ristretto_classloader::{runtime, Result};
+use ristretto_classloader::{runtime, ClassLoader, Result};
 use std::sync::Arc;
 use tokio::runtime::Runtime;
 
@@ -9,35 +9,16 @@ fn benchmarks(criterion: &mut Criterion) {
 
 fn bench_lifecycle(criterion: &mut Criterion) -> Result<()> {
     let runtime = Runtime::new()?;
-    let (_java_home, _version, class_loader) =
-        runtime.block_on(async { runtime::version_class_loader("21.0.6.7.1").await })?;
+    let class_loader = runtime.block_on(async { default_class_loader().await })?;
     let class_loader = Arc::new(class_loader);
 
-    criterion.bench_function("runtime_v8", |bencher| {
+    criterion.bench_function("default_class_loader", |bencher| {
         bencher.iter(|| {
             runtime.block_on(async {
-                boot_class_loader("8.442.06.1").await.ok();
-            });
-        });
-    });
-    criterion.bench_function("runtime_v11", |bencher| {
-        bencher.iter(|| {
-            runtime.block_on(async {
-                boot_class_loader("11.0.26.4.1").await.ok();
-            });
-        });
-    });
-    criterion.bench_function("runtime_v17", |bencher| {
-        bencher.iter(|| {
-            runtime.block_on(async {
-                boot_class_loader("17.0.13.11.1").await.ok();
-            });
-        });
-    });
-    criterion.bench_function("runtime_v21", |bencher| {
-        bencher.iter(|| {
-            runtime.block_on(async {
-                boot_class_loader("21.0.6.7.1").await.ok();
+                let class_loader = default_class_loader()
+                    .await
+                    .expect("Failed to create class loader");
+                let _class = class_loader.load("java.lang.Object").await.ok();
             });
         });
     });
@@ -59,10 +40,10 @@ fn bench_lifecycle(criterion: &mut Criterion) -> Result<()> {
     Ok(())
 }
 
-async fn boot_class_loader(version: &str) -> Result<()> {
-    let (_java_home, _java_version, class_loader) = runtime::version_class_loader(version).await?;
-    let _class = class_loader.load("java.lang.Object").await?;
-    Ok(())
+async fn default_class_loader() -> Result<Arc<ClassLoader>> {
+    let (_java_home, _version, class_loader) = runtime::default_class_loader().await?;
+    let class_loader = Arc::new(class_loader);
+    Ok(class_loader)
 }
 
 criterion_group!(

ristretto_vm/Cargo.toml

@@ -50,3 +50,7 @@ rustls-tls = [
 url = [
     "ristretto_classloader/url",
 ]
+
+[[bench]]
+harness = false
+name = "vm"

ristretto_vm/benches/vm.rs

@@ -0,0 +1,69 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use ristretto_classfile::Error;
+use ristretto_classloader::ClassPath;
+use ristretto_vm::{ConfigurationBuilder, Result, VM};
+use std::path::PathBuf;
+use tokio::runtime::Runtime;
+
+const CARGO_MANIFEST: &str = env!("CARGO_MANIFEST_DIR");
+
+fn benchmarks(criterion: &mut Criterion) {
+    bench_lifecycle(criterion).ok();
+}
+
+fn bench_lifecycle(criterion: &mut Criterion) -> Result<()> {
+    let runtime = Runtime::new().map_err(|error| Error::IoError(error.to_string()))?;
+
+    criterion.bench_function("vm_init", |bencher| {
+        bencher.iter(|| {
+            runtime.block_on(async {
+                vm_init().await.ok();
+            });
+        });
+    });
+    criterion.bench_function("hello_world", |bencher| {
+        bencher.iter(|| {
+            runtime.block_on(async {
+                hello_world().await.ok();
+            });
+        });
+    });
+
+    Ok(())
+}
+
+async fn vm_init() -> Result<()> {
+    let cargo_manifest = PathBuf::from(CARGO_MANIFEST);
+    let classes_jar_path = cargo_manifest
+        .join("..")
+        .join("classes")
+        .join("classes.jar");
+    let class_path = ClassPath::from(classes_jar_path.to_string_lossy());
+    let configuration = ConfigurationBuilder::new().class_path(class_path).build()?;
+    let _ = VM::new(configuration).await?;
+    Ok(())
+}
+
+async fn hello_world() -> Result<()> {
+    let cargo_manifest = PathBuf::from(CARGO_MANIFEST);
+    let classes_jar_path = cargo_manifest
+        .join("..")
+        .join("classes")
+        .join("classes.jar");
+    let class_path = ClassPath::from(classes_jar_path.to_string_lossy());
+    let configuration = ConfigurationBuilder::new()
+        .class_path(class_path)
+        .main_class("HelloWorld")
+        .build()?;
+    let vm = VM::new(configuration).await?;
+    let parameters: Vec<&str> = Vec::new();
+    let _result = vm.invoke_main(parameters).await?;
+    Ok(())
+}
+
+criterion_group!(
+    name = benches;
+    config = Criterion::default();
+    targets = benchmarks
+);
+criterion_main!(benches);