sheet 5

Sheet_5/bsp_5_1/mylib.cpp

@@ -0,0 +1,140 @@
+#include "mylib.h"
+#include <cassert>       // assert()
+#include <cmath>
+#include <iostream>
+#include <functional>    // multiplies<>{}
+#include <list>
+#include <numeric>       // iota()
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+#include <vector>
+using namespace std;
+
+double scalar(vector<double> const &x, vector<double> const &y)
+{
+    assert(x.size() == y.size()); // switch off via compile flag: -DNDEBUG
+    size_t const N = x.size();
+    double sum = 0.0;
+//    int check;	// for using omp_in_parallel
+//#pragma omp parallel for default(none) shared(x,y,N,check) reduction(+:sum)
+#pragma omp parallel for default(none) shared(x,y,N) reduction(+:sum)
+    for (size_t i = 0; i < N; ++i)
+    {
+        sum += x[i] * y[i];
+//        check = omp_in_parallel();
+        //sum += exp(x[i])*log(y[i]);
+    }
+//    cout << "in parallel: " << check << endl;
+    return sum;
+}
+
+
+double scalar_manual(vector<double> const &x, vector<double> const &y)
+{
+    assert(x.size() == y.size());
+    size_t const N = x.size();
+    double sum = 0.0;
+
+    #pragma omp parallel default(none) shared(x,y,N,sum)
+    {
+        int tid  = omp_get_thread_num();
+        int nt   = omp_get_num_threads();
+
+        // manual splitting of the index area
+        size_t start = (N * tid)     / nt;
+        size_t end   = (N * (tid+1)) / nt;
+
+        double local_sum = 0.0;
+        for (size_t i = start; i < end; ++i) {
+            local_sum += x[i] * y[i];
+        }
+
+        // local subtotal combined to global sum
+        #pragma omp atomic
+        sum += local_sum;
+    }
+
+    return sum;
+}
+
+
+double norm(vector<double> const &x)
+{
+    size_t const N = x.size();
+    double sum = 0.0;
+#pragma omp parallel for default(none) shared(x,N) reduction(+:sum)
+    for (size_t i = 0; i < N; ++i)
+    {
+        sum += x[i]*x[i];
+    }
+    return sum;
+}
+
+
+
+vector<int> reduction_vec(int n)
+{ 
+    vector<int> vec(n);
+#pragma omp parallel default(none) shared(cout) reduction(VecAdd:vec)
+    {
+        #pragma omp barrier
+        #pragma omp critical
+        cout << omp_get_thread_num() << " : " << vec.size() << endl;
+        #pragma omp barrier
+        iota( vec.begin(),vec.end(), omp_get_thread_num() );
+        #pragma omp barrier
+
+    }
+    return vec;
+}
+
+
+vector<int> reduction_vec_append(int n)
+{
+    vector<int> vec;
+
+#pragma omp parallel default(none) shared(n,cout) reduction(VecAppend:vec)
+    {
+        std::vector<int> local(n);	// local vector of each thread
+
+        // consecutive numbers starting from thread ID
+        iota(local.begin(), local.end(), omp_get_thread_num());
+
+        // output for checking
+        #pragma omp critical
+        cout << "Thread " << omp_get_thread_num() << " local size = " << local.size() << std::endl;
+
+        // append local to vec
+        vec.insert(vec.end(), local.begin(), local.end());
+    }
+
+    return vec;
+}
+
+
+
+double scalar_trans(vector<double> const &x, vector<double> const &y)
+{
+    assert(x.size() == y.size()); // switch off via compile flag: -DNDEBUG
+    vector<double> z(x.size());
+    //list<double> z(x.size());  // parallel for-loop on iterators not possible (missing 'operator-')
+                                 // c++-20 CLANG_, ONEAPI_:condition of OpenMP for loop must be a relational comparison 
+    
+    transform(cbegin(x),cend(x),cbegin(y),begin(z),std::multiplies<>{});
+    
+    double sum = 0.0;
+#pragma omp parallel for default(none) shared(z) reduction(+:sum)
+    for (auto pi = cbegin(z); pi!=cend(z); ++pi)
+    {
+        sum += *pi;
+    }
+    //for (auto val: z)
+    //{
+        //sum += val;
+    //}    
+    return sum;
+}
+
+
+