proper skip omp parallel loops

Author: jangorecki

src/froll.c

@@ -231,7 +231,7 @@ void frollmeanExact(const double *x, uint64_t nx, ans_t *ans, int k, double fill
   }
   bool truehasnf = hasnf>0;                                     // flag to re-run with NA support if NAs detected
   if (!truehasnf || !narm) {
-    #pragma omp parallel for num_threads(getDTthreads(nx, true))
+    #pragma omp parallel for num_threads(getDTthreads(nx, true)) shared(truehasnf)
     for (uint64_t i=k-1; i<nx; i++) {                           // loop on every observation with complete window, partial already filled in single threaded section
       if (narm && truehasnf) {
         continue;                                               // if NAs detected no point to continue
@@ -251,6 +251,7 @@ void frollmeanExact(const double *x, uint64_t nx, ans_t *ans, int k, double fill
         if (!narm) {
           ans->dbl_v[i] = (double) w;                           // NAs should be propagated
         }
+        #pragma omp atomic write
         truehasnf = true;                                       // NAs detected for this window, set flag so rest of windows will not be re-run
       } else {
         ans->dbl_v[i] = (double) w;                             // Inf and -Inf
@@ -418,7 +419,7 @@ void frollsumExact(const double *x, uint64_t nx, ans_t *ans, int k, double fill,
   }
   bool truehasnf = hasnf>0;
   if (!truehasnf || !narm) {
-    #pragma omp parallel for num_threads(getDTthreads(nx, true))
+    #pragma omp parallel for num_threads(getDTthreads(nx, true)) shared(truehasnf)
     for (uint64_t i=k-1; i<nx; i++) {
       if (narm && truehasnf) {
         continue;
@@ -433,6 +434,7 @@ void frollsumExact(const double *x, uint64_t nx, ans_t *ans, int k, double fill,
         if (!narm) {
           ans->dbl_v[i] = (double) w;
         }
+        #pragma omp atomic write
         truehasnf = true;
       } else {
         ans->dbl_v[i] = (double) w;
@@ -1065,7 +1067,7 @@ void frollprodExact(const double *x, uint64_t nx, ans_t *ans, int k, double fill
   }
   bool truehasnf = hasnf>0;
   if (!truehasnf || !narm) {
-    #pragma omp parallel for num_threads(getDTthreads(nx, true))
+    #pragma omp parallel for num_threads(getDTthreads(nx, true)) shared(truehasnf)
     for (uint64_t i=k-1; i<nx; i++) {
       if (narm && truehasnf) {
         continue;
@@ -1080,6 +1082,7 @@ void frollprodExact(const double *x, uint64_t nx, ans_t *ans, int k, double fill
         if (!narm) {
           ans->dbl_v[i] = (double) w;
         }
+        #pragma omp atomic write
         truehasnf = true;
       } else {
         ans->dbl_v[i] = (double) w;

src/frolladaptive.c

@@ -202,7 +202,7 @@ void frolladaptivemeanExact(const double *x, uint64_t nx, ans_t *ans, const int
     snprintf(end(ans->message[0]), 500, _("%s: running in parallel for input length %"PRIu64", hasnf %d, narm %d\n"), "frolladaptivemeanExact", (uint64_t)nx, hasnf, (int) narm);
   bool truehasnf = hasnf>0;                                     // flag to re-run if NAs detected
   if (!truehasnf || !narm) {                                    // narm=FALSE handled here as NAs properly propagated in exact algo
-    #pragma omp parallel for num_threads(getDTthreads(nx, true))
+    #pragma omp parallel for num_threads(getDTthreads(nx, true)) shared(truehasnf)
     for (uint64_t i=0; i<nx; i++) {                             // loop on every observation to produce final answer
       if (narm && truehasnf) {
         continue;                                               // if NAs detected no point to continue
@@ -225,6 +225,7 @@ void frolladaptivemeanExact(const double *x, uint64_t nx, ans_t *ans, const int
           if (!narm) {
             ans->dbl_v[i] = (double) w;
           }
+          #pragma omp atomic write
           truehasnf = true;                                     // NAs detected for this window, set flag so rest of windows will not be re-run
         } else {
           ans->dbl_v[i] = (double) w;                           // Inf and -Inf
@@ -422,7 +423,7 @@ void frolladaptivesumExact(const double *x, uint64_t nx, ans_t *ans, const int *
     snprintf(end(ans->message[0]), 500, _("%s: running in parallel for input length %"PRIu64", hasnf %d, narm %d\n"), "frolladaptivesumExact", (uint64_t)nx, hasnf, (int) narm);
   bool truehasnf = hasnf>0;
   if (!truehasnf || !narm) {
-    #pragma omp parallel for num_threads(getDTthreads(nx, true))
+    #pragma omp parallel for num_threads(getDTthreads(nx, true)) shared(truehasnf)
     for (uint64_t i=0; i<nx; i++) {
       if (narm && truehasnf) {
         continue;
@@ -440,6 +441,7 @@ void frolladaptivesumExact(const double *x, uint64_t nx, ans_t *ans, const int *
           if (!narm) {
             ans->dbl_v[i] = (double) w;
           }
+          #pragma omp atomic write
           truehasnf = true;                                     // NAs detected for this window, set flag so rest of windows will not be re-run
         } else {
           ans->dbl_v[i] = (double) w;                           // Inf and -Inf
@@ -657,7 +659,7 @@ void frolladaptiveprodExact(const double *x, uint64_t nx, ans_t *ans, const int
     snprintf(end(ans->message[0]), 500, _("%s: running in parallel for input length %"PRIu64", hasnf %d, narm %d\n"), "frolladaptiveprodExact", (uint64_t)nx, hasnf, (int) narm);
   bool truehasnf = hasnf>0;
   if (!truehasnf || !narm) {
-    #pragma omp parallel for num_threads(getDTthreads(nx, true))
+    #pragma omp parallel for num_threads(getDTthreads(nx, true)) shared(truehasnf)
     for (uint64_t i=0; i<nx; i++) {
       if (narm && truehasnf) {
         continue;
@@ -675,6 +677,7 @@ void frolladaptiveprodExact(const double *x, uint64_t nx, ans_t *ans, const int
           if (!narm) {
             ans->dbl_v[i] = (double) w;
           }
+          #pragma omp atomic write
           truehasnf = true;                                     // NAs detected for this window, set flag so rest of windows will not be re-run
         } else {
           ans->dbl_v[i] = (double) w;                           // Inf and -Inf