skippy-runtime 0.76.1

Rust runtime layer for Skippy staged model execution
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

use std::ffi::{CStr, c_char};
use std::ptr;

use anyhow::{Result, anyhow};
use skippy_ffi::{BackendDevice as RawBackendDevice, BackendDeviceType as RawBackendDeviceType};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BackendDeviceType {
    Cpu,
    Gpu,
    IntegratedGpu,
    Accelerator,
    Meta,
}

impl From<RawBackendDeviceType> for BackendDeviceType {
    fn from(value: RawBackendDeviceType) -> Self {
        match value {
            RawBackendDeviceType::Cpu => Self::Cpu,
            RawBackendDeviceType::Gpu => Self::Gpu,
            RawBackendDeviceType::IGpu => Self::IntegratedGpu,
            RawBackendDeviceType::Accel => Self::Accelerator,
            RawBackendDeviceType::Meta => Self::Meta,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BackendDevice {
    pub name: String,
    pub description: Option<String>,
    pub device_id: Option<String>,
    pub memory_free: u64,
    pub memory_total: u64,
    pub device_type: BackendDeviceType,
    pub caps: u64,
}

pub fn backend_devices() -> Result<Vec<BackendDevice>> {
    let mut error = ptr::null_mut();
    let mut count = 0usize;
    let status = unsafe { skippy_ffi::skippy_backend_device_count(&mut count, &mut error) };
    super::ensure_ok(status, error)?;

    let mut devices = Vec::with_capacity(count);
    for index in 0..count {
        let mut raw = RawBackendDevice {
            version: 0,
            name: ptr::null(),
            description: ptr::null(),
            device_id: ptr::null(),
            memory_free: 0,
            memory_total: 0,
            device_type: RawBackendDeviceType::Cpu,
            caps: 0,
        };
        let mut error = ptr::null_mut();
        let status = unsafe { skippy_ffi::skippy_backend_device_at(index, &mut raw, &mut error) };
        super::ensure_ok(status, error)?;
        devices.push(backend_device_from_raw(raw)?);
    }

    Ok(devices)
}

fn backend_device_from_raw(raw: RawBackendDevice) -> Result<BackendDevice> {
    Ok(BackendDevice {
        name: c_string_required(raw.name, "backend device name")?,
        description: c_string_optional(raw.description)?,
        device_id: c_string_optional(raw.device_id)?,
        memory_free: raw.memory_free,
        memory_total: raw.memory_total,
        device_type: raw.device_type.into(),
        caps: raw.caps,
    })
}

fn c_string_required(ptr: *const c_char, field: &str) -> Result<String> {
    if ptr.is_null() {
        return Err(anyhow!("{field} is null"));
    }
    Ok(unsafe { CStr::from_ptr(ptr) }
        .to_string_lossy()
        .into_owned())
}

fn c_string_optional(ptr: *const c_char) -> Result<Option<String>> {
    if ptr.is_null() {
        return Ok(None);
    }
    let value = unsafe { CStr::from_ptr(ptr) }
        .to_string_lossy()
        .into_owned();
    Ok((!value.is_empty()).then_some(value))
}