avx-async 0.5.0

Revolutionary async runtime - Quantum, Neural Networks, Blockchain, Genetic Algorithms, Zero dependencies
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Example: Edge Computing Task Distribution
//!
//! Demonstrates distributed task execution across edge nodes

use avx_async::{Runtime, EdgeManager, EdgeNode, DistributionStrategy, sleep};
use std::time::{Duration, Instant};

fn main() {
    let rt = Runtime::new();

    rt.spawn(async {
        println!("🌐 Edge Computing Task Distribution");
        println!("====================================\n");

        // Create edge manager
        let manager = EdgeManager::new("edge-001", "us-east");
        println!("✅ Created local edge node: edge-001 (us-east)\n");

        // Register remote edge nodes
        println!("📡 Registering remote edge nodes...\n");

        manager.register_node(EdgeNode {
            node_id: "edge-002".to_string(),
            region: "us-west".to_string(),
            location: "San Francisco".to_string(),
            last_seen: Instant::now(),
            latency_ms: 80,
            is_healthy: true,
            max_threads: 8,
            available_threads: 6,
            queue_capacity: 1024,
            current_load: 0.3,
            tasks_processed: 1250,
            total_uptime: Duration::from_secs(3600),
            avg_response_time: Duration::from_millis(15),
        });

        manager.register_node(EdgeNode {
            node_id: "edge-003".to_string(),
            region: "eu-west".to_string(),
            location: "London".to_string(),
            last_seen: Instant::now(),
            latency_ms: 120,
            is_healthy: true,
            max_threads: 16,
            available_threads: 10,
            queue_capacity: 2048,
            current_load: 0.5,
            tasks_processed: 3400,
            total_uptime: Duration::from_secs(7200),
            avg_response_time: Duration::from_millis(20),
        });

        manager.register_node(EdgeNode {
            node_id: "edge-004".to_string(),
            region: "ap-south".to_string(),
            location: "Singapore".to_string(),
            last_seen: Instant::now(),
            latency_ms: 200,
            is_healthy: true,
            max_threads: 12,
            available_threads: 9,
            queue_capacity: 1536,
            current_load: 0.2,
            tasks_processed: 890,
            total_uptime: Duration::from_secs(1800),
            avg_response_time: Duration::from_millis(25),
        });

        // Display healthy nodes
        println!("🟢 Healthy Edge Nodes:");
        for node in manager.healthy_nodes() {
            println!("  {}", node);
        }

        // Test different distribution strategies
        println!("\n📊 Distribution Strategies:\n");

        let task_count = 1000;

        // Strategy 1: Latency-Based
        if let Some(best_node) = manager.find_best_node(DistributionStrategy::LatencyBased) {
            println!("🎯 Latency-Based: Best node is '{}'", best_node);
        }

        // Strategy 2: Load-Based
        if let Some(best_node) = manager.find_best_node(DistributionStrategy::LoadBased) {
            println!("⚖️  Load-Based: Best node is '{}'", best_node);
        }

        // Strategy 3: Round-Robin Distribution
        let distribution = manager.distribute_tasks(task_count, DistributionStrategy::RoundRobin);
        println!("\n🔄 Round-Robin Distribution of {} tasks:", task_count);
        println!("  Local: {} tasks", distribution.local_tasks);
        for remote in &distribution.remote_tasks {
            println!("  {}: {} tasks ({})",
                remote.node_id,
                remote.task_count,
                remote.reason
            );
        }

        // Strategy 4: Load-Based Distribution
        let distribution = manager.distribute_tasks(task_count, DistributionStrategy::LoadBased);
        println!("\n⚖️  Load-Based Distribution of {} tasks:", task_count);
        println!("  Local: {} tasks", distribution.local_tasks);
        for remote in &distribution.remote_tasks {
            println!("  {}: {} tasks ({})",
                remote.node_id,
                remote.task_count,
                remote.reason
            );
        }

        // Simulate load changes
        println!("\n📈 Simulating load changes...\n");
        manager.update_node_load("edge-002", 0.8);
        manager.update_node_load("edge-003", 0.9);
        manager.update_node_load("edge-004", 0.1);

        sleep(Duration::from_millis(100)).await;

        // Re-evaluate after load change
        let distribution = manager.distribute_tasks(task_count, DistributionStrategy::LoadBased);
        println!("📊 Updated Load-Based Distribution:");
        println!("  Local: {} tasks", distribution.local_tasks);
        for remote in &distribution.remote_tasks {
            println!("  {}: {} tasks ({})",
                remote.node_id,
                remote.task_count,
                remote.reason
            );
        }

        // Export topology
        println!("\n📄 Edge Topology JSON:");
        println!("{}", manager.to_json());

        println!("\n✅ Edge computing demo complete!");
    });

    rt.run();
}