swaits/dagx
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update tests, examples, benches

Browse Source
This commit is contained in:
TechnoPorg committed 2026-02-11 22:01:50 +01:00
1 parent 0137296fb4
commit 86787b3a0d
71 files changed
+1791 -3547
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

benches/basic/execution.rs
+21 -21
View File
@@ -12,7 +12,7 @@ pub fn bench_dag_execution(c: &mut Criterion) {
rt.block_on(async {
let dag = DagRunner::new();
for i in 0..10 {
dag.add_task(task_fn(move |_: ()| async move { i }));
dag.add_task(task_fn::<(), _, _>(move |_: ()| { i }));
}
dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
.await
@@ -26,7 +26,7 @@ pub fn bench_dag_execution(c: &mut Criterion) {
rt.block_on(async {
let dag = DagRunner::new();
for i in 0..100 {
dag.add_task(task_fn(move |_: ()| async move { i }));
dag.add_task(task_fn::<(), _, _>(move |_: ()| { i }));
}
dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
.await
@@ -51,61 +51,61 @@ pub fn bench_dag_execution(c: &mut Criterion) {
let t0 = dag.add_task(Value(0));
let t1 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t0);
let t2 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t1);
let t3 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t2);
let t4 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t3);
let t5 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t4);
let t6 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t5);
let t7 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t6);
let t8 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t7);
let t9 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t8);
let t10 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t9);
let t11 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t10);
let t12 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t11);
let t13 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t12);
let t14 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t13);
let t15 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t14);
let t16 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t15);
let t17 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t16);
let t18 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t17);
let _t19 = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(t18);
dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
benches/basic/scaling.rs
+1 -1
View File
@@ -17,7 +17,7 @@ pub fn bench_dag_scaling(c: &mut Criterion) {
rt.block_on(async {
let dag = DagRunner::new();
for i in 0..size {
dag.add_task(task_fn(move |_: ()| async move { i }));
dag.add_task(task_fn::<(), _, _>(move |_: ()| { i }));
}
dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
.await
benches/comparisons/deep_chain.rs
+3 -3
View File
@@ -18,14 +18,14 @@ pub fn bench_deep_chain(c: &mut Criterion) {
let dag = DagRunner::new();
let first: TaskHandle<_> = dag.add_task(task_fn(|_: ()| async { 0 })).into();
let first: TaskHandle<_> = dag.add_task(task_fn::<(), _, _>(|_: ()| { 0 })).into();
let mut prev = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(first);
for i in 2..100 {
prev = dag
.add_task(task_fn(move |x: i32| async move { x + i }))
.add_task(task_fn::<i32, _, _>(move |&x: &i32| { x + i }))
.depends_on(prev);
}
benches/comparisons/diamond_pattern.rs
+4 -4
View File
@@ -18,15 +18,15 @@ pub fn bench_diamond_pattern(c: &mut Criterion) {
let dag = DagRunner::new();
let a: TaskHandle<_> = dag.add_task(task_fn(|_: ()| async { 10 })).into();
let a: TaskHandle<_> = dag.add_task(task_fn::<(), _, _>(|_: ()| 10)).into();
let b = dag
.add_task(task_fn(|x: i32| async move { x * 2 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| x * 2))
.depends_on(a);
let c = dag
.add_task(task_fn(|x: i32| async move { x + 5 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| x + 5))
.depends_on(a);
let d = dag
.add_task(task_fn(|(x, y): (i32, i32)| async move { x + y }))
.add_task(task_fn::<(i32, i32), _, _>(|(x, y): (&i32, &i32)| x + y))
.depends_on((&b, &c));
dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
benches/comparisons/etl_pipeline.rs
+15 -12
View File
@@ -18,34 +18,34 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
let dag = DagRunner::new();
// Extract from 3 sources
let source1 = dag.add_task(task_fn(|_: ()| async { vec![1, 2, 3, 4, 5] }));
let source2 = dag.add_task(task_fn(|_: ()| async { vec![6, 7, 8, 9, 10] }));
let source3 = dag.add_task(task_fn(|_: ()| async { vec![11, 12, 13, 14, 15] }));
let source1 = dag.add_task(task_fn::<(), _, _>(|_: ()| vec![1, 2, 3, 4, 5]));
let source2 = dag.add_task(task_fn::<(), _, _>(|_: ()| vec![6, 7, 8, 9, 10]));
let source3 = dag.add_task(task_fn::<(), _, _>(|_: ()| vec![11, 12, 13, 14, 15]));
// Transform each source
let transform1 = dag
.add_task(task_fn(|data: Vec<i32>| async move {
.add_task(task_fn::<Vec<_>, _, _>(|data: &Vec<i32>| {
data.into_iter().map(|x| x * 2).collect::<Vec<_>>()
}))
.depends_on(source1);
let transform2 = dag
.add_task(task_fn(|data: Vec<i32>| async move {
.add_task(task_fn::<Vec<_>, _, _>(|data: &Vec<i32>| {
data.into_iter().map(|x| x * 2).collect::<Vec<_>>()
}))
.depends_on(source2);
let transform3 = dag
.add_task(task_fn(|data: Vec<i32>| async move {
.add_task(task_fn::<Vec<_>, _, _>(|data: &Vec<i32>| {
data.into_iter().map(|x| x * 2).collect::<Vec<_>>()
}))
.depends_on(source3);
// Merge all transformed data
let merge = dag
.add_task(task_fn(
|(d1, d2, d3): (Vec<i32>, Vec<i32>, Vec<i32>)| async move {
let mut result = d1;
.add_task(task_fn::<(Vec<_>, Vec<_>, Vec<_>), _, _>(
|(d1, d2, d3): (&Vec<i32>, &Vec<i32>, &Vec<i32>)| {
let mut result = d1.clone();
result.extend(d2);
result.extend(d3);
result
@@ -55,14 +55,17 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
// Validate
let validate = dag
.add_task(task_fn(|data: Vec<i32>| async move {
data.into_iter().filter(|&x| x > 0).collect::<Vec<_>>()
.add_task(task_fn::<Vec<_>, _, _>(|data: &Vec<i32>| {
data.iter()
.copied()
.filter(|&x| x > 0)
.collect::<Vec<i32>>()
}))
.depends_on(merge);
// Load (compute sum)
let load = dag
.add_task(task_fn(|data: Vec<i32>| async move {
.add_task(task_fn::<Vec<_>, _, _>(|data: &Vec<i32>| {
data.into_iter().sum::<i32>()
}))
.depends_on(validate);
benches/comparisons/large_scale.rs
+1 -1
View File
@@ -19,7 +19,7 @@ pub fn bench_large_scale(c: &mut Criterion) {
let dag = DagRunner::new();
for i in 0..10_000 {
dag.add_task(task_fn(move |_: ()| async move { i * 2 }));
dag.add_task(task_fn::<(), _, _>(move |_: ()| { i * 2 }));
}
dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
benches/comparisons/linear_pipeline.rs
+5 -5
View File
@@ -17,18 +17,18 @@ pub fn bench_linear_pipeline(c: &mut Criterion) {
let dag = DagRunner::new();
let a = dag.add_task(task_fn(|_: ()| async { 1 }));
let a = dag.add_task(task_fn::<(), _, _>(|_: ()| { 1 }));
let b = dag
.add_task(task_fn(|x: i32| async move { x + 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
.depends_on(a);
let c = dag
.add_task(task_fn(|x: i32| async move { x * 2 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x * 2 }))
.depends_on(b);
let d = dag
.add_task(task_fn(|x: i32| async move { x - 1 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x - 1 }))
.depends_on(c);
let e = dag
.add_task(task_fn(|x: i32| async move { x * 3 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| { x * 3 }))
.depends_on(d);
dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
benches/comparisons/wide_fanout.rs
+2 -2
View File
@@ -17,11 +17,11 @@ pub fn bench_wide_fanout(c: &mut Criterion) {
use dagx::{task_fn, DagRunner};
let dag = DagRunner::new();
let source: TaskHandle<_> = dag.add_task(task_fn(|_: ()| async { 42 })).into();
let source: TaskHandle<_> = dag.add_task(task_fn::<(), _, _>(|_: ()| { 42 })).into();
// Create 100 tasks that all depend on source
for i in 0..100 {
dag.add_task(task_fn(move |x: i32| async move { x + i }))
dag.add_task(task_fn::<i32, _, _>(move |&x: &i32| { x + i }))
.depends_on(source);
}
benches/patterns/breakdown.rs
+3 -3
View File
@@ -14,7 +14,7 @@ pub fn bench_10k_breakdown(c: &mut Criterion) {
b.iter(|| {
let dag = DagRunner::new();
for i in 0..10_000 {
dag.add_task(task_fn(move |_: ()| async move { i }));
dag.add_task(task_fn::<(), _, _>(move |_: ()| { i }));
}
});
});
@@ -25,7 +25,7 @@ pub fn bench_10k_breakdown(c: &mut Criterion) {
rt.block_on(async {
let dag = DagRunner::new();
for i in 0..10_000 {
dag.add_task(task_fn(move |_: ()| async move { i }));
dag.add_task(task_fn::<(), _, _>(move |_: ()| { i }));
}
dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
.await
@@ -39,7 +39,7 @@ pub fn bench_10k_breakdown(c: &mut Criterion) {
// Pre-build the DAG outside the measurement
let dag = DagRunner::new();
for i in 0..10_000 {
dag.add_task(task_fn(move |_: ()| async move { i }));
dag.add_task(task_fn::<(), _, _>(move |_: ()| { i }));
}
b.iter(|| {
benches/patterns/diamond.rs
+4 -4
View File
@@ -14,16 +14,16 @@ pub fn bench_diamond(c: &mut Criterion) {
for i in 0..50 {
let source: TaskHandle<_> =
dag.add_task(task_fn(move |_: ()| async move { i })).into();
dag.add_task(task_fn::<(), _, _>(move |_: ()| i)).into();
let left = dag
.add_task(task_fn(|x: i32| async move { x * 2 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| x * 2))
.depends_on(source);
let right = dag
.add_task(task_fn(|x: i32| async move { x * 3 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| x * 3))
.depends_on(source);
dag.add_task(task_fn(|(l, r): (i32, i32)| async move { l + r }))
dag.add_task(task_fn::<(i32, i32), _, _>(|(l, r): (&i32, &i32)| l + r))
.depends_on((&left, &right));
}
benches/patterns/fanout.rs
+7 -6
View File
@@ -12,10 +12,10 @@ pub fn bench_fanout(c: &mut Criterion) {
b.iter(|| {
rt.block_on(async {
let dag = DagRunner::new();
let source: TaskHandle<_> = dag.add_task(task_fn(|_: ()| async { 42 })).into();
let source: TaskHandle<_> = dag.add_task(task_fn::<(), _, _>(|_: ()| 42)).into();
for i in 0..100 {
dag.add_task(task_fn(move |x: i32| async move { x + i }))
dag.add_task(task_fn::<i32, _, _>(move |&x: &i32| x + i))
.depends_on(source);
}
@@ -32,14 +32,14 @@ pub fn bench_fanout(c: &mut Criterion) {
rt.block_on(async {
let dag = DagRunner::new();
let source: TaskHandle<_> = dag
.add_task(task_fn(|_: ()| async {
.add_task(task_fn::<(), _, _>(|_: ()| {
// Create 1000 strings - framework wraps in Arc automatically
(0..1000).map(|i| format!("Item {}", i)).collect::<Vec<_>>()
}))
.into();
for i in 0..100 {
dag.add_task(task_fn(move |data: Vec<String>| async move {
dag.add_task(task_fn::<Vec<_>, _, _>(move |data: &Vec<String>| {
// Each consumer gets data extracted from Arc
data.iter().filter(|s| s.contains(&i.to_string())).count()
}))
@@ -63,11 +63,12 @@ pub fn bench_fanout(c: &mut Criterion) {
// Source produces a simple Copy type (usize)
// Framework wraps in Arc<usize> internally
let source: TaskHandle<_> = dag.add_task(task_fn(|_: ()| async { 42usize })).into();
let source: TaskHandle<_> =
dag.add_task(task_fn::<(), _, _>(|_: ()| 42usize)).into();
// 100 dependents - Arc overhead visible on Copy types
for i in 0..100 {
dag.add_task(task_fn(move |x: usize| async move { x + i }))
dag.add_task(task_fn::<usize, _, _>(move |x: &usize| x + i))
.depends_on(source);
}
benches/realistic/config_broadcast.rs
+16 -14
View File
@@ -21,7 +21,7 @@ pub fn bench_config_broadcast(c: &mut Criterion) {
// Configuration source - framework wraps HashMap in Arc automatically
let config: TaskHandle<_> = dag
.add_task(task_fn(|_: ()| async {
.add_task(task_fn::<(), _, _>(|_: ()| {
HashMap::from([
("max_connections".to_string(), "100".to_string()),
("timeout_ms".to_string(), "5000".to_string()),
@@ -37,20 +37,22 @@ pub fn bench_config_broadcast(c: &mut Criterion) {
// 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);
dag.add_task(task_fn::<HashMap<_, _>, _, _>(
move |cfg: &HashMap<String, String>| {
// 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)
}))
// Simulate some computation
black_box(worker_id * batch_size + timeout / 100)
},
))
.depends_on(config);
}
benches/realistic/etl.rs
+22 -20
View File
@@ -21,24 +21,26 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
let dag = DagRunner::new();
// Extract: Load JSON-like data (framework wraps in Arc automatically)
let extract: TaskHandle<_> = dag.add_task(task_fn(move |_: ()| async move {
(0..count)
.map(|i| {
format!(
"{{\"id\":{},\"name\":\"User{}\",\"score\":{}}}",
i,
i,
i * 10
)
})
.collect::<Vec<_>>()
})).into();
let extract: TaskHandle<_> = dag
.add_task(task_fn::<(), _, _>(move |_: ()| {
(0..count)
.map(|i| {
format!(
"{{\"id\":{},\"name\":\"User{}\",\"score\":{}}}",
i,
i,
i * 10
)
})
.collect::<Vec<_>>()
}))
.into();
// Transform: Three parallel transformations
// T1: Parse and validate
let validate = dag
.add_task(task_fn(move |data: Vec<String>| async move {
.add_task(task_fn::<Vec<_>, _, _>(move |data: &Vec<String>| {
data.iter()
.filter(|s| {
s.contains("\"id\"")
@@ -51,7 +53,7 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
// T2: Extract scores
let scores = dag
.add_task(task_fn(move |data: Vec<String>| async move {
.add_task(task_fn::<Vec<_>, _, _>(move |data: &Vec<String>| {
data.iter()
.filter_map(|s| {
s.split("\"score\":").nth(1).and_then(|part| {
@@ -64,7 +66,7 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
// T3: Extract names
let names = dag
.add_task(task_fn(move |data: Vec<String>| async move {
.add_task(task_fn::<Vec<_>, _, _>(move |data: &Vec<String>| {
data.iter()
.filter_map(|s| {
s.split("\"name\":\"")
@@ -77,8 +79,8 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
.depends_on(extract);
// Load: Aggregate all transformations
dag.add_task(task_fn(
move |(valid, scores, names): (usize, Vec<i32>, Vec<String>)| async move {
dag.add_task(task_fn::<(usize, Vec<_>, Vec<_>), _, _>(
move |(valid, scores, names): (&usize, &Vec<i32>, &Vec<String>)| {
let avg_score =
scores.iter().sum::<i32>() / scores.len().max(1) as i32;
format!(
@@ -91,9 +93,9 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
))
.depends_on((&validate, &scores, &names));
dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
.await
.unwrap();
dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
.await
.unwrap();
})
});
},
benches/realistic/memory_efficiency.rs
+2 -2
View File
@@ -20,7 +20,7 @@ pub fn bench_memory_efficiency(c: &mut Criterion) {
let dag = DagRunner::new();
let source: TaskHandle<_> = dag
.add_task(task_fn(move |_: ()| async move {
.add_task(task_fn::<(), _, _>(move |_: ()| {
// Create MB of data - framework wraps in Arc automatically
vec![0u8; mb * 1024 * 1024]
}))
@@ -28,7 +28,7 @@ pub fn bench_memory_efficiency(c: &mut Criterion) {
// 20 consumers share the data via automatic Arc wrapping
for i in 0..20 {
dag.add_task(task_fn(move |data: Vec<u8>| async move {
dag.add_task(task_fn::<Vec<_>, _, _>(move |data: &Vec<u8>| {
// Process a small portion (data extracted from Arc)
let sample_sum: u32 = data
.iter()
benches/realistic/mixed.rs
+10 -8
View File
@@ -14,7 +14,7 @@ pub fn bench_mixed_patterns(c: &mut Criterion) {
// Stage 1: Load data (framework wraps in Arc automatically)
let data: TaskHandle<_> = dag
.add_task(task_fn(|_: ()| async {
.add_task(task_fn::<(), _, _>(|_: ()| {
(0..1000)
.map(|i| format!("Record-{:04}", i))
.collect::<Vec<_>>()
@@ -23,31 +23,33 @@ pub fn bench_mixed_patterns(c: &mut Criterion) {
// Stage 2: Fan-out for parallel analysis
let analysis1 = dag
.add_task(task_fn(|d: Vec<String>| async move {
.add_task(task_fn::<Vec<_>, _, _>(|d: &Vec<String>| {
d.iter().filter(|s| s.contains("00")).count()
}))
.depends_on(data);
let analysis2 = dag
.add_task(task_fn(|d: Vec<String>| async move {
.add_task(task_fn::<Vec<_>, _, _>(|d: &Vec<String>| {
d.iter().map(|s| s.len()).sum::<usize>()
}))
.depends_on(data);
let analysis3 = dag
.add_task(task_fn(|d: Vec<String>| async move { d.len() }))
.add_task(task_fn::<Vec<_>, _, _>(|d: &Vec<String>| d.len()))
.depends_on(data);
// Stage 3: Fan-in to aggregate
let summary = dag
.add_task(task_fn(|(a1, a2, a3): (usize, usize, usize)| async move {
format!("Matches: {}, Total bytes: {}, Count: {}", a1, a2, a3)
}))
.add_task(task_fn::<(usize, usize, usize), _, _>(
|(a1, a2, a3): (&usize, &usize, &usize)| {
format!("Matches: {}, Total bytes: {}, Count: {}", a1, a2, a3)
},
))
.depends_on((&analysis1, &analysis2, &analysis3));
// Stage 4: Fan-out final report to multiple destinations
for i in 0..3 {
dag.add_task(task_fn(move |report: String| async move {
dag.add_task(task_fn::<String, _, _>(move |report: &String| {
format!("Destination {}: {}", i, report)
}))
.depends_on(summary);