veda-rs 1.0.0

High-performance parallel runtime for Rust with work-stealing and adaptive scheduling
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

//! Deterministic execution for debugging and testing

#[cfg(feature = "deterministic")]
use veda_rs::prelude::*;

#[cfg(feature = "deterministic")]
fn complex_computation(x: i32) -> i32 {
    let mut result = x;
    for i in 1..10 {
        result = result.wrapping_mul(i).wrapping_add(x);
    }
    result
}

#[cfg(feature = "deterministic")]
fn main() {
    println!("=== Deterministic Execution Example ===\n");
    
    let seed = 42;
    
    // Configure deterministic mode
    let config = veda_rs::Config::builder()
        .scheduling_policy(veda_rs::SchedulingPolicy::Deterministic { seed })
        .num_threads(4)
        .build()
        .expect("Failed to build config");
    
    veda_rs::init_with_config(config).expect("Failed to initialize");
    
    println!("Running with deterministic seed: {}", seed);
    
    // Run 1
    let result1: Vec<i32> = (0..100)
        .into_par_iter()
        .map(complex_computation)
        .collect();
    
    println!("First run complete: {} results", result1.len());
    
    veda_rs::shutdown();
    
    // Run 2 with same seed
    let config2 = veda_rs::Config::builder()
        .scheduling_policy(veda_rs::SchedulingPolicy::Deterministic { seed })
        .num_threads(4)
        .build()
        .expect("Failed to build config");
    
    veda_rs::init_with_config(config2).expect("Failed to initialize");
    
    let result2: Vec<i32> = (0..100)
        .into_par_iter()
        .map(complex_computation)
        .collect();
    
    println!("Second run complete: {} results", result2.len());
    
    // Verify determinism
    let identical = result1 == result2;
    println!("\nResults identical: {}", identical);
    
    if identical {
        println!("✓ Deterministic execution verified!");
    } else {
        println!("✗ Results differ (this shouldn't happen)");
    }
    
    veda_rs::shutdown();
    println!("\n=== Example Complete ===");
}

#[cfg(not(feature = "deterministic"))]
fn main() {
    eprintln!("This example requires the 'deterministic' feature.");
    eprintln!("Run with: cargo run --example deterministic_debug --features deterministic");
}