intel-mkl-sys crate

Cargo.toml

@@ -1,5 +1,6 @@
 [workspace]
 members = [
   "intel-mkl-src",
+  "intel-mkl-sys",
   "intel-mkl-tool",
 ]

intel-mkl-sys/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "intel-mkl-sys"
+version = "2019.5.0"
+authors = ["Toshiki Teramura <[email protected]>"]
+edition = "2018"
+
+[dependencies.intel-mkl-src]
+path = "../intel-mkl-src"
+
+[dev-dependencies]
+criterion = "0.3"
+rand = "0.7"
+approx = "0.3"
+
+[[bench]]
+name = "cos"
+harness = false

intel-mkl-sys/benches/cos.rs

@@ -0,0 +1,65 @@
+#[macro_use]
+extern crate criterion;
+
+use criterion::Criterion;
+use rand::distributions::{Distribution, Uniform};
+
+fn criterion_benchmark(c: &mut Criterion) {
+    // f32
+    for &n in &[100, 1000, 10000] {
+        let in_ = {
+            let mut rng = rand::thread_rng();
+            let between = Uniform::from(0.0..2.0 * std::f32::consts::PI);
+            let mut buf = vec![0.0; n];
+            for val in buf.iter_mut() {
+                *val = between.sample(&mut rng);
+            }
+            buf
+        };
+
+        let mut out = vec![0.0_f32; n];
+        c.bench_function(&format!("cos32_n{}", n), |b| {
+            b.iter(|| {
+                for i in 0..n {
+                    out[i] = in_[i].cos();
+                }
+            })
+        });
+        c.bench_function(&format!("vcos32_n{}", n), |b| {
+            b.iter(|| unsafe {
+                intel_mkl_sys::vsCos(n as i32, in_.as_ptr(), out.as_mut_ptr());
+            })
+        });
+    }
+
+    // f64
+    for &n in &[100, 1000, 10000] {
+        let in_ = {
+            let mut rng = rand::thread_rng();
+            let between = Uniform::from(0.0..2.0 * std::f64::consts::PI);
+            let mut buf = vec![0.0; n];
+            for val in buf.iter_mut() {
+                *val = between.sample(&mut rng);
+            }
+            buf
+        };
+
+        let mut out = vec![0.0_f64; n];
+        c.bench_function(&format!("cos64_n{}", n), |b| {
+            b.iter(|| {
+                for i in 0..n {
+                    out[i] = in_[i].cos();
+                }
+            })
+        });
+
+        c.bench_function(&format!("vcos64_n{}", n), |b| {
+            b.iter(|| unsafe {
+                intel_mkl_sys::vdCos(n as i32, in_.as_ptr(), out.as_mut_ptr());
+            })
+        });
+    }
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

intel-mkl-sys/bindgen.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+set -uex
+
+bindgen \
+  --use-core \
+  --with-derive-{default,eq,hash,ord} \
+  wrapper.h \
+  > src/mkl.rs

intel-mkl-sys/src/lib.rs

@@ -0,0 +1,66 @@
+//! Rust binding to Intel-MKL including
+//!
+//! - [Vector Mathematical Functions (mkl_vml.h)](https://software.intel.com/en-us/onemkl-developer-reference-c-vector-mathematical-functions)
+//! - [Statistical Functions (mkl_vsl.h)](https://software.intel.com/en-us/onemkl-developer-reference-c-statistical-functions)
+//!
+//! Other parts of Intel-MKL is served via
+//!
+//! - [blas-sys](https://crates.io/crates/blas-sys)
+//! - [lapack-sys](https://crates.io/crates/lapack-sys)
+//! - [lapacke-sys](https://crates.io/crates/lapacke-sys)
+//! - [fftw-sys](https://crates.io/crates/fftw-sys)
+//!
+#![allow(
+    improper_ctypes,
+    non_upper_case_globals,
+    non_camel_case_types,
+    non_snake_case
+)]
+
+extern crate intel_mkl_src;
+
+include!("mkl.rs");
+
+// Test linking
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use approx::ulps_eq;
+    use rand::distributions::{Distribution, Uniform};
+    use std::ffi::c_void;
+
+    fn gen_rand_array(n: usize) -> Vec<f64> {
+        let mut rng = rand::thread_rng();
+        let between = Uniform::from(0.0..2.0 * std::f64::consts::PI);
+        let mut buf = vec![0.0; n];
+        for val in buf.iter_mut() {
+            *val = between.sample(&mut rng);
+        }
+        buf
+    }
+
+    #[test]
+    fn cos() {
+        let n = 1024;
+        let a = gen_rand_array(n);
+        let mut b = vec![0.0_f64; n];
+        unsafe {
+            vdCos(n as i32, a.as_ptr(), b.as_mut_ptr());
+        }
+        for i in 0..n {
+            ulps_eq!(b[i], a[i].cos(), max_ulps = 4, epsilon = std::f64::EPSILON);
+        }
+    }
+
+    #[test]
+    fn new_stream() {
+        let mut stream: *mut c_void = std::ptr::null_mut();
+        unsafe {
+            vslNewStream(
+                &mut stream as *mut *mut c_void,
+                VSL_BRNG_MT19937 as i32,
+                777,
+            );
+        }
+    }
+}