feat: dagrunner, initial version

tests/parallelism/proof.rs

@@ -0,0 +1,65 @@
+//! Parallelism proof tests
+
+use crate::common::task_fn;
+use dagx::{DagResult, DagRunner};
+use std::time::{Duration, Instant};
+use tokio::time::sleep;
+
+#[tokio::test]
+async fn test_parallelism_proof_1000_tasks() -> DagResult<()> {
+    // Proof that 1000 tasks sleeping 100ms each complete in ~100ms (not 100 seconds)
+    let dag = DagRunner::new();
+
+    let sleep_duration = Duration::from_millis(100);
+    let num_tasks = 1000u32;
+
+    // Create 1000 independent tasks that each sleep for 100ms
+    let tasks: Vec<_> = (0..num_tasks)
+        .map(|i| {
+            dag.add_task(task_fn(move |_: ()| async move {
+                sleep(sleep_duration).await;
+                i
+            }))
+        })
+        .collect();
+
+    let start = Instant::now();
+    dag.run(|fut| {
+        tokio::spawn(fut);
+    })
+    .await?;
+    let elapsed = start.elapsed();
+
+    // Verify all tasks completed
+    for (i, task) in tasks.iter().enumerate() {
+        assert_eq!(dag.get(task)?, i as u32);
+    }
+
+    // Sequential execution would take: 1000 * 100ms = 100 seconds
+    let sequential_time = sleep_duration * num_tasks;
+
+    println!(
+        "Parallelism proof: {} tasks × {}ms completed in {:?} (sequential would be {:?})",
+        num_tasks,
+        sleep_duration.as_millis(),
+        elapsed,
+        sequential_time
+    );
+
+    // Allow generous overhead: should complete in less than 500ms (not 100 seconds!)
+    assert!(
+        elapsed < Duration::from_millis(500),
+        "Tasks appear to be running sequentially! Took {:?} instead of ~100ms",
+        elapsed
+    );
+
+    // Verify we achieved massive speedup
+    let speedup = sequential_time.as_secs_f64() / elapsed.as_secs_f64();
+    assert!(
+        speedup > 200.0,
+        "Speedup too low: {:.1}x (expected > 200x)",
+        speedup
+    );
+
+    Ok(())
+}