From e58f4ab423b783d78b00ce6ef8145e89f49564a8 Mon Sep 17 00:00:00 2001
From: Riga27527 <596847942@qq.com>
Date: Sat, 13 Aug 2022 00:14:30 +0800
Subject: [PATCH] Riga finished hw06!

---
 CMakeLists.txt |   1 +
 main.cpp       | 152 ++++++++++++++++++++++++++++++++++++++++---------
 score.md       |  28 +++++++++
 3 files changed, 153 insertions(+), 28 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0d6a8f8..a01b278 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,6 +1,7 @@
 cmake_minimum_required(VERSION 3.10)
 
 set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_BUILD_TYPE Release)
 
 project(main LANGUAGES CXX)
diff --git a/main.cpp b/main.cpp
index a1d2625..2e79efb 100644
--- a/main.cpp
+++ b/main.cpp
@@ -4,16 +4,31 @@
 #include <cmath>
 #include <numeric>
 #include <algorithm>
+#include <thread>
 #include "ticktock.h"
+#include <tbb/parallel_for.h>
+#include <tbb/parallel_reduce.h>
+#include <tbb/parallel_scan.h>
+#include <mutex>
+#include <execution>
 
 // TODO: 并行化所有这些 for 循环
 
 template <class T, class Func>
 std::vector<T> fill(std::vector<T> &arr, Func const &func) {
     TICK(fill);
-    for (size_t i = 0; i < arr.size(); i++) {
-        arr[i] = func(i);
-    }
+    // ----------------------parallel_for---------------------------    
+    tbb::parallel_for(tbb::blocked_range<size_t>(0, arr.size()),
+        [&](auto r){
+            for (size_t i = r.begin(); i < r.end(); i++) {
+                arr[i] = func(i);
+            }            
+        }, tbb::auto_partitioner{});  
+
+    // --------------------------old---------------------------
+    // for (size_t i = 0; i < arr.size(); i++) {
+    //     arr[i] = func(i);
+    // }
     TOCK(fill);
     return arr;
 }
@@ -21,20 +36,41 @@ std::vector<T> fill(std::vector<T> &arr, Func const &func) {
 template <class T>
 void saxpy(T a, std::vector<T> &x, std::vector<T> const &y) {
     TICK(saxpy);
-    for (size_t i = 0; i < x.size(); i++) {
-       x[i] = a * x[i] + y[i];
-    }
+    // --------------------------parallel_for---------------------------
+    tbb::parallel_for(tbb::blocked_range<size_t>(0, x.size()),
+        [&](auto r){
+            for (size_t i = r.begin(); i < r.end(); ++i){
+                x[i] = a * x[i] + y[i];
+            }
+        });
+
+    // --------------------------old---------------------------
+    // for (size_t i = 0; i < x.size(); i++) {
+    //    x[i] = a * x[i] + y[i];
+    // }
     TOCK(saxpy);
 }
 
 template <class T>
 T sqrtdot(std::vector<T> const &x, std::vector<T> const &y) {
     TICK(sqrtdot);
-    T ret = 0;
-    for (size_t i = 0; i < std::min(x.size(), y.size()); i++) {
-        ret += x[i] * y[i];
-    }
-    ret = std::sqrt(ret);
+    // --------------------------parallel_reduce---------------------------    
+    T ret = std::sqrt(tbb::parallel_reduce(tbb::blocked_range<size_t>(0, std::min(x.size(), y.size())), (T)0, 
+        [&](tbb::blocked_range<size_t> r, T local_res){
+            for(size_t i=r.begin(); i<r.end(); ++i){
+                local_res += x[i] * y[i];
+            }
+            return local_res;
+        }, [](T x, T y){
+            return x + y;
+        }));
+
+    // --------------------------old---------------------------    
+    // T ret = 0;
+    // for (size_t i = 0; i < std::min(x.size(), y.size()); i++) {
+    //     ret += x[i] * y[i];
+    // }
+    // ret = std::sqrt(ret);
     TOCK(sqrtdot);
     return ret;
 }
@@ -42,11 +78,37 @@ T sqrtdot(std::vector<T> const &x, std::vector<T> const &y) {
 template <class T>
 T minvalue(std::vector<T> const &x) {
     TICK(minvalue);
+    // --------------------------parallel_for with mutex---------------------------     
     T ret = x[0];
-    for (size_t i = 1; i < x.size(); i++) {
-        if (x[i] < ret)
-            ret = x[i];
-    }
+    std::mutex mtx;    
+    tbb::parallel_for(tbb::blocked_range<size_t>(1, x.size()),
+        [&](auto r){
+            T tmp = x[r.begin()];
+            for(size_t i=r.begin()+1; i<r.end(); ++i)
+                if(x[i] < tmp)
+                    tmp = x[i];
+            std::lock_guard lck(mtx);
+            ret = std::min(ret, tmp);
+        });
+
+    // --------------------------parallel_reduce version---------------------------  
+    // T ret = tbb::parallel_reduce(tbb::blocked_range<size_t>(0, x.size()), (T)0,
+    //     [&](tbb::blocked_range<size_t> r, T local_min){
+    //         local_min = x[r.begin()];
+    //         for(size_t i=r.begin()+1; i<r.end(); ++i){
+    //             if(local_min > x[i])
+    //                 local_min = x[i];
+    //         }
+    //         return local_min;
+    //     }, [](T x, T y){
+    //         return (x < y ? x : y);
+    //     });
+
+    // --------------------------old version---------------------------         
+    // for (size_t i = 1; i < x.size(); i++) {
+    //     if (x[i] < ret)
+    //         ret = x[i];
+    // }
     TOCK(minvalue);
     return ret;
 }
@@ -54,15 +116,35 @@ T minvalue(std::vector<T> const &x) {
 template <class T>
 std::vector<T> magicfilter(std::vector<T> const &x, std::vector<T> const &y) {
     TICK(magicfilter);
+    // --------------------------parallel_for with mutex--------------------------- 
     std::vector<T> res;
-    for (size_t i = 0; i < std::min(x.size(), y.size()); i++) {
-        if (x[i] > y[i]) {
-            res.push_back(x[i]);
-        } else if (y[i] > x[i] && y[i] > 0.5f) {
-            res.push_back(y[i]);
-            res.push_back(x[i] * y[i]);
+    size_t n = std::min(x.size(), y.size());
+    res.reserve(n);
+    std::mutex mtx;
+    tbb::parallel_for(tbb::blocked_range<size_t>(0, n), [&](auto r){
+        std::vector<T> tmp_arr;
+        tmp_arr.reserve(r.size());
+        for(size_t i=r.begin(); i<r.end(); ++i){
+            if (x[i] > y[i]) {
+                tmp_arr.push_back(x[i]);
+            } else if (y[i] > x[i] && y[i] > 0.5f) {
+                tmp_arr.push_back(y[i]);
+                tmp_arr.push_back(x[i] * y[i]);
+            }            
         }
-    }
+        std::lock_guard lck(mtx);
+        std::copy(tmp_arr.begin(), tmp_arr.end(), std::back_inserter(res));
+    });
+
+    // --------------------------old--------------------------- 
+    // for (size_t i = 0; i < std::min(x.size(), y.size()); i++) {
+    //     if (x[i] > y[i]) {
+    //         res.push_back(x[i]);
+    //     } else if (y[i] > x[i] && y[i] > 0.5f) {
+    //         res.push_back(y[i]);
+    //         res.push_back(x[i] * y[i]);
+    //     }
+    // }
     TOCK(magicfilter);
     return res;
 }
@@ -70,11 +152,25 @@ std::vector<T> magicfilter(std::vector<T> const &x, std::vector<T> const &y) {
 template <class T>
 T scanner(std::vector<T> &x) {
     TICK(scanner);
-    T ret = 0;
-    for (size_t i = 0; i < x.size(); i++) {
-        ret += x[i];
-        x[i] = ret;
-    }
+    // --------------------------parallel_scan--------------------------- 
+    T ret = tbb::parallel_scan(tbb::blocked_range<size_t>(0, x.size()), (T)0, 
+        [&](auto r, T local_res, auto is_final){
+            for(size_t i=r.begin(); i<r.end(); ++i){
+                local_res += x[i];
+                if(is_final)
+                    x[i] = local_res;
+            }
+            return local_res;
+        }, [](T x, T y){
+            return x + y;
+        });
+
+    // --------------------------old---------------------------
+    // T ret = 0;
+    // for (size_t i = 0; i < x.size(); i++) {
+    //     ret += x[i];
+    //     x[i] = ret;
+    // }
     TOCK(scanner);
     return ret;
 }
@@ -96,7 +192,7 @@ int main() {
     std::cout << arr.size() << std::endl;
 
     scanner(x);
-    std::cout << std::reduce(x.begin(), x.end()) << std::endl;
+    std::cout << std::reduce(std::execution::seq, x.begin(), x.end()) << std::endl;
 
     return 0;
 }
diff --git a/score.md b/score.md
index edea7fd..ee3b1bd 100644
--- a/score.md
+++ b/score.md
@@ -53,3 +53,31 @@ magicfilter: 0.0378731s
 55924034
 scanner: 0.0257618s
 6.19406e+07
+
+
+----------------------------------Old result---------------------
+fill: 2.09027s
+fill: 2.13145s
+saxpy: 0.0397575s
+sqrtdot: 0.0888022s
+5165.4
+minvalue: 0.0843207s
+-1.11803
+magicfilter: 0.456461s
+55924034
+scanner: 0.105253s
+5.28566e+07
+
+----------------------------------Parallel result---------------------
+fill: 0.517877s
+fill: 0.520669s
+saxpy: 0.0425261s
+sqrtdot: 0.0366869s
+5792.62
+minvalue: 0.0220482s
+-1.11803
+magicfilter: 0.164679s
+55924034
+scanner: 0.0727342s
+5.28613e+07
+