feat: add rust kernels library for loading kernels

kernels-rs/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "kernels"
+version = "0.1.0"
+edition = "2024"
+description = "Load and call Hugging Face Hub kernels in Rust"
+homepage = "https://github.com/huggingface/kernels"
+license = "Apache-2.0"
+repository = "https://github.com/huggingface/kernels"
+
+[features]
+default = []
+candle = ["dep:candle-core"]
+candle-cuda = ["candle", "candle-core/cuda", "dep:cudarc"]
+
+[dependencies]
+candle-core = { version = "0.10.0", optional = true }
+cudarc = { version = "0.19.0", optional = true }
+huggingface-hub = { git = "https://github.com/huggingface/huggingface_hub_rust.git", rev = "8cbc662035e04d4be8e829316272893e980f5926", package = "huggingface-hub", features = ["blocking"] }
+libc = "0.2"
+libloading = "0.8"
+thiserror = "1"
+walkdir = "2"

kernels-rs/src/backend.rs

@@ -0,0 +1,118 @@
+use std::fmt;
+use std::str::FromStr;
+
+use libloading::Library;
+
+use crate::error::Error;
+
+#[derive(Debug, Clone)]
+pub enum Backend {
+    Cpu,
+    Cuda { version: String },
+    Xpu { version: String },
+}
+
+impl Backend {
+    pub fn kind(&self) -> BackendKind {
+        match self {
+            Backend::Cpu => BackendKind::Cpu,
+            Backend::Cuda { .. } => BackendKind::Cuda,
+            Backend::Xpu { .. } => BackendKind::Xpu,
+        }
+    }
+
+    pub fn name(&self) -> &str {
+        self.kind().as_str()
+    }
+}
+
+impl fmt::Display for Backend {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Backend::Cpu => write!(f, "cpu"),
+            Backend::Cuda { version } => write!(f, "cuda {version}"),
+            Backend::Xpu { version } => write!(f, "xpu {version}"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BackendKind {
+    Cpu,
+    Cuda,
+    Xpu,
+}
+
+impl BackendKind {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            BackendKind::Cpu => "cpu",
+            BackendKind::Cuda => "cuda",
+            BackendKind::Xpu => "xpu",
+        }
+    }
+}
+
+impl fmt::Display for BackendKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(self.as_str())
+    }
+}
+
+impl FromStr for BackendKind {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "cpu" => Ok(Self::Cpu),
+            "cuda" => Ok(Self::Cuda),
+            "xpu" => Ok(Self::Xpu),
+            other => Err(Error::Kernel(format!("unknown backend: {other}"))),
+        }
+    }
+}
+
+pub fn detect_cuda_version() -> Option<String> {
+    type CudaRuntimeGetVersion = unsafe extern "C" fn(*mut i32) -> i32;
+
+    let library = unsafe { Library::new(libloading::library_filename("cudart")) }.ok()?;
+    let cuda_runtime_get_version: libloading::Symbol<CudaRuntimeGetVersion> =
+        unsafe { library.get(b"cudaRuntimeGetVersion\0").ok()? };
+
+    let mut runtime_version = 0;
+    if unsafe { cuda_runtime_get_version(&mut runtime_version) } != 0 {
+        return None;
+    }
+
+    format_cuda_runtime_version(runtime_version)
+}
+
+fn format_cuda_runtime_version(runtime_version: i32) -> Option<String> {
+    if runtime_version <= 0 {
+        return None;
+    }
+
+    let major = runtime_version / 1000;
+    let minor = (runtime_version % 1000) / 10;
+    Some(format!("{major}.{minor}"))
+}
+
+pub fn detect() -> BackendKind {
+    if detect_cuda_version().is_some() {
+        BackendKind::Cuda
+    } else {
+        BackendKind::Cpu
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::format_cuda_runtime_version;
+
+    #[test]
+    fn formats_cuda_runtime_versions() {
+        assert_eq!(format_cuda_runtime_version(12080).as_deref(), Some("12.8"));
+        assert_eq!(format_cuda_runtime_version(11020).as_deref(), Some("11.2"));
+        assert_eq!(format_cuda_runtime_version(0), None);
+    }
+}