Update

openmp/matmul_for.cp

+void matmul_depend(
+  int N, int BS,
+  float A[N][N], float B[N][N], float C[N][N]
+)
+{
+  int i, j, k, ii, jj, kk;
+  for (i = 0; i < N; i+=BS) {
+    for (j = 0; j < N; j+=BS) {
+      for (k = 0; k < N; k+=BS) {
+// Note 1: i, j, k, A, B, C are firstprivate by default
+// Note 2: A, B and C are just pointers
+#pragma omp task private(ii, jj, kk) \
+                 depend ( in: A[i:BS][k:BS], B[k:BS][j:BS] ) \
+                 depend ( inout: C[i:BS][j:BS] )
+          for (ii = i; ii < i+BS; ii++ )
+             for (jj = j; jj < j+BS; jj++ )
+                for (kk = k; kk < k+BS; kk++ )
+                   C[ii][jj] = C[ii][jj] + A[ii][kk] * B[kk][jj];
+        }
+      }
+    }
+  }
+}

openmp/matmul_for.cpp

+void matmul_for(
+  int N, int BS,
+  float A[N][N], float B[N][N], float C[N][N]
+)
+{
+  int i, j, k;
+#pragma omp parallel for collapse(2)
+  for (i = 0; i < N; ++i) {
+    for (j = 0; j < N; ++j) {
+      for (k = 0; k < N; ++k) {
+       C[i][j] = C[i][j] + A[i][k] * B[k][j];
+      }
+    }
+  }
+}

openmp/matmul_task.cpp

+void matmul_depend(
+  int N, int BS,
+  float A[N][N], float B[N][N], float C[N][N]
+)
+{
+  int i, j, k, ii, jj, kk;
+  for (i = 0; i < N; i+=BS) {
+    for (j = 0; j < N; j+=BS) {
+      for (k = 0; k < N; k+=BS) {
+// Note 1: i, j, k, A, B, C are firstprivate by default
+// Note 2: A, B and C are just pointers
+#pragma omp task private(ii, jj, kk) \
+                 depend ( in: A[i:BS][k:BS], B[k:BS][j:BS] ) \
+                 depend ( inout: C[i:BS][j:BS] )
+          for (ii = i; ii < i+BS; ii++ )
+             for (jj = j; jj < j+BS; jj++ )
+                for (kk = k; kk < k+BS; kk++ )
+                   C[ii][jj] = C[ii][jj] + A[ii][kk] * B[kk][jj];
+        }
+      }
+    }
+  }
+}

openmp/partial_matmul.cpp

+#include <iostream>
+#include <omp.h>
+
+int fibonacci(int n)
+{
+  if (n<2)
+   return n;
+
+  int sum;
+  int r1;
+  int r2;
+  #pragma omp task if (n>20) depend(out:r1) shared(r1) firstprivate(n)
+    r1 = fibonacci(n-1);
+  #pragma omp task if (n>20) depend(out:r2) shared(r2) firstprivate(n)
+    r2 = fibonacci(n-2);
+  #pragma omp task if (n>20) depend(out:sum) depend(in:r1,r2) shared(r1,r2,sum)
+    sum = r1 + r2;
+  #pragma omp taskwait
+  return sum;
+}
+
+int main(int argc, char** argv)
+{
+  int r, n;
+  n = atoi(argv[1]);
+  double t0 = omp_get_wtime();
+#pragma omp parallel shared(r) firstprivate(n)
+  {
+#pragma omp master
+    {
+#pragma omp task depend(out:r) firstprivate(n) shared(r)
+      r = fibonacci( n );
+#pragma omp task depend(in:r) firstprivate(n) shared(r)
+      {
+        double t1 = omp_get_wtime();
+        std::cout <<"Fibonacci(" << n << ") =" << r << std::endl;
+        std::cout << "Time: " << t1-t0 << std::endl;
+      }
+    }
+  }
+
+  return 0;
+}