oxirs-vec 0.2.4

Vector index abstractions for semantic similarity and AI-augmented querying
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
149
150
151
152
153

//! CUDA runtime types and utilities

use std::time::Duration;

/// CUDA stream wrapper
#[derive(Debug)]
pub struct CudaStream {
    pub handle: *mut std::ffi::c_void,
    pub device_id: i32,
}

unsafe impl Send for CudaStream {}
unsafe impl Sync for CudaStream {}

impl CudaStream {
    pub fn new(device_id: i32) -> anyhow::Result<Self> {
        #[cfg(all(feature = "cuda", cuda_runtime_available))]
        {
            let _ = device_id;
            // CUDA functionality temporarily disabled for compilation compatibility
            // TODO: Implement proper CUDA runtime integration
            Err(anyhow::anyhow!("CUDA support needs proper implementation"))
        }

        #[cfg(not(all(feature = "cuda", cuda_runtime_available)))]
        {
            Ok(Self {
                handle: std::ptr::null_mut(),
                device_id,
            })
        }
    }

    pub fn synchronize(&self) -> anyhow::Result<()> {
        #[cfg(all(feature = "cuda", cuda_runtime_available))]
        {
            // CUDA functionality temporarily disabled
            Err(anyhow::anyhow!("CUDA support needs proper implementation"))
        }

        #[cfg(not(all(feature = "cuda", cuda_runtime_available)))]
        {
            Ok(())
        }
    }
}

impl Drop for CudaStream {
    fn drop(&mut self) {
        #[cfg(all(feature = "cuda", cuda_runtime_available))]
        {
            // CUDA cleanup temporarily disabled
        }
    }
}

/// CUDA kernel wrapper
#[derive(Debug)]
pub struct CudaKernel {
    pub function: *mut std::ffi::c_void,
    pub module: *mut std::ffi::c_void,
    pub name: String,
}

unsafe impl Send for CudaKernel {}
unsafe impl Sync for CudaKernel {}

impl CudaKernel {
    #[allow(unused_variables)]
    pub fn load(ptx_code: &str, function_name: &str) -> anyhow::Result<Self> {
        #[cfg(all(feature = "cuda", cuda_runtime_available))]
        {
            // CUDA functionality temporarily disabled for compilation compatibility
            Err(anyhow::anyhow!("CUDA support needs proper implementation"))
        }

        #[cfg(not(all(feature = "cuda", cuda_runtime_available)))]
        {
            Ok(Self {
                function: std::ptr::null_mut(),
                module: std::ptr::null_mut(),
                name: function_name.to_string(),
            })
        }
    }
}

impl Drop for CudaKernel {
    fn drop(&mut self) {
        #[cfg(all(feature = "cuda", cuda_runtime_available))]
        {
            // CUDA cleanup temporarily disabled
        }
    }
}

/// GPU performance statistics
#[derive(Debug, Default, Clone)]
pub struct GpuPerformanceStats {
    pub total_operations: u64,
    pub total_compute_time: Duration,
    pub total_memory_transfers: u64,
    pub total_transfer_time: Duration,
    pub peak_memory_usage: usize,
    pub current_memory_usage: usize,
}

impl GpuPerformanceStats {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn record_operation(&mut self, compute_time: Duration) {
        self.total_operations += 1;
        self.total_compute_time += compute_time;
    }

    pub fn record_transfer(&mut self, transfer_time: Duration) {
        self.total_memory_transfers += 1;
        self.total_transfer_time += transfer_time;
    }

    pub fn update_memory_usage(&mut self, current: usize) {
        self.current_memory_usage = current;
        if current > self.peak_memory_usage {
            self.peak_memory_usage = current;
        }
    }

    pub fn average_compute_time(&self) -> Duration {
        if self.total_operations > 0 {
            self.total_compute_time / self.total_operations as u32
        } else {
            Duration::ZERO
        }
    }

    pub fn average_transfer_time(&self) -> Duration {
        if self.total_memory_transfers > 0 {
            self.total_transfer_time / self.total_memory_transfers as u32
        } else {
            Duration::ZERO
        }
    }

    pub fn throughput_ops_per_sec(&self) -> f64 {
        if !self.total_compute_time.is_zero() {
            self.total_operations as f64 / self.total_compute_time.as_secs_f64()
        } else {
            0.0
        }
    }
}