Merge branch 'alex' into jack

src/bin/test_simple.rs

@@ -1,6 +1,6 @@
-use rand::Rng;
+// use rand::Rng;
 use rustmp::{par_for, critical};
-use std::time;
+// use std::time;
 
 #[derive(Debug)]
 struct Student {
@@ -18,7 +18,6 @@ impl Student {
         }
     }
 }
-
 fn main() {
     let numbers: Vec<Student> = vec![];
 
@@ -41,6 +40,21 @@ fn main() {
         println!("{:?}", num);
     }
 
+    let a:Vec<Vec<i32>> = vec![vec![1,2,3],vec![4,5,6],vec![7,8,9]];
+    let n = a.len();
+    let mut c = vec![vec![0;n];n];
+    let mut x = 0;
+    par_for! {
+        // I feel like we shouldn't need to capture a here
+        for k in 0..n, capturing a, reduction x#+, {
+            critical! {
+                read a;
+                x += a[1][k]*a[k][0];
+            }
+        }
+    }
+    c[1][0] = x;
+    println!("{:?}", c[1][0]);
     // let mut local = 0;
     // par_for! {
     // for i in 1..32, blocksize 1, capturing numbers, private local, {

src/lib.rs

@@ -71,11 +71,13 @@ macro_rules! critical {
 
 #[macro_export]
 macro_rules! __internal_par_for {
+    // without reduction
     (var_name($name:ident),
     iterator($iter:expr),
     blocksize($size:expr),
     captured($($captured:ident)*),
     private($($private:ident)*),
+    reduction(),
     $blk:block) => {
         let mut __rmp_tasks = Vec::new();
         $(let $captured = rustmp::Capture::new($captured);)*
@@ -95,12 +97,51 @@ macro_rules! __internal_par_for {
         }
         $(let $captured = $captured.unwrap();)*
     };
+    // with reduction
+    (var_name($name:ident),
+    iterator($iter:expr),
+    blocksize($size:expr),
+    captured($($captured:ident)*),
+    private($($private:ident)*),
+    reduction($($red_name:ident, $red_op:tt)+),
+    $blk:block) => {
+        let mut __rmp_tasks = Vec::new();
+        $(let $captured = rustmp::Capture::new($captured);)*
+        {
+            let __rmp_tpm_mtx = rustmp::ThreadPoolManager::get_instance_guard();
+            let __rmp_tpm = __rmp_tpm_mtx.lock().unwrap();
+            let __rmp_iters = __rmp_tpm.split_iterators($iter, $size);
+            let mut __rmp_red_vals = Vec::new();
+            // let mut __rmp_count = 0;
+            $(__rmp_red_vals.push(Vec::new()); $red_name = $red_name;)*
+            let __rmp_red_vals = rustmp::Capture::new(__rmp_red_vals);
+            for iter in __rmp_iters {
+                $(let $captured = $captured.clone();)*
+                let __rmp_red_vals = __rmp_red_vals.clone();
+                __rmp_tasks.push(rustmp::as_static_job(move || {
+                    $(let mut $private = $private.clone();)*
+                    $(let mut $red_name = $red_name.clone();)*
+                    for &$name in &iter
+                        $blk
+                    let mut __rmp_temp = __rmp_red_vals.write();
+                    let mut __rmp_counter = 0;
+                    $(__rmp_temp[__rmp_counter].push($red_name); __rmp_counter += 1;)*
+                }));
+            }
+            __rmp_tpm.exec(__rmp_tasks);
+            let mut __rmp_temp = __rmp_red_vals.read();
+            let mut __rmp_counter = 0;
+            $($red_name = __rmp_temp[__rmp_counter].iter().fold($red_name, |x, &y| {x $red_op y}); __rmp_counter += 1;)*;
+        }
+        $(let $captured = $captured.unwrap();)*
+    };
     // Parse blocksize
     (var_name($name:ident),
     iterator($iter:expr),
     blocksize($size:expr),
     captured($($captured:ident)*),
     private($($private:ident)*),
+    reduction($($red_name:ident, $red_op:tt)*),
     blocksize $new_size:expr,
     $($rem:tt)+) => {
         rustmp::__internal_par_for!(
@@ -109,6 +150,7 @@ macro_rules! __internal_par_for {
             blocksize($new_size),
             captured($($captured)*),
             private($($private)*),
+            reduction($($red_name, $red_op)*),
             $($rem)*)
     };
     // Parse capturing
@@ -117,6 +159,7 @@ macro_rules! __internal_par_for {
     blocksize($size:expr),
     captured($($captured:ident)*),
     private($($private:ident)*),
+    reduction($($red_name:ident, $red_op:tt)*),
     capturing $($new_captured:ident)*,
     $($rem:tt)+) => {
         rustmp::__internal_par_for!(
@@ -125,6 +168,7 @@ macro_rules! __internal_par_for {
             blocksize($size),
             captured($($new_captured)*),
             private($($private)*),
+            reduction($($red_name, $red_op)*),
             $($rem)*)
     };
     // Parse private
@@ -133,6 +177,7 @@ macro_rules! __internal_par_for {
     blocksize($size:expr),
     captured($($captured:ident)*),
     private($($private:ident)*),
+    reduction($($red_name:ident, $red_op:tt)*),
     private $($new_private:ident)*,
     $($rem:tt)+) => {
         rustmp::__internal_par_for!(
@@ -141,6 +186,25 @@ macro_rules! __internal_par_for {
             blocksize($size),
             captured($($captured)*),
             private($($new_private)*),
+            reduction($($red_name, $red_op)*),
+            $($rem)*)
+    };
+    // Parse reduction
+    (var_name($name:ident),
+    iterator($iter:expr),
+    blocksize($size:expr),
+    captured($($captured:ident)*),
+    private($($private:ident)*),
+    reduction($($red_name:ident, $red_op:tt)*),
+    reduction $($new_name:ident#$new_op:tt);*,
+    $($rem:tt)+) => {
+        rustmp::__internal_par_for!(
+            var_name($name),
+            iterator($iter),
+            blocksize($size),
+            captured($($captured)*),
+            private($($private)*),
+            reduction($($new_name, $new_op)*),
             $($rem)*)
     };
 }
@@ -158,6 +222,7 @@ macro_rules! par_for {
             blocksize(1),
             captured(),
             private(),
+            reduction(),
             $($rem)*)
     }
 }