feat: added benchmark

src/main.rs

@@ -1,4 +1,184 @@
+use stopwatch::Stopwatch;
+use tokio::io::AsyncWriteExt;
+use tokio::process;
+
 #[tokio::main]
-async fn main() -> anyhow::Result<()> {
+async fn main() -> eyre::Result<()> {
+    tracing_subscriber::fmt().pretty().init();
+
+    let client = dagger_sdk::connect().await?;
+
+    let (tx, mut rx) = tokio::sync::mpsc::channel(4);
+
+    async_scoped::TokioScope::scope_and_block(|s| {
+        let dclient = client.clone();
+        let dtx = tx.clone();
+        s.spawn(async move {
+            let dclient = dclient.pipeline("build-image");
+            tracing::info!("building 1. complete image");
+
+            let sw = Stopwatch::start_new();
+            let src = dclient
+                .host()
+                .directory_opts(
+                    "bench_app",
+                    dagger_sdk::HostDirectoryOptsBuilder::default()
+                        .exclude(vec!["target/"])
+                        .build()
+                        .unwrap(),
+                )
+                .id()
+                .await
+                .unwrap();
+
+            let _ = dclient
+                .container()
+                .from("rustlang/rust:nightly")
+                .with_directory("/mnt/app", src)
+                .with_workdir("/mnt/app")
+                .with_exec(vec!["cargo", "build", "--release"])
+                .with_exec(vec!["target/release/bench_app", "bench"])
+                .exit_code()
+                .await
+                .unwrap();
+
+            dtx.send(format!(
+                "1. build-image: {}",
+                sw.elapsed_ms() as f64 / 1000.0
+            ))
+            .await
+            .unwrap();
+        });
+
+        let dclient = client.clone();
+        let dtx = tx.clone();
+        s.spawn(async move {
+            let dclient = dclient.pipeline("pull-image");
+            tracing::info!("building 2. pull image");
+            let sw = Stopwatch::start_new();
+
+            if let Err(e) = process::Command::new("docker")
+                .args(&[
+                    "image",
+                    "rm",
+                    "kasperhermansen/dagger-runtime-benchmark:latest",
+                ])
+                .output()
+                .await
+            {
+                tracing::warn!(msg = e.to_string(), "failed to delete image");
+            }
+
+            let _ = dclient
+                .container()
+                .from("kasperhermansen/dagger-runtime-benchmark:latest")
+                .with_exec(vec!["/usr/bin/bench_app", "bench"])
+                .exit_code()
+                .await
+                .unwrap();
+            dtx.send(format!(
+                "2. pull-image: {}",
+                sw.elapsed_ms() as f64 / 1000.0
+            ))
+            .await
+            .unwrap();
+        });
+
+        let dclient = client.clone();
+        let dtx = tx.clone();
+        s.spawn(async move {
+            let dclient = dclient.pipeline("run-wasm");
+            tracing::info!("building 3. pull wasm");
+            let sw = Stopwatch::start_new();
+
+            let src = dclient
+                .host()
+                .directory(".")
+                .file("dist/wasm/bench_app.wasm")
+                .id()
+                .await
+                .unwrap();
+
+            if let Err(e) = process::Command::new("docker")
+                .args(&["image", "rm", "kasperhermansen/dagger-wasmer:latest"])
+                .output()
+                .await
+            {
+                tracing::warn!(msg = e.to_string(), "failed to delete image");
+            }
+
+            let _ = dclient
+                .container()
+                .from("kasperhermansen/dagger-wasmer:latest")
+                .with_file("/usr/bin/bench_app.wasm", src)
+                .with_exec(vec!["wasmer", "run", "/usr/bin/bench_app.wasm", "bench"])
+                .exit_code()
+                .await
+                .unwrap();
+
+            dtx.send(format!("3. run-wasm: {}", sw.elapsed_ms() as f64 / 1000.0))
+                .await
+                .unwrap();
+        });
+
+        let dclient = client.clone();
+        let dtx = tx.clone();
+        s.spawn(async move {
+            let dclient = dclient.pipeline("run-binary");
+            tracing::info!("building 4. run binary");
+            let sw = Stopwatch::start_new();
+
+            let src = dclient
+                .host()
+                .directory(".")
+                .file("dist/binary/bench_app")
+                .id()
+                .await
+                .unwrap();
+
+            if let Err(e) = process::Command::new("docker")
+                .args(&["image", "rm", "debian:bullseye-slim"])
+                .output()
+                .await
+            {
+                tracing::warn!(msg = e.to_string(), "failed to delete image");
+            }
+
+            let _ = dclient
+                .container()
+                .from("debian:bullseye-slim")
+                .with_file("/usr/bin/bench_app", src)
+                .with_exec(vec!["/usr/bin/bench_app", "bench"])
+                .exit_code()
+                .await
+                .unwrap();
+
+            dtx.send(format!(
+                "4. run-binary: {}",
+                sw.elapsed_ms() as f64 / 1000.0
+            ))
+            .await
+            .unwrap();
+        });
+    });
+
+    drop(tx);
+
+    let mut file = tokio::fs::File::create("reports/timings.md").await?;
+    file.write_all(b"# Dagger runtime benchmark results\n")
+        .await?;
+
+    let mut results = Vec::new();
+    while let Some(res) = rx.recv().await {
+        results.push(res);
+    }
+    results.sort();
+
+    for res in results {
+        file.write_all(format!("{}\n", res).as_bytes()).await?;
+    }
+
+    file.sync_all().await?;
+
     Ok(())
 }