Handle output log directory creation and log file dumping

Author: dutta-alankar

src/global.cpp

@@ -8,6 +8,17 @@
 #include <iostream>
 #include <string>
 #include <sstream>
+
+#if __has_include(<filesystem>)
+  #include <filesystem> // NOLINT [build/c++17]
+  namespace fs = std::filesystem;
+#elif __has_include(<experimental/filesystem>)
+  #include <experimental/filesystem>
+  namespace fs = std::experimental::filesystem;
+#else
+  #error "Missing the <filesystem> header."
+#endif
+
 #include "idefix.hpp"
 #include "global.hpp"
 #include "profiler.hpp"
@@ -105,12 +116,34 @@ void IdefixOutStream::init(int rank) {
 
 
 // disable the log file
-void IdefixOutStream::enableLogFile() {
+void IdefixOutStream::enableLogFile(const std::string &logDirectory) {
   std::stringstream sslogFileName;
   sslogFileName << "idefix." << idfx::prank << ".log";
 
-  std::string logFileName(sslogFileName.str());
+  std::string logFileName;
+  if(!logDirectory.empty()) {
+    fs::path outputDirectory(logDirectory);
+    std::error_code errorCode;
+    // Attempt to create the directory. We deliberately ignore the boolean return
+    // value of create_directories: when several MPI processes call this function
+    // concurrently, only one of them actually creates the directory while the
+    // others get a "false" return (nothing created) even though no error
+    // occurred. Relying on that return value would make the losing ranks abort
+    // spuriously. Instead, we verify success by checking that the path exists as
+    // a directory afterwards, which is robust to this race condition.
+    fs::create_directories(outputDirectory, errorCode);
+    if(!fs::is_directory(outputDirectory)) {
+      IDEFIX_ERROR("Unable to create log directory " + logDirectory);
+    }
+    logFileName = (outputDirectory / sslogFileName.str()).string();
+  } else {
+    logFileName = sslogFileName.str();
+  }
+
   this->my_fstream.open(logFileName.c_str());
+  if(!this->my_fstream.is_open()) {
+    IDEFIX_ERROR("Unable to open log file " + logFileName);
+  }
 
   this->logFileEnabled = true;
 }

src/global.hpp

@@ -66,7 +66,7 @@ void DumpArray(std::string filename, ArrayType array) {
 class idfx::IdefixOutStream {
  public:
   void init(int);
-  void enableLogFile();
+  void enableLogFile(const std::string &logDirectory = "");
   // for regular output of variables and stuff
   template<typename T> IdefixOutStream& operator<<(const T& something) {
     if(toscreen) std::cout << something;

src/input.cpp

@@ -16,6 +16,16 @@
 #include <vector>
 #include <memory>
 
+#if __has_include(<filesystem>)
+  #include <filesystem> // NOLINT [build/c++17]
+  namespace fs = std::filesystem;
+#elif __has_include(<experimental/filesystem>)
+  #include <experimental/filesystem>
+  namespace fs = std::experimental::filesystem;
+#else
+  #error "Missing the <filesystem> header."
+#endif
+
 #include "idefix.hpp"
 #include "input.hpp"
 #include "version.hpp"
@@ -57,6 +67,15 @@ Input::Input(int argc, char* argv[] ) {
   // Parse command line (may replace the input file)
   ParseCommandLine(argc,argv);
 
+  // Determine executable directory. This is the fallback log destination when
+  // [Output]:log_dir is not defined in the input file.
+  fs::path executablePath(argv[0]);
+  std::error_code errorCode;
+  executablePath = fs::absolute(executablePath, errorCode);
+  if(!errorCode && executablePath.has_parent_path()) {
+    this->executableDirectory = executablePath.parent_path().string();
+  }
+
   file.open(this->inputFileName);
 
   if(!file) {
@@ -108,12 +127,20 @@ Input::Input(int argc, char* argv[] ) {
     }
   }
   file.close();
+
+  if(this->enableLogs) {
+    if(CheckEntry("Output","log_dir") > 0) {
+      idfx::cout.enableLogFile(Get<std::string>("Output","log_dir",0));
+    } else {
+      idfx::cout.enableLogFile(this->executableDirectory);
+    }
+  }
 }
 
 // This routine parse command line options
 void Input::ParseCommandLine(int argc, char **argv) {
   std::stringstream msg;
-  bool enableLogs = true;
+  this->enableLogs = true;
   for(int i = 1 ; i < argc ; i++) {
     // MPI decomposition argument
     if(std::string(argv[i]) == "-dec") {
@@ -171,9 +198,9 @@ void Input::ParseCommandLine(int argc, char **argv) {
       this->forceInitRequested = true;
     } else if(std::string(argv[i]) == "-nowrite") {
       this->forceNoWrite = true;
-      enableLogs = false;
+      this->enableLogs = false;
     } else if(std::string(argv[i]) == "-nolog") {
-      enableLogs = false;
+      this->enableLogs = false;
     } else if(std::string(argv[i]) == "-profile") {
       idfx::prof.EnablePerformanceProfiling();
     } else if(std::string(argv[i]) == "-Werror") {
@@ -190,9 +217,6 @@ void Input::ParseCommandLine(int argc, char **argv) {
       IDEFIX_ERROR(msg);
     }
   }
-  if(enableLogs) {
-    idfx::cout.enableLogFile();
-  }
 }
 
 

src/input.hpp

@@ -73,6 +73,8 @@ class Input {
   Kokkos::Timer timer;
 
   double lastStopFileCheck;
+  bool enableLogs{true};
+  std::string executableDirectory{"."};
 };
 
 // Template functions