Added support for cuBLAS and CLBlast in ggml.

README.md

@@ -84,6 +84,11 @@ dependency from being built in debug mode:
 [profile.dev.package.ggml-sys]
 opt-level = 3
 ```
+## Leverage Accelerators with `llm`
+
+The `llm` library is engineered to take advantage of hardware accelerators such as `cuda` and `metal` for optimized performance. 
+
+To enable `llm` to harness these accelerators, some preliminary configuration steps are necessary, which vary based on your operating system. For comprehensive guidance, please refer to the [Acceleration Support for Building section](doc/CONTRIBUTING.md#acceleration-support-for-building) in our documentation.
 
 ## Using `llm` from Other Languages
 

binaries/generate-ggml-bindings/src/main.rs

@@ -6,45 +6,94 @@ use std::fs;
 use std::path::PathBuf;
 
 fn main() {
+    let sys_path = PathBuf::from("crates").join("ggml").join("sys");
+    let ggml_path = sys_path.join("llama-cpp");
+    let include_path = ggml_path.to_str().unwrap().to_string();
+    let src_path = sys_path.join("src");
+
     let bindings = bindgen::Builder::default()
-        .header("crates/ggml/sys/llama-cpp/ggml.h")
+        .header(ggml_path.join("ggml.h").to_str().unwrap().to_string())
+        .allowlist_file(r".*ggml.h")
         // Suppress some warnings
         .raw_line("#![allow(non_upper_case_globals)]")
         .raw_line("#![allow(non_camel_case_types)]")
         .raw_line("#![allow(non_snake_case)]")
         .raw_line("#![allow(unused)]")
+        .raw_line(r#"#[cfg(feature = "cublas")]"#)
+        .raw_line("pub mod cuda;")
+        .raw_line(r#"#[cfg(feature = "metal")]"#)
+        .raw_line("pub mod metal;")
+        .raw_line(r#"#[cfg(feature = "clblast")]"#)
+        .raw_line("pub mod opencl;")
         // Only generate code if it's from GGML
         .allowlist_file("crates/ggml/.*")
         .generate()
         .expect("Unable to generate bindings");
 
-    let out_path = PathBuf::from("crates")
-        .join("ggml")
-        .join("sys")
-        .join("src")
-        .join("lib.rs");
+    bindgen::Builder::default()
+        .header(ggml_path.join("ggml-cuda.h").to_str().unwrap().to_string())
+        .allowlist_file(r".*ggml-cuda\.h")
+        .allowlist_recursively(false)
+        .clang_arg("-I")
+        .clang_arg(&include_path)
+        .raw_line("use super::ggml_compute_params;")
+        .raw_line("use super::ggml_tensor;")
+        .generate()
+        .expect("Unable to generate cuda bindings")
+        .write_to_file(src_path.join("cuda.rs"))
+        .expect("Couldn't write cuda bindings");
+
+    bindgen::Builder::default()
+        .header(
+            ggml_path
+                .join("ggml-opencl.h")
+                .to_str()
+                .unwrap()
+                .to_string(),
+        )
+        .allowlist_file(r".*ggml-opencl\.h")
+        .allowlist_recursively(false)
+        .clang_arg("-I")
+        .clang_arg(&include_path)
+        .raw_line("use super::ggml_tensor;")
+        .generate()
+        .expect("Unable to generate opencl bindings")
+        .write_to_file(src_path.join("opencl.rs"))
+        .expect("Couldn't write opencl bindings");
+
+    bindgen::Builder::default()
+        .header(ggml_path.join("ggml-metal.h").to_str().unwrap().to_string())
+        .allowlist_file(r".*ggml-metal\.h")
+        .allowlist_recursively(false)
+        .clang_arg("-I")
+        .clang_arg(&include_path)
+        .generate()
+        .expect("Unable to generate metal bindings")
+        .write_to_file(src_path.join("metal.rs"))
+        .expect("Couldn't write metal bindings");
 
     let mut generated_bindings = bindings.to_string();
 
     if cfg!(windows) {
         // windows generates all ::std::os::raw::c_* enum types as i32.
         // We need to replace some of them with c_uint as the rust bindings expect them to be unsigned.
         // Temporary hack until bindgen supports defining the enum types manually. See https://github.com/rust-lang/rust-bindgen/issues/1907
-        generated_bindings = generated_bindings.replace(
-            "ggml_type = ::std::os::raw::c_int;",
-            "ggml_type = ::std::os::raw::c_uint;",
-        );
-        generated_bindings = generated_bindings.replace(
-            "ggml_backend = ::std::os::raw::c_int;",
-            "ggml_backend = ::std::os::raw::c_uint;",
-        );
-        generated_bindings = generated_bindings.replace(
-            "ggml_op = ::std::os::raw::c_int;",
-            "ggml_op = ::std::os::raw::c_uint;",
-        );
+        for name in &[
+            "type",
+            "backend",
+            "op",
+            "linesearch",
+            "opt_type",
+            "task_type",
+        ] {
+            generated_bindings = generated_bindings.replace(
+                &format!("ggml_{name} = ::std::os::raw::c_int;"),
+                &format!("ggml_{name} = ::std::os::raw::c_uint;"),
+            );
+        }
     }
 
-    fs::write(out_path, generated_bindings).expect("Couldn't write bindings");
+    fs::write(src_path.join("lib.rs"), generated_bindings).expect("Couldn't write bindings");
 
     println!("Successfully updated bindings");
 }

binaries/llm-cli/Cargo.toml

@@ -27,3 +27,8 @@ num_cpus = "1.15.0"
 
 color-eyre = { version = "0.6.2", default-features = false }
 zstd = { version = "0.12", default-features = false }
+
+[features]
+cublas = ["llm/cublas"]
+clblast = ["llm/clblast"]
+metal = ["llm/metal"]

crates/ggml/Cargo.toml

@@ -14,3 +14,7 @@ ggml-sys = { path = "sys", version = "0.2.0-dev" }
 rand = { workspace = true }
 anyhow = { workspace = true }
 
+[features]
+cublas = ["ggml-sys/cublas"]
+clblast = ["ggml-sys/clblast"]
+metal = ["ggml-sys/metal"]

crates/ggml/sys/Cargo.toml

@@ -8,3 +8,8 @@ license = "MIT"
 
 [build-dependencies]
 cc = "^1.0"
+
+[features]
+cublas = []
+clblast = []
+metal = []