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

tests/patterns/complex.rs
+66 -73
View File
@@ -11,10 +11,10 @@ async fn test_workflow_with_conditional_paths() -> DagResult<()> {
let dag = DagRunner::new();
// Input validation
let input = dag.add_task(task_fn(|_: ()| async { 42 }));
let input = dag.add_task(task_fn::<(), _, _>(|_: ()| 42));
let validate = dag
.add_task(task_fn(|x: i32| async move {
.add_task(task_fn::<i32, _, _>(|&x: &i32| {
if x > 0 && x < 100 {
Ok(x)
} else {
@@ -25,37 +25,37 @@ async fn test_workflow_with_conditional_paths() -> DagResult<()> {
// Process valid input
let process = dag
.add_task(task_fn(|result: Result<i32, &str>| async move {
match result {
Ok(x) => x * 2,
.add_task(task_fn::<Result<_, _>, _, _>(
|result: &Result<i32, &str>| match result {
Ok(x) => *x * 2,
Err(_) => -1,
}
}))
},
))
.depends_on(validate);
// Parallel enhancement steps
let enhance1 = dag
.add_task(task_fn(|x: i32| async move { x + 10 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| x + 10))
.depends_on(process);
let enhance2 = dag
.add_task(task_fn(|x: i32| async move { x * 3 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| x * 3))
.depends_on(process);
let enhance3 = dag
.add_task(task_fn(|x: i32| async move { x - 5 }))
.add_task(task_fn::<i32, _, _>(|&x: &i32| x - 5))
.depends_on(process);
// Combine enhancements
let combine = dag
.add_task(task_fn(|(e1, e2, e3): (i32, i32, i32)| async move {
vec![e1, e2, e3]
}))
.add_task(task_fn::<(i32, i32, i32), _, _>(
|(&e1, &e2, &e3): (&i32, &i32, &i32)| vec![e1, e2, e3],
))
.depends_on((&enhance1, &enhance2, &enhance3));
// Final aggregation
let final_result = dag
.add_task(task_fn(|values: Vec<i32>| async move {
.add_task(task_fn::<Vec<_>, _, _>(|values: &Vec<i32>| {
values.iter().sum::<i32>()
}))
.depends_on(combine);
@@ -76,7 +76,7 @@ async fn test_map_reduce_pattern() -> DagResult<()> {
// Map phase: process 16 inputs in parallel
let mappers: Vec<dagx::TaskHandle<Vec<(&str, usize)>>> = (0..16)
.map(|i| {
let task = dag.add_task(task_fn(move |_: ()| async move {
let task = dag.add_task(task_fn::<(), _, _>(move |_: ()| {
// Simulate word count
vec![("word1", i % 3), ("word2", i % 5), ("word3", i % 7)]
}));
@@ -94,14 +94,23 @@ async fn test_map_reduce_pattern() -> DagResult<()> {
match deps.len() {
4 => dag
.add_task(task_fn(
.add_task(task_fn::<
(
Vec<(&str, usize)>,
Vec<(&str, usize)>,
Vec<(&str, usize)>,
Vec<(&str, usize)>,
),
_,
_,
>(
move |inputs: (
Vec<(&str, usize)>,
Vec<(&str, usize)>,
Vec<(&str, usize)>,
Vec<(&str, usize)>,
)| async move {
let mut combined = Vec::new();
&Vec<(&str, usize)>,
&Vec<(&str, usize)>,
&Vec<(&str, usize)>,
&Vec<(&str, usize)>,
)| {
let mut combined = Vec::<(&str, usize)>::new();
combined.extend(inputs.0);
combined.extend(inputs.1);
combined.extend(inputs.2);
@@ -119,11 +128,11 @@ async fn test_map_reduce_pattern() -> DagResult<()> {
let reducers: Vec<_> = shuffled
.iter()
.map(|shuffled_data| {
dag.add_task(task_fn(|data: Vec<(&str, usize)>| async move {
dag.add_task(task_fn::<Vec<_>, _, _>(|data: &Vec<(&str, usize)>| {
// Sum values by key
let mut totals = std::collections::HashMap::new();
for (key, value) in data {
*totals.entry(key).or_insert(0) += value;
*totals.entry(*key).or_insert(0) += value;
}
totals.len()
}))
@@ -133,8 +142,8 @@ async fn test_map_reduce_pattern() -> DagResult<()> {
// Final aggregation
let final_task = dag
.add_task(task_fn(
|(r1, r2, r3, r4): (usize, usize, usize, usize)| async move { r1 + r2 + r3 + r4 },
.add_task(task_fn::<(_, _, _, _), _, _>(
|(r1, r2, r3, r4): (&usize, &usize, &usize, &usize)| r1 + r2 + r3 + r4,
))
.depends_on((&reducers[0], &reducers[1], &reducers[2], &reducers[3]));
@@ -152,36 +161,30 @@ async fn test_pipeline_with_feedback() -> DagResult<()> {
let iteration_count = Arc::new(AtomicUsize::new(0));
// Initial value
let init = dag.add_task(task_fn(|_: ()| async { 1 }));
let init = dag.add_task(task_fn::<(), _, _>(|_: ()| 1));
// Stage 1: Transform
let stage1 = dag
.add_task(task_fn({
.add_task(task_fn::<i32, _, _>({
let counter = iteration_count.clone();
move |x: i32| {
move |x: &i32| {
let counter = counter.clone();
async move {
counter.fetch_add(1, Ordering::SeqCst);
x * 2
}
counter.fetch_add(1, Ordering::SeqCst);
x * 2
}
}))
.depends_on(init);
// Stage 2: Filter
let stage2 = dag
.add_task(task_fn(|x: i32| async move {
if x < 100 {
Some(x)
} else {
None
}
}))
.add_task(task_fn::<i32, _, _>(
|&x: &i32| if x < 100 { Some(x) } else { None },
))
.depends_on(stage1);
// Stage 3: Accumulate
let stage3 = dag
.add_task(task_fn(|opt: Option<i32>| async move {
.add_task(task_fn::<Option<_>, _, _>(|opt: &Option<i32>| {
opt.map(|x| x + 10).unwrap_or(0)
}))
.depends_on(stage2);
@@ -189,7 +192,7 @@ async fn test_pipeline_with_feedback() -> DagResult<()> {
// Note: Can't create actual cycles in DAG, but we simulate feedback
// by having a separate "feedback" task that would feed back in a real system
let _feedback = dag
.add_task(task_fn(|x: i32| async move {
.add_task(task_fn::<i32, _, _>(|&x: &i32| {
// In a real feedback loop, this would feed back to stage1
x / 2
}))
@@ -210,7 +213,7 @@ async fn test_scatter_gather_pattern() -> DagResult<()> {
// Scatter: distribute work to multiple workers
let source: TaskHandle<_> = dag
.add_task(task_fn(|_: ()| async {
.add_task(task_fn::<(), _, _>(|_: ()| {
vec![10, 20, 30, 40, 50, 60, 70, 80]
}))
.into();
@@ -218,7 +221,7 @@ async fn test_scatter_gather_pattern() -> DagResult<()> {
// Workers process chunks
let workers: Vec<_> = (0..4)
.map(|worker_id| {
dag.add_task(task_fn(move |data: Vec<i32>| async move {
dag.add_task(task_fn::<Vec<_>, _, _>(move |data: &Vec<i32>| {
// Each worker processes a chunk
let chunk_size = data.len() / 4;
let start = worker_id * chunk_size;
@@ -236,8 +239,8 @@ async fn test_scatter_gather_pattern() -> DagResult<()> {
// Gather: collect results from all workers
let gather = dag
.add_task(task_fn(
|(w0, w1, w2, w3): (i32, i32, i32, i32)| async move { w0 + w1 + w2 + w3 },
.add_task(task_fn::<(i32, i32, i32, i32), _, _>(
|(w0, w1, w2, w3): (&i32, &i32, &i32, &i32)| w0 + w1 + w2 + w3,
))
.depends_on((&workers[0], &workers[1], &workers[2], &workers[3]));
@@ -255,14 +258,12 @@ async fn test_fork_join_with_barriers() -> DagResult<()> {
let phase_counter = Arc::new(AtomicUsize::new(0));
// Fork phase
let parent = dag.add_task(task_fn({
let parent = dag.add_task(task_fn::<(), _, _>({
let counter = phase_counter.clone();
move |_: ()| {
let counter = counter.clone();
async move {
counter.store(1, Ordering::SeqCst);
100
}
counter.store(1, Ordering::SeqCst);
100
}
}));
@@ -273,12 +274,10 @@ async fn test_fork_join_with_barriers() -> DagResult<()> {
for i in 0..3 {
let counter = phase_counter.clone();
let task = dag
.add_task(task_fn(move |x: i32| {
.add_task(task_fn::<i32, _, _>(move |&x: &i32| {
let counter = counter.clone();
async move {
assert_eq!(counter.load(Ordering::SeqCst), 1);
x + i
}
assert_eq!(counter.load(Ordering::SeqCst), 1);
x + i
}))
.depends_on(prev1);
path1.push(task);
@@ -290,12 +289,10 @@ async fn test_fork_join_with_barriers() -> DagResult<()> {
for i in 0..3 {
let counter = phase_counter.clone();
let task = dag
.add_task(task_fn(move |x: i32| {
.add_task(task_fn::<i32, _, _>(move |&x: &i32| {
let counter = counter.clone();
async move {
assert_eq!(counter.load(Ordering::SeqCst), 1);
x * 2 + i
}
assert_eq!(counter.load(Ordering::SeqCst), 1);
x * 2 + i
}))
.depends_on(prev2);
path2.push(task);
@@ -304,28 +301,24 @@ async fn test_fork_join_with_barriers() -> DagResult<()> {
// Barrier: wait for all paths
let barrier = dag
.add_task(task_fn({
.add_task(task_fn::<(i32, i32), _, _>({
let counter = phase_counter.clone();
move |(p1, p2): (i32, i32)| {
move |(p1, p2): (&i32, &i32)| {
let counter = counter.clone();
async move {
counter.store(2, Ordering::SeqCst);
p1 + p2
}
counter.store(2, Ordering::SeqCst);
p1 + p2
}
}))
.depends_on((&path1[2], &path2[2]));
// Join phase
let join = dag
.add_task(task_fn({
.add_task(task_fn::<i32, _, _>({
let counter = phase_counter.clone();
move |x: i32| {
move |&x: &i32| {
let counter = counter.clone();
async move {
assert_eq!(counter.load(Ordering::SeqCst), 2);
x
}
assert_eq!(counter.load(Ordering::SeqCst), 2);
x
}
}))
.depends_on(barrier);