Added in reduction keyword and a simple example

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 {
@@ -41,14 +41,26 @@ fn main() {
         println!("{:?}", num);
     }
 
-    //let mut local = 0;
+    let mut x = 0;
-    //par_for! {
+    // let mut y = 1;
-    //for i in 1..32, blocksize 1, capturing numbers, private local, {
+    par_for! {
-    //local += 1;
+        for i in 0..10, reduction x#+, {
-    //println!("{}", local);
+            // let mut lock = x.write();
-    //let mut lock = numbers.write();
+            // *lock += 7;
-    //lock.push(Student::new(i));
+            // y *= 6;
-    //println!("Thread {} running!", i);
+            x += 2;
-    //} }
+        }
+    }
+    println!("{:?}", x);
+
+    // let mut local = 0;
+    // par_for! {
+    // for i in 1..32, blocksize 1, capturing numbers, private local, {
+    // local += 1;
+    // println!("{}", local);
+    // let mut lock = numbers.write();
+    // lock.push(Student::new(i));
+    // println!("Thread {} running!", i);
+    // } }
 
 }

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,48 @@ 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 __rmp_red_vals = rustmp::Capture::new(Vec::with_capacity(__rmp_iters.len()));
+            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();
+                    $(__rmp_temp.push($red_name);)*
+                }));
+            }
+            __rmp_tpm.exec(__rmp_tasks);
+            let mut __rmp_temp = __rmp_red_vals.read();
+            for i in 0..__rmp_temp.len() {
+                $($red_name = $red_name $red_op __rmp_temp[i];)*
+            }
+        }
+        $(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 +147,7 @@ macro_rules! __internal_par_for {
             blocksize($new_size),
             captured($($captured)*),
             private($($private)*),
+            reduction($($red_name, $red_op)*),
             $($rem)*)
     };
     // Parse capturing
@@ -117,6 +156,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 +165,7 @@ macro_rules! __internal_par_for {
             blocksize($size),
             captured($($new_captured)*),
             private($($private)*),
+            reduction($($red_name, $red_op)*),
             $($rem)*)
     };
     // Parse private
@@ -133,6 +174,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 +183,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 +219,7 @@ macro_rules! par_for {
             blocksize(1),
             captured(),
             private(),
+            reduction(),
             $($rem)*)
     }
 }