feat: dagrunner, initial version

benches/realistic/config_broadcast.rs

@@ -0,0 +1,66 @@
+//! Configuration broadcast pattern benchmark - one config shared across many workers
+
+use criterion::{BenchmarkId, Criterion};
+use dagx::{task_fn, DagRunner};
+use std::collections::HashMap;
+use std::hint::black_box;
+
+pub fn bench_config_broadcast(c: &mut Criterion) {
+    let rt = tokio::runtime::Runtime::new().unwrap();
+    let mut group = c.benchmark_group("config_broadcast");
+
+    for worker_count in [10, 50, 100, 200].iter() {
+        group.bench_with_input(
+            BenchmarkId::new("config", worker_count),
+            worker_count,
+            |b, &workers| {
+                b.iter(|| {
+                    rt.block_on(async {
+                        let dag = DagRunner::new();
+
+                        // Configuration source - framework wraps HashMap in Arc automatically
+                        let config = dag.add_task(task_fn(|_: ()| async {
+                            HashMap::from([
+                                ("max_connections".to_string(), "100".to_string()),
+                                ("timeout_ms".to_string(), "5000".to_string()),
+                                ("batch_size".to_string(), "50".to_string()),
+                                ("retry_count".to_string(), "3".to_string()),
+                                ("worker_threads".to_string(), "4".to_string()),
+                                ("buffer_size".to_string(), "8192".to_string()),
+                                ("compression".to_string(), "true".to_string()),
+                                ("log_level".to_string(), "info".to_string()),
+                            ])
+                        }));
+
+                        // Workers receive and process based on shared config
+                        for worker_id in 0..workers {
+                            dag.add_task(task_fn(move |cfg: HashMap<String, String>| async move {
+                                // Simulate work based on configuration
+                                let batch_size: usize = cfg
+                                    .get("batch_size")
+                                    .and_then(|s| s.parse().ok())
+                                    .unwrap_or(10);
+                                let timeout: usize = cfg
+                                    .get("timeout_ms")
+                                    .and_then(|s| s.parse().ok())
+                                    .unwrap_or(1000);
+
+                                // Simulate some computation
+                                black_box(worker_id * batch_size + timeout / 100)
+                            }))
+                            .depends_on(&config);
+                        }
+
+                        dag.run(|fut| {
+                            tokio::spawn(fut);
+                        })
+                        .await
+                        .unwrap();
+                    })
+                });
+            },
+        );
+    }
+
+    group.finish();
+}