ruviz 0.4.2

High-performance 2D plotting library for Rust
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

//! Debug GPU implementation to identify performance bottlenecks

use ruviz::core::*;
use ruviz::data::*;
use ruviz::render::gpu::{GpuRenderer, initialize_gpu_backend};
use std::time::Instant;

#[tokio::main]
async fn main() -> Result<()> {
    env_logger::init();

    println!("๐Ÿ”ง GPU Debug Test");
    println!("=================\n");

    // Initialize GPU
    match initialize_gpu_backend().await {
        Ok(_) => println!("โœ… GPU Backend initialized"),
        Err(e) => {
            println!("โŒ GPU Backend failed: {}", e);
            return Ok(());
        }
    }

    let mut gpu_renderer = match GpuRenderer::new().await {
        Ok(renderer) => {
            println!(
                "โœ… GPU Renderer created, threshold: {}",
                renderer.gpu_threshold()
            );
            renderer
        }
        Err(e) => {
            println!("โŒ GPU Renderer failed: {}", e);
            return Ok(());
        }
    };

    // Test small dataset first
    let point_count = 1000;
    println!("\n๐Ÿงช Testing {} points", point_count);

    let x_data: Vec<f64> = (0..point_count).map(|i| i as f64 * 0.001).collect();
    let y_data: Vec<f64> = x_data
        .iter()
        .map(|&x| (x * 2.0 * std::f64::consts::PI).sin())
        .collect();

    let x_range = (0.0, point_count as f64 * 0.001);
    let y_range = (-1.0, 1.0);
    let viewport = (0.0, 0.0, 1920.0, 1080.0);

    println!("๐Ÿ“Š Transform Coordinates Test");
    let start = Instant::now();

    match gpu_renderer.transform_coordinates_optimal(&x_data, &y_data, x_range, y_range, viewport) {
        Ok((x_result, y_result)) => {
            let elapsed = start.elapsed();
            println!(
                "โœ… Success: {} ms, {} points transformed",
                elapsed.as_millis(),
                x_result.len()
            );
            println!(
                "   First result: x={:.3}, y={:.3}",
                x_result[0], y_result[0]
            );
            println!(
                "   Last result: x={:.3}, y={:.3}",
                x_result[x_result.len() - 1],
                y_result[y_result.len() - 1]
            );
        }
        Err(e) => {
            println!("โŒ Transform failed: {}", e);
        }
    }

    // Test medium dataset
    let point_count = 10_000;
    println!("\n๐Ÿงช Testing {} points", point_count);

    let x_data: Vec<f64> = (0..point_count).map(|i| i as f64 * 0.001).collect();
    let y_data: Vec<f64> = x_data
        .iter()
        .map(|&x| (x * 2.0 * std::f64::consts::PI).sin())
        .collect();

    println!("๐Ÿ“Š Transform Coordinates Test (larger dataset)");
    let start = Instant::now();

    match gpu_renderer.transform_coordinates_optimal(&x_data, &y_data, x_range, y_range, viewport) {
        Ok((x_result, _y_result)) => {
            let elapsed = start.elapsed();
            println!(
                "โœ… Success: {} ms, {} points transformed",
                elapsed.as_millis(),
                x_result.len()
            );
        }
        Err(e) => {
            println!("โŒ Transform failed: {}", e);
        }
    }

    // Check stats
    let stats = gpu_renderer.get_stats();
    println!("\n๐Ÿ“ˆ GPU Renderer Stats");
    println!("GPU operations: {}", stats.gpu_operations);
    println!("CPU operations: {}", stats.cpu_operations);
    println!("GPU points processed: {}", stats.gpu_points_processed);
    println!("CPU points processed: {}", stats.cpu_points_processed);
    println!("Avg GPU time: {:.1}ฮผs", stats.avg_gpu_time);
    println!("Avg CPU time: {:.1}ฮผs", stats.avg_cpu_time);

    Ok(())
}