Pad out the benchmarks to make the performance difference more pronounced.

This also speed the benchmarks up since the bench suite has trouble with
benchmarks that less then 100ns in length.

src/bench/matrix.rs

@@ -63,288 +63,360 @@ pub mod mat4 {
 fn bench_mat2_mul_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.mul_m(&mat2::B);
         }
+    }
 }
 
 #[bench]
 fn bench_mat3_mul_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.mul_m(&mat3::B);
         }
+    }
 }
 
 #[bench]
 fn bench_mat4_mul_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.mul_m(&mat4::B);
         }
+    }
 }
 
 #[bench]
 fn bench_mat2_add_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.add_m(&mat2::B);
         }
+    }
 }
 
 #[bench]
 fn bench_mat3_add_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.add_m(&mat3::B);
         }
+    }
 }
 
 #[bench]
 fn bench_mat4_add_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.add_m(&mat4::B);
         }
+    }
 }
 
 #[bench]
 fn bench_mat2_sub_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.sub_m(&mat2::B);
         }
+    }
 }
 
 #[bench]
 fn bench_mat3_sub_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.sub_m(&mat3::B);
         }
+    }
 }
 
 #[bench]
 fn bench_mat4_sub_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.sub_m(&mat4::B);
         }
+    }
 }
 
 #[bench]
 fn bench_mat2_mul_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.mul_s(2.0);
         }
+    }
 }
 
 #[bench]
 fn bench_mat3_mul_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.mul_s(2.0);
         }
+    }
 }
 
 #[bench]
 fn bench_mat4_mul_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.mul_s(2.0);
         }
+    }
 }
 
 #[bench]
 fn bench_mat2_div_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.div_s(2.);
         }
+    }
 }
 
 #[bench]
 fn bench_mat3_div_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.div_s(2.);
         }
+    }
 }
 
 #[bench]
 fn bench_mat4_div_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.div_s(2.);
         }
+    }
 }
 
 #[bench]
 fn bench_mat2_rem_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.rem_s(2.);
         }
+    }
 }
 
 #[bench]
 fn bench_mat3_rem_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.rem_s(2.);
         }
+    }
 }
 
 #[bench]
 fn bench_mat4_rem_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.rem_s(2.);
         }
+    }
 }
 
 #[bench]
 fn bench_mat2_neg_self(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.neg_self();
         }
+    }
 }
 
 #[bench]
 fn bench_mat3_neg_self(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.neg_self();
         }
+    }
 }
 
 #[bench]
 fn bench_mat4_neg_self(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.neg_self();
         }
+    }
 }
 
 #[bench]
 fn bench_mat2_div_self_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.div_self_s(2.);
         }
+    }
 }
 
 #[bench]
 fn bench_mat3_div_self_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.div_self_s(2.);
         }
+    }
 }
 
 #[bench]
 fn bench_mat4_div_self_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.div_self_s(2.);
         }
+    }
 }
 
 #[bench]
 fn bench_mat2_rem_self_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.rem_self_s(2.);
         }
+    }
 }
 
 #[bench]
 fn bench_mat3_rem_self_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.rem_self_s(2.);
         }
+    }
 }
 
 #[bench]
 fn bench_mat4_rem_self_s(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.rem_self_s(2.);
         }
+    }
 }
 
 #[bench]
 fn bench_mat2_mul_self_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.mul_self_m(&mat2::B);
         }
+    }
 }
 
 #[bench]
 fn bench_mat3_mul_self_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.mul_self_m(&mat3::B);
         }
+    }
 }
 
 #[bench]
 fn bench_mat4_mul_self_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.mul_self_m(&mat4::B);
         }
+    }
 }
 
 #[bench]
 fn bench_mat2_add_self_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.add_self_m(&mat2::B);
         }
+    }
 }
 
 #[bench]
 fn bench_mat3_add_self_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.add_self_m(&mat3::B);
         }
+    }
 }
 
 #[bench]
 fn bench_mat4_add_self_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.add_self_m(&mat4::B);
         }
+    }
 }
 
 #[bench]
 fn bench_mat2_sub_self_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.sub_self_m(&mat2::B);
         }
+    }
 }
 
 #[bench]
 fn bench_mat3_sub_self_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.sub_self_m(&mat3::B);
         }
+    }
 }
 
 #[bench]
 fn bench_mat4_sub_self_m(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.add_self_m(&mat4::B);
         }
+    }
 }
 
 
@@ -352,46 +424,58 @@ fn bench_mat4_sub_self_m(b: &mut extra::test::BenchHarness) {
 fn bench_mat2_transpose(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.transpose();
         }
+    }
 }
 
 #[bench]
 fn bench_mat3_transpose(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.transpose();
         }
+    }
 }
 
 #[bench]
 fn bench_mat4_transpose(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a = mat_a.transpose();
         }
+    }
 }
 
 #[bench]
 fn bench_mat2_transpose_self(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat2::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.transpose_self();
         }
+    }
 }
 
 #[bench]
 fn bench_mat3_transpose_self(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat3::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.transpose_self();
         }
+    }
 }
 
 #[bench]
 fn bench_mat4_transpose_self(b: &mut extra::test::BenchHarness) {
     let mut mat_a = mat4::A.clone();
     do b.iter {
+        for _ in range(0, 1000) {
             mat_a.transpose_self();
         }
+    }
 }