Use BLAS in dot only for "long" vectors.

For some measure of long, seems like the smallest vectors benefit from
using the plain generic dot product (32 elements or smaller).

Author: bluss

benches/bench1.rs

@@ -397,17 +397,6 @@ fn muladd_2d_f32_blas(bench: &mut test::Bencher)
     });
 }
 
-#[bench]
-fn dot_f32_regular(bench: &mut test::Bencher)
-{
-    let av = OwnedArray::<f32, _>::zeros(1024);
-    let bv = OwnedArray::<f32, _>::zeros(1024);
-    bench.iter(|| {
-        av.dot(&bv)
-    });
-}
-
-
 #[bench]
 fn assign_scalar_2d_large(bench: &mut test::Bencher)
 {
@@ -544,13 +533,31 @@ fn equality_f32(bench: &mut test::Bencher)
 }
 
 #[bench]
-fn dot(bench: &mut test::Bencher)
+fn dot_f32_16(bench: &mut test::Bencher)
+{
+    let a = OwnedArray::<f32, _>::zeros(16);
+    let b = OwnedArray::<f32, _>::zeros(16);
+    bench.iter(|| a.dot(&b));
+}
+
+#[bench]
+fn dot_f32_256(bench: &mut test::Bencher)
 {
     let a = OwnedArray::<f32, _>::zeros(256);
     let b = OwnedArray::<f32, _>::zeros(256);
     bench.iter(|| a.dot(&b));
 }
 
+#[bench]
+fn dot_f32_1024(bench: &mut test::Bencher)
+{
+    let av = OwnedArray::<f32, _>::zeros(1024);
+    let bv = OwnedArray::<f32, _>::zeros(1024);
+    bench.iter(|| {
+        av.dot(&bv)
+    });
+}
+
 #[bench]
 fn means(bench: &mut test::Bencher) {
     let a = OwnedArray::from_iter(0..100_000i64);

src/lib.rs

@@ -2361,17 +2361,20 @@ impl<A, S> ArrayBase<S, Ix>
                 ::std::ptr::read(a as *const _ as *const B)
             }
         }
-        assert_eq!(self.len(), rhs.len());
-        if let Ok(self_v) = self.blas_view_as_type::<f32>() {
-            if let Ok(rhs_v) = rhs.blas_view_as_type::<f32>() {
-                let f_ret = f32::dot(&self_v, &rhs_v);
-                return cast_as::<f32, A>(&f_ret);
+        // Use only if the vector is large enough to be worth it
+        if self.len() >= 32 {
+            assert_eq!(self.len(), rhs.len());
+            if let Ok(self_v) = self.blas_view_as_type::<f32>() {
+                if let Ok(rhs_v) = rhs.blas_view_as_type::<f32>() {
+                    let f_ret = f32::dot(&self_v, &rhs_v);
+                    return cast_as::<f32, A>(&f_ret);
+                }
             }
-        }
-        if let Ok(self_v) = self.blas_view_as_type::<f64>() {
-            if let Ok(rhs_v) = rhs.blas_view_as_type::<f64>() {
-                let f_ret = f64::dot(&self_v, &rhs_v);
-                return cast_as::<f64, A>(&f_ret);
+            if let Ok(self_v) = self.blas_view_as_type::<f64>() {
+                if let Ok(rhs_v) = rhs.blas_view_as_type::<f64>() {
+                    let f_ret = f64::dot(&self_v, &rhs_v);
+                    return cast_as::<f64, A>(&f_ret);
+                }
             }
         }
         self.dot_generic(rhs)