103 lines
3.1 KiB
Rust
103 lines
3.1 KiB
Rust
//! Stress tests and benchmarks
|
|
|
|
use crate::common::task_fn;
|
|
use dagx::DagRunner;
|
|
|
|
use std::sync::Arc;
|
|
use std::time::{Duration, Instant};
|
|
|
|
#[tokio::test]
|
|
async fn test_deep_chain_100_levels() {
|
|
let dag = Arc::new(DagRunner::new());
|
|
|
|
// Create a chain 100 levels deep
|
|
let start = Instant::now();
|
|
let first = dag.add_task(task_fn::<(), _, _>(|_: ()| 0));
|
|
let mut handles = vec![first.into()];
|
|
|
|
for _ in 1..=100 {
|
|
let next = dag
|
|
.add_task(task_fn::<i32, _, _>(move |&x: &i32| x + 1))
|
|
.depends_on(handles.last().unwrap());
|
|
handles.push(next);
|
|
}
|
|
let build_time = start.elapsed();
|
|
|
|
println!("Built 100-level chain in {:?}", build_time);
|
|
|
|
// Execute
|
|
let start = Instant::now();
|
|
dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
|
|
.await
|
|
.unwrap();
|
|
let exec_time = start.elapsed();
|
|
|
|
println!("Executed 100-level chain in {:?}", exec_time);
|
|
assert!(
|
|
exec_time < Duration::from_secs(5),
|
|
"Execution took too long"
|
|
);
|
|
|
|
// Verify result
|
|
assert_eq!(dag.get(handles.last().unwrap()).unwrap(), 100);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_stress_mixed_patterns() {
|
|
// Stress test with mixed DAG patterns
|
|
let dag = Arc::new(DagRunner::new());
|
|
let mut all_tasks = vec![];
|
|
|
|
// Add various patterns
|
|
for i in 0..10 {
|
|
// Linear chains
|
|
let first = dag.add_task(task_fn::<(), _, _>(move |_: ()| i * 1000));
|
|
let mut chain_handles = vec![first.into()];
|
|
for j in 1..10 {
|
|
let next = dag
|
|
.add_task(task_fn::<i32, _, _>(move |&x: &i32| x + j))
|
|
.depends_on(chain_handles.last().unwrap());
|
|
chain_handles.push(next);
|
|
}
|
|
all_tasks.push(*chain_handles.last().unwrap());
|
|
|
|
// Diamonds
|
|
let source = dag.add_task(task_fn::<(), _, _>(move |_: ()| i * 100));
|
|
let source_handle: dagx::TaskHandle<i32> = source.into();
|
|
let left = dag
|
|
.add_task(task_fn::<i32, _, _>(|&x: &i32| x * 2))
|
|
.depends_on(source_handle);
|
|
let right = dag
|
|
.add_task(task_fn::<i32, _, _>(|&x: &i32| x * 3))
|
|
.depends_on(source_handle);
|
|
let merge = dag
|
|
.add_task(task_fn::<(i32, i32), _, _>(|(l, r): (&i32, &i32)| l + r))
|
|
.depends_on((&left, &right));
|
|
all_tasks.push(merge);
|
|
|
|
// Fan-outs
|
|
let hub = dag.add_task(task_fn::<(), _, _>(move |_: ()| i));
|
|
let hub_handle: dagx::TaskHandle<i32> = hub.into();
|
|
for j in 0..5 {
|
|
let fan = dag
|
|
.add_task(task_fn::<i32, _, _>(move |&x: &i32| x + j * 10))
|
|
.depends_on(hub_handle);
|
|
all_tasks.push(fan);
|
|
}
|
|
}
|
|
|
|
// Execute
|
|
let start = Instant::now();
|
|
dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
|
|
.await
|
|
.unwrap();
|
|
let exec_time = start.elapsed();
|
|
|
|
println!("Executed mixed pattern stress test in {:?}", exec_time);
|
|
|
|
// Verify some results
|
|
for task in all_tasks.iter().take(10) {
|
|
assert!(dag.get(task).is_ok());
|
|
}
|
|
}
|