Add missing Fortran documentation (1/2)

Checks/PWR004/README.md

@@ -21,8 +21,10 @@ improves code readability.
 
 ### Code example
 
-In the following code, a variable `factor` is used in each iteration of the loop
-to initialize the array `result`.
+#### C
+
+In the following code, a variable `factor` is used in each iteration of the
+loop to initialize the array `result`:
 
 ```c
 void example() {
@@ -36,22 +38,55 @@ void example() {
 }
 ```
 
-Having the scope declared explicitly for each variable improves readability
+Having the scope declared explicitly for each variable improves readability,
 since it makes explicit the scope of all the variables within the parallel
-region.
+region:
 
 ```c
 void example() {
   int factor = 42;
   int result[10];
 
-  #pragma omp parallel for shared(result, factor)
+  #pragma omp parallel for default(none) shared(result, factor) private(i)
   for (int i = 0; i < 10; i++) {
     result[i] = factor * i;
   }
 }
 ```
 
+#### Fortran
+
+In the following code, a variable `factor` is used in each iteration of the
+loop to initialize the array `result`:
+
+```f90
+subroutine example()
+  integer :: factor = 42
+  integer :: result(10)
+
+  !$omp parallel do
+  do i = 1, 10
+    result(i) = factor * i
+  end do
+end subroutine example
+```
+
+Having the scope declared explicitly for each variable improves readability,
+since it makes explicit the scope of all the variables within the parallel
+region:
+
+```f90
+subroutine example()
+  integer :: factor = 42
+  integer :: result(10)
+
+  !$omp parallel do default(none) shared(factor, result) private(i)
+  do i = 1, 10
+    result(i) = factor * i
+  end do
+end subroutine example
+```
+
 ### Related resources
 
 * [PWR004 examples](../PWR004)

Checks/PWR005/README.md

@@ -21,10 +21,12 @@ variable.
 
 ### Code example
 
+#### C
+
 In the following code, a variable `t` is used in each iteration of the loop to
 hold a value that is then assigned to the array `result`. Since no data scoping
-is declared for those variables the default will be used. This makes the
-variable `t` shared which is incorrect since it introduces a race condition.
+is declared for those variables, the default will be used. This makes the
+variable `t` shared, which is incorrect since it introduces a race condition:
 
 ```c
 void example() {
@@ -39,8 +41,8 @@ void example() {
 }
 ```
 
-The following code disables the default scoping which will make the compiler
-raise an error due to unspecified scopes.
+The following code disables the default scoping, which will make the compiler
+raise an error due to unspecified scopes:
 
 ```c
 void example() {
@@ -55,22 +57,74 @@ void example() {
 }
 ```
 
-To fix the code the scope of each variable must be specified. The variable `t`
-must be made private to prevent the race condition.
+To fix the code, the scope of each variable must be specified. The variable `t`
+must be made private to prevent the race condition:
 
 ```c
 void example() {
   int t;
   int result[10];
 
-  #pragma omp parallel for default(none) shared(result) private(t)
+  #pragma omp parallel for default(none) shared(result) private(i, t)
   for (int i = 0; i < 10; i++) {
     t = i + 1;
     result[i] = t;
   }
 }
 ```
 
+#### Fortran
+
+In the following code, a variable `t` is used in each iteration of the loop to
+hold a value that is then assigned to the array `result`. Since no data scoping
+is declared for those variables, the default will be used. This makes the
+variable `t` shared, which is incorrect since it introduces a race condition:
+
+```f90
+subroutine example()
+  integer :: i, t
+  integer :: result(10)
+
+  !$omp parallel do
+  do i = 1, 10
+    t = i + 1;
+    result(i) = t;
+  end do
+end subroutine example
+```
+
+The following code disables the default scoping, which will make the compiler
+raise an error due to unspecified scopes:
+
+```f90
+subroutine example()
+  integer :: i, t
+  integer :: result(10)
+
+  !$omp parallel do default(none)
+  do i = 1, 10
+    t = i + 1;
+    result(i) = t;
+  end do
+end subroutine example
+```
+
+To fix the code, the scope of each variable must be specified. The variable `t`
+must be made private to prevent the race condition:
+
+```f90
+subroutine example()
+  integer :: i, t
+  integer :: result(10)
+
+  !$omp parallel do default(none) shared(result) private(i, t)
+  do i = 1, 10
+    t = i + 1;
+    result(i) = t;
+  end do
+end subroutine example
+```
+
 ### Related resources
 
 * [PWR005 examples](../PWR005)

Checks/PWR006/README.md

@@ -18,9 +18,11 @@ possible.
 
 ### Code example
 
+#### C
+
 In the following code, arrays `A` and `B` are never written to. However, they
 are privatized and thus each thread will hold a copy of each array, effectively
-using more memory and taking more time to create private copies.
+using more memory and taking more time to create private copies:
 
 ```c
 #define SIZE 5
@@ -30,7 +32,7 @@ void example() {
   int B[SIZE] = {5, 4, 3, 2, 1};
   int sum[SIZE];
 
-  #pragma omp parallel for shared(sum) firstprivate(A, B)
+  #pragma omp parallel for shared(sum) firstprivate(A, B) private(i)
   for (int i = 0; i < SIZE; i++) {
     sum[i] = A[i] + B[i];
   }
@@ -39,7 +41,7 @@ void example() {
 
 To save memory, change their scope to shared. This may also prevent memory
 issues when using arrays, as codes may easily run out of memory for a high
-number of threads.
+number of threads:
 
 ```c
 #define SIZE 5
@@ -49,13 +51,55 @@ void example() {
   int B[SIZE] = {5, 4, 3, 2, 1};
   int sum[SIZE];
 
-  #pragma omp parallel for shared(sum, A, B)
+  #pragma omp parallel for shared(sum, A, B) private(i)
   for (int i = 0; i < SIZE; i++) {
     sum[i] = A[i] + B[i];
   }
 }
 ```
 
+#### Fortran
+
+In the following code, arrays `A` and `B` are never written to. However, they
+are privatized and thus each thread will hold a copy of each array, effectively
+using more memory and taking more time to create private copies:
+
+```f90
+subroutine example()
+  implicit none
+  integer :: i
+  integer :: a(5) = [1, 2, 3, 4, 5]
+  integer :: b(5) = [6, 7, 8, 9, 10]
+  integer :: sum(5)
+
+  !$omp parallel do default(none) firstprivate(a, b) shared(sum) private(i)
+  do i = 1, 5
+    sum(i) = a(i) + b(i)
+  end do
+  !$omp end parallel do
+end subroutine example
+```
+
+To save memory, change their scope to shared. This may also prevent memory
+issues when using arrays, as codes may easily run out of memory for a high
+number of threads:
+
+```f90
+subroutine example()
+  implicit none
+  integer :: i
+  integer :: a(5) = [1, 2, 3, 4, 5]
+  integer :: b(5) = [6, 7, 8, 9, 10]
+  integer :: sum(5)
+
+  !$omp parallel do default(none) shared(a, b, sum) private(i)
+  do i = 1, 5
+    sum(i) = a(i) + b(i)
+  end do
+  !$omp end parallel do
+end subroutine example
+```
+
 ### Related resources
 
 * [PWR006 examples](../PWR006)

Checks/PWR006/example.c

@@ -7,7 +7,7 @@ void example() {
   int B[SIZE] = {5, 4, 3, 2, 1};
   int sum[SIZE];
 
-  #pragma omp parallel for shared(sum) firstprivate(A, B)
+  #pragma omp parallel for shared(sum) firstprivate(A, B) private(i)
   for (int i = 0; i < SIZE; i++) {
     sum[i] = A[i] + B[i];
   }

Checks/PWR006/example.f90

@@ -1,15 +1,15 @@
 ! PWR006: Avoid privatization of read-only variables
 
-program example
+subroutine example()
   implicit none
   integer :: i
   integer :: a(5) = [1, 2, 3, 4, 5]
   integer :: b(5) = [6, 7, 8, 9, 10]
   integer :: sum(5)
 
-  !$omp parallel do default(none) firstprivate(a, b) shared(sum)
+  !$omp parallel do default(none) firstprivate(a, b) shared(sum) private(i)
   do i = 1, 5
-    sum(i) = a(i) + b(i);
+    sum(i) = a(i) + b(i)
   end do
   !$omp end parallel do
-end program example
+end subroutine example

Checks/PWR009/README.md

@@ -38,6 +38,8 @@ is used.
 
 ### Code example
 
+#### C
+
 The following code offloads a matrix multiplication computation through the
 `target` construct and then creates a parallel region and distributes the work
 through `for` construct (note that the matrices are statically sized arrays):
@@ -60,9 +62,9 @@ through `for` construct (note that the matrices are statically sized arrays):
 } // end target
 ```
 
-When offloading to the GPU it is recommended to use an additional level of
+When offloading to the GPU, it is recommended to use an additional level of
 parallelism. This can be achieved by using the `teams` and `distribute`
-constructs, in this case in combination with `parallel for`:
+constructs; in this case, in combination with `parallel for`:
 
 ```c
 #pragma omp target teams distribute parallel for \
@@ -77,6 +79,48 @@ for (size_t i = 0; i < m; i++) {
 }
 ```
 
+#### Fortran
+
+The following code offloads a matrix multiplication computation through the
+`target` construct and then creates a parallel region and distributes the work
+through the `do` construct:
+
+```f90
+!$omp target map(to: A, B) map(tofrom: C)
+!$omp parallel default(none) private(i, j, k) shared(A, B, C)
+!$omp do
+do j = 1, size(C, 2)
+  do k = 1, size(C, 2)
+    do i = 1, size(C, 1)
+      C(i, j) = C(i, j) + A(i, k) * B(k, j)
+    end do
+  end do
+end do
+!$omp end do
+!$omp end parallel
+!$omp end target
+```
+
+When offloading to the GPU, it is recommended to use an additional level of
+parallelism. This can be achieved by using the `teams` and `distribute`
+constructs; in this case, in combination with `parallel do`:
+
+```f90
+!$omp target teams distribute map(to: A, B) map(tofrom: C)
+!$omp parallel default(none) private(i, j, k) shared(A, B, C)
+!$omp do
+do j = 1, size(C, 2)
+  do k = 1, size(C, 2)
+    do i = 1, size(C, 1)
+      C(i, j) = C(i, j) + A(i, k) * B(k, j)
+    end do
+  end do
+end do
+!$omp end do
+!$omp end parallel
+!$omp end target
+```
+
 ### Related resources
 
 * [PWR009 examples](../PWR009)