[OpenMP] Introduce new file wrapper class for runtime

[jlpeyton]

Summary

Introduce new kmp_safe_file_t class with RAII semantics for file open/close. It is essentially a wrapper around the C-style FILE* object. This also unifies the way we error report if a file can't be opened.

[jdoerfert]

Really nice cleanup. My only request is more documentation for new code.

openmp/runtime/src/kmp.h

4066

Please include doxygen documentation, at least for non trivial methods and the class. Maybe use "RAII" in the class name to indicate the functionality and make it clear there is no "close" needed at use sites.

[jlpeyton]

Updated with documentation. Class is now kmp_safe_raii_file_t

[jdoerfert]

Thanks!

LGTM, update the commit message wrt. class name.

openmp/runtime/src/kmp.h

 int __kmp_execute_tasks_oncore(kmp_info_t *thread, kmp_int32 gtid,
                                kmp_flag_oncore *flag, int final_spin,
                                int *thread_finished,
 #if USE_ITT_BUILD
                                void *itt_sync_obj,
 #endif /* USE_ITT_BUILD */
                                kmp_int32 is_constrained);
 
+class kmp_safe_file_t {
+  FILE *f;
+
+  void close() {
+    if (f && f != stdout && f != stderr) {
+      fclose(f);
+      f = nullptr;
+    }
+  }
+
+public:
+  kmp_safe_file_t() : f(nullptr) {}
+  kmp_safe_file_t(const char *filename, const char *mode,
+                  const char *env_var = nullptr)
+      : f(nullptr) {
+    open(filename, mode, env_var);
+  }
+  ~kmp_safe_file_t() { close(); }
+
+  void open(const char *filename, const char *mode,
+            const char *env_var = nullptr) {
+    KMP_ASSERT(!f);
+    f = fopen(filename, mode);
+    if (!f) {
+      int code = errno;
+      if (env_var) {
+        __kmp_fatal(KMP_MSG(CantOpenFileForReading, filename), KMP_ERR(code),
+                    KMP_HNT(CheckEnvVar, env_var, filename), __kmp_msg_null);
+      } else {
+        __kmp_fatal(KMP_MSG(CantOpenFileForReading, filename), KMP_ERR(code),
+                    __kmp_msg_null);
+      }
+    }
+  }
+  void set_stdout() {
+    KMP_ASSERT(!f);
+    f = stdout;
+  }
+  void set_stderr() {
+    KMP_ASSERT(!f);
+    f = stderr;
+  }
+  operator bool() { return bool(f); }
+  operator FILE *() { return f; }
+};
+
 #endif /* KMP_H */

openmp/runtime/src/kmp_affinity.cpp

if (depth < 0) {
         if (msg_id != kmp_i18n_null) {
           KMP_INFORM(AffStrParseFilename, "KMP_AFFINITY",
                      __kmp_i18n_catgets(msg_id), "/proc/cpuinfo");
         } else {
           KMP_INFORM(AffParseFilename, "KMP_AFFINITY", "/proc/cpuinfo");
         }
       }
 
-      FILE *f = fopen("/proc/cpuinfo", "r");
-      if (f == NULL) {
-        msg_id = kmp_i18n_str_CantOpenCpuinfo;
-      } else {
-        file_name = "/proc/cpuinfo";
-        depth =
-            __kmp_affinity_create_cpuinfo_map(&address2os, &line, &msg_id, f);
-        fclose(f);
-        if (depth == 0) {
-          KMP_EXIT_AFF_NONE;
-        }
-      }
-    }
+      kmp_safe_file_t f("/proc/cpuinfo", "r");
+      depth = __kmp_affinity_create_cpuinfo_map(&address2os, &line, &msg_id, f);
 
 #endif /* KMP_OS_LINUX */
 
 #if KMP_GROUP_AFFINITY
 
     if ((depth < 0) && (__kmp_num_proc_groups > 1)) {
       if (__kmp_affinity_verbose) {
         KMP_INFORM(AffWindowsProcGroupMap, "KMP_AFFINITY");
if (depth < 0) {
       KMP_FATAL(MsgExiting, __kmp_i18n_catgets(msg_id));
     }
   }
 
 #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
 
   else if (__kmp_affinity_top_method == affinity_top_method_cpuinfo) {
     const char *filename;
+    const char *env_var = nullptr;
     if (__kmp_cpuinfo_file != NULL) {
       filename = __kmp_cpuinfo_file;
+      env_var = "KMP_CPUINFO_FILE";
     } else {
       filename = "/proc/cpuinfo";
     }
 
     if (__kmp_affinity_verbose) {
       KMP_INFORM(AffParseFilename, "KMP_AFFINITY", filename);
     }
 
-    FILE *f = fopen(filename, "r");
-    if (f == NULL) {
-      int code = errno;
-      if (__kmp_cpuinfo_file != NULL) {
-        __kmp_fatal(KMP_MSG(CantOpenFileForReading, filename), KMP_ERR(code),
-                    KMP_HNT(NameComesFrom_CPUINFO_FILE), __kmp_msg_null);
-      } else {
-        __kmp_fatal(KMP_MSG(CantOpenFileForReading, filename), KMP_ERR(code),
-                    __kmp_msg_null);
-      }
-    }
+    kmp_safe_file_t f(filename, "r", env_var);
     int line = 0;
     depth = __kmp_affinity_create_cpuinfo_map(&address2os, &line, &msg_id, f);
-    fclose(f);
     if (depth < 0) {
       KMP_ASSERT(msg_id != kmp_i18n_null);
       if (line > 0) {
         KMP_FATAL(FileLineMsgExiting, filename, line,
                   __kmp_i18n_catgets(msg_id));
       } else {
         KMP_FATAL(FileMsgExiting, filename, __kmp_i18n_catgets(msg_id));
       }

openmp/runtime/src/kmp_lock.cpp

static void __kmp_accumulate_speculative_stats(kmp_adaptive_lock_info_t *lck) {
 
   __kmp_release_bootstrap_lock(&chain_lock);
 }
 
 static float percent(kmp_uint32 count, kmp_uint32 total) {
   return (total == 0) ? 0.0 : (100.0 * count) / total;
 }
 
-static FILE *__kmp_open_stats_file() {
-  if (strcmp(__kmp_speculative_statsfile, "-") == 0)
-    return stdout;
-
-  size_t buffLen = KMP_STRLEN(__kmp_speculative_statsfile) + 20;
-  char buffer[buffLen];
-  KMP_SNPRINTF(&buffer[0], buffLen, __kmp_speculative_statsfile,
-               (kmp_int32)getpid());
-  FILE *result = fopen(&buffer[0], "w");
-
-  // Maybe we should issue a warning here...
-  return result ? result : stdout;
-}
-
 void __kmp_print_speculative_stats() {
   kmp_adaptive_lock_statistics_t total = destroyedStats;
   kmp_adaptive_lock_info_t *lck;
 
   for (lck = liveLocks.stats.next; lck != &liveLocks; lck = lck->stats.next) {
     __kmp_add_stats(&total, lck);
   }
   kmp_adaptive_lock_statistics_t *t = &total;
   kmp_uint32 totalSections =
       t->nonSpeculativeAcquires + t->successfulSpeculations;
   kmp_uint32 totalSpeculations = t->successfulSpeculations +
                                  t->hardFailedSpeculations +
                                  t->softFailedSpeculations;
   if (totalSections <= 0)
     return;
 
-  FILE *statsFile = __kmp_open_stats_file();
+  kmp_safe_file_t statsFile;
+  if (strcmp(__kmp_speculative_statsfile, "-") == 0) {
+    statsFile.set_stdout();
+  } else {
+    size_t buffLen = KMP_STRLEN(__kmp_speculative_statsfile) + 20;
+    char buffer[buffLen];
+    KMP_SNPRINTF(&buffer[0], buffLen, __kmp_speculative_statsfile,
+                 (kmp_int32)getpid());
+    statsFile.open(buffer, "w");
+  }
 
   fprintf(statsFile, "Speculative lock statistics (all approximate!)\n");
   fprintf(statsFile, " Lock parameters: \n"
                      "   max_soft_retries               : %10d\n"
                      "   max_badness                    : %10d\n",
           __kmp_adaptive_backoff_params.max_soft_retries,
           __kmp_adaptive_backoff_params.max_badness);
   fprintf(statsFile, " Non-speculative acquire attempts : %10d\n",
fprintf(statsFile, " Successes                        : %10d (%5.1f%%)\n",
           t->successfulSpeculations,
           percent(t->successfulSpeculations, totalSpeculations));
   fprintf(statsFile, " Soft failures                    : %10d (%5.1f%%)\n",
           t->softFailedSpeculations,
           percent(t->softFailedSpeculations, totalSpeculations));
   fprintf(statsFile, " Hard failures                    : %10d (%5.1f%%)\n",
           t->hardFailedSpeculations,
           percent(t->hardFailedSpeculations, totalSpeculations));
-
-  if (statsFile != stdout)
-    fclose(statsFile);
 }
 
 #define KMP_INC_STAT(lck, stat) (lck->lk.adaptive.stats.stat++)
 #else
 #define KMP_INC_STAT(lck, stat)
 
 #endif // KMP_DEBUG_ADAPTIVE_LOCKS
 

openmp/runtime/src/kmp_stats.cpp

 #include <sstream>
 #include <stdlib.h> // for atexit
 #include <cmath>
 
 #define STRINGIZE2(x) #x
 #define STRINGIZE(x) STRINGIZE2(x)
 
 #define expandName(name, flags, ignore) {STRINGIZE(name), flags},
 statInfo timeStat::timerInfo[] = {
     KMP_FOREACH_TIMER(expandName, 0){"TIMER_LAST", 0}};
 const statInfo counter::counterInfo[] = {
     KMP_FOREACH_COUNTER(expandName, 0){"COUNTER_LAST", 0}};
 #undef expandName
 
 #define expandName(ignore1, ignore2, ignore3) {0.0, 0.0, 0.0},
 kmp_stats_output_module::rgb_color kmp_stats_output_module::timerColorInfo[] = {
     KMP_FOREACH_TIMER(expandName, 0){0.0, 0.0, 0.0}};
 #undef expandName
 
 const kmp_stats_output_module::rgb_color
     kmp_stats_output_module::globalColorArray[] = {
         {1.0, 0.0, 0.0}, // red
         {1.0, 0.6, 0.0}, // orange
         {1.0, 1.0, 0.0}, // yellow
         {0.0, 1.0, 0.0}, // green
         {0.0, 0.0, 1.0}, // blue
         {0.6, 0.2, 0.8}, // purple
         {1.0, 0.0, 1.0}, // magenta
         {0.0, 0.4, 0.2}, // dark green
kmp_stats_output_module::globalColorArray[] = {
         {0.7, 0.6, 0.0}, // gold
         {0.0, 0.0, 0.0} // black
 };
 
 // Ensure that the atexit handler only runs once.
 static uint32_t statsPrinted = 0;
 
 // output interface
 static kmp_stats_output_module *__kmp_stats_global_output = NULL;
 
 double logHistogram::binMax[] = {
     1.e1l,  1.e2l,  1.e3l,  1.e4l,  1.e5l,  1.e6l,  1.e7l,  1.e8l,
     1.e9l,  1.e10l, 1.e11l, 1.e12l, 1.e13l, 1.e14l, 1.e15l, 1.e16l,
     1.e17l, 1.e18l, 1.e19l, 1.e20l, 1.e21l, 1.e22l, 1.e23l, 1.e24l,
     1.e25l, 1.e26l, 1.e27l, 1.e28l, 1.e29l, 1.e30l};
 
 /* ************* statistic member functions ************* */
 
 void statistic::addSample(double sample) {
   sample -= offset;
   KMP_DEBUG_ASSERT(std::isfinite(sample));
 
   double delta = sample - meanVal;
 
   sampleCount = sampleCount + 1;
   meanVal = meanVal + delta / sampleCount;
   m2 = m2 + delta * (sample - meanVal);
 
   minVal = std::min(minVal, sample);
   maxVal = std::max(maxVal, sample);
   if (collectingHist)
     hist.addSample(sample);
 }
 
 statistic &statistic::operator+=(const statistic &other) {
   if (other.sampleCount == 0)
     return *this;
 
   if (sampleCount == 0) {
     *this = other;
     return *this;
   }
 
statistic &statistic::operator+=(const statistic &other) {
   maxVal = std::max(maxVal, other.maxVal);
   sampleCount = newSampleCount;
   if (collectingHist)
     hist += other.hist;
 
   return *this;
 }
 
 void statistic::scale(double factor) {
   minVal = minVal * factor;
   maxVal = maxVal * factor;
   meanVal = meanVal * factor;
   m2 = m2 * factor * factor;
   return;
 }
 
 std::string statistic::format(char unit, bool total) const {
   std::string result = formatSI(sampleCount, 9, ' ');
 
   if (sampleCount == 0) {
     result = result + std::string(", ") + formatSI(0.0, 9, unit);
     result = result + std::string(", ") + formatSI(0.0, 9, unit);
     result = result + std::string(", ") + formatSI(0.0, 9, unit);
     if (total)
       result = result + std::string(", ") + formatSI(0.0, 9, unit);
     result = result + std::string(", ") + formatSI(0.0, 9, unit);
   } else {
     result = result + std::string(", ") + formatSI(minVal, 9, unit);
     result = result + std::string(", ") + formatSI(meanVal, 9, unit);
     result = result + std::string(", ") + formatSI(maxVal, 9, unit);
     if (total)
       result =
           result + std::string(", ") + formatSI(meanVal * sampleCount, 9, unit);
     result = result + std::string(", ") + formatSI(getSD(), 9, unit);
   }
   return result;
 }
 
 /* ************* histogram member functions ************* */
 
 // Lowest bin that has anything in it
 int logHistogram::minBin() const {
   for (int i = 0; i < numBins; i++) {
     if (bins[i].count != 0)
       return i - logOffset;
   }
   return -logOffset;
 }
 
 // Highest bin that has anything in it
for (it = __kmp_stats_list->begin(); it != __kmp_stats_list->end(); it++) {
     ptr->getPartitionedTimers()->windup();
     ptr->endLife();
   }
 }
 
 void kmp_stats_output_module::printPloticusFile() {
   int i;
   int size = __kmp_stats_list->size();
-  FILE *plotOut = fopen(plotFileName, "w+");
-
+  kmp_safe_file_t plotOut(plotFileName, "w+");
   fprintf(plotOut, "#proc page\n"
                    "   pagesize: 15 10\n"
                    "   scale: 1.0\n\n");
 
   fprintf(plotOut, "#proc getdata\n"
                    "   file: %s\n\n",
           eventsFileName);
 
if (timeStat::logEvent((timer_e)i)) {
                        "   details: rgb(%1.1f,%1.1f,%1.1f)\n\n",
               timeStat::name((timer_e)i), c.r, c.g, c.b);
     }
   }
 
   fprintf(plotOut, "#proc legend\n"
                    "   format: down\n"
                    "   location: max max\n\n");
-  fclose(plotOut);
   return;
 }
 
 static void outputEnvVariable(FILE *statsOut, char const *name) {
   char const *value = getenv(name);
   fprintf(statsOut, "# %s = %s\n", name, value ? value : "*unspecified*");
 }
 
void kmp_stats_output_module::outputStats(const char *heading) {
   // constructors so will take time to create.
   windupExplicitTimers();
 
   statistic allStats[TIMER_LAST];
   statistic totalStats[TIMER_LAST]; /* Synthesized, cross threads versions of
                                        normal timer stats */
   statistic allCounters[COUNTER_LAST];
 
-  FILE *statsOut =
-      !outputFileName.empty() ? fopen(outputFileName.c_str(), "a+") : stderr;
-  if (!statsOut)
-    statsOut = stderr;
+  kmp_safe_file_t statsOut;
+  if (!outputFileName.empty()) {
+    statsOut.open(outputFileName.c_str(), "a+");
+  } else {
+    statsOut.set_stderr();
+  }
 
-  FILE *eventsOut;
+  kmp_safe_file_t eventsOut;
   if (eventPrintingEnabled()) {
-    eventsOut = fopen(eventsFileName, "w+");
+    eventsOut.open(eventsFileName, "w+");
   }
 
   printHeaderInfo(statsOut);
   fprintf(statsOut, "%s\n", heading);
   // Accumulate across threads.
   kmp_stats_list::iterator it;
   for (it = __kmp_stats_list->begin(); it != __kmp_stats_list->end(); it++) {
     int t = (*it)->getGtid();
for (counter_e c = counter_e(0); c < COUNTER_LAST; c = counter_e(c + 1)) {
       if (counter::masterOnly(c) && t != 0)
         continue;
       allCounters[c].addSample((*it)->getCounter(c)->getValue());
     }
   }
 
   if (eventPrintingEnabled()) {
     printPloticusFile();
-    fclose(eventsOut);
   }
 
   fprintf(statsOut, "Aggregate for all threads\n");
   printTimerStats(statsOut, &allStats[0], &totalStats[0]);
   fprintf(statsOut, "\n");
   printCounterStats(statsOut, &allCounters[0]);
-
-  if (statsOut != stderr)
-    fclose(statsOut);
 }
 
 /* *************  exported C functions ************** */
 
 // no name mangling for these functions, we want the c files to be able to get
 // at these functions
 extern "C" {