archx 3.0.1

High-performance CPU/GPU adaptive optimization library with SIMD and Multithreading
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

use std::future::Future;
use std::pin::Pin;
use crate::system::{add_advanced, WorkloadHints};

/// Asynchronous implementation of the vectorized addition operation.
/// 
/// This function avoids blocking the calling thread by offloading the 
/// computation to a background task. It automatically selects between 
/// GPU-accelerated and multi-threaded CPU paths based on the provided `WorkloadHints`.
///
/// # Returns
/// A `Future` that resolves to a `Vec<f32>` containing the element-wise sum of `a` and `b`.
pub fn add_async(a: Vec<f32>, b: Vec<f32>, hints: WorkloadHints) -> Pin<Box<dyn Future<Output = Vec<f32>> + Send>> {
    let _scope = crate::profiler::ProfileScope::new("Async Operation", "CPU", "Async");
    Box::pin(async move {
        // 1. Try GPU async path if preferred
        if hints.prefer_gpu {
            let gpu_res = crate::gpu::with_backend(|backend: &dyn crate::gpu::GpuBackend| {
                backend.add_async(a.clone(), b.clone())
            });
            
            if let Some(fut) = gpu_res {
                if let Ok(res) = fut.await {
                    return res;
                }
            }
        }

        // 2. Fallback to CPU execution (wrapped in a blocking task)
        // Note: For a real library, we'd use tokio::spawn_blocking or similar.
        // Here we'll simulate it using a standard thread for demo purposes 
        // to keep dependencies minimal.
        let (tx, rx) = std::sync::mpsc::channel();
        std::thread::spawn(move || {
            let mut out = vec![0.0; a.len()];
            add_advanced(&a, &b, &mut out, hints);
            let _ = tx.send(out);
        });
        
        rx.recv().unwrap_or_else(|_| Vec::new())
    })
}