Merge pull request #767 from os-fpga/cleanup_and_logfile

planning utils: cleanup and logfile

Author: serge-dsa

planning/src/main.cpp

@@ -1,4 +1,4 @@
-static const char* _pln_VERSION_STR = "pln0267";
+static const char* _pln_VERSION_STR = "pln0270";
 
 #include "RS/rsEnv.h"
 #include "util/pln_log.h"

planning/src/util/cmd_line.cpp

@@ -9,45 +9,44 @@ cmd_line::cmd_line(int argc, const char** argv) {
 
   bool needVal = false;
   string key, s;
+  auto& ls = lout();
 
   for (int i = 1; i < argc; ++i) {
     assert(argv[i]);
     s = argv[i];
     if (s.size() < 2) {
-      cout << "Warning: Not a valid flag  \"" << s << "\" discarding" << endl;
+      ls << "Warning: Not a valid flag  \"" << s << "\" discarding" << endl;
       continue;
     }
     if ('-' == s[0]) {
       if ('-' == s[1]) {  // param key
         if (needVal)
-          cout << "Warning: Key " << key << " did not get a value" << endl;
+          ls << "Warning: Key " << key << " did not get a value" << endl;
         needVal = true;
         key = s;
       } else {  // flag
         flags_.insert(s);
         if (needVal)
-          cout << "Warning: Key " << key << " did not get a value" << endl;
+          ls << "Warning: Key " << key << " did not get a value" << endl;
         needVal = false;
       }
     } else {  // param value
       if (needVal) {
         params_[key] = s;
         needVal = false;
       } else {
-        cout << "Warning: No key for value " << s << endl;
+        ls << "Warning: No key for value " << s << endl;
       }
     }
   }
 }
 
-void cmd_line::set_flag(const string& fl) { flags_.insert(fl); }
-
-void cmd_line::set_param_value(string& key, string& val) { params_[key] = val; }
-
 void cmd_line::print_options() const {
-  cout << "Flags :\n";
-  for (const auto& f : flags_) cout << "\t" << f << endl;
-  cout << "Params :" << endl;
+  auto& ls = lout();
+
+  ls << "Flags :\n";
+  for (const auto& f : flags_) ls << "\t" << f << endl;
+  ls << "Params :" << endl;
 
   // sort by name
   vector<pair<string, string>> V;
@@ -56,7 +55,10 @@ void cmd_line::print_options() const {
 
   std::sort(V.begin(), V.end());
 
-  for (const auto& p : V) cout << '\t' << p.first << '\t' << p.second << endl;
+  for (const auto& p : V) {
+    ls << '\t' << p.first << '\t' << p.second << endl;
+  }
+}
+
 }
 
-}  // namespace pln

planning/src/util/cmd_line.h

@@ -19,22 +19,24 @@ struct cmd_line {
 
   cmd_line(int argc, const char **argv);
 
-  const unordered_set<string> &get_flag_set() const { return flags_; }
-  unordered_map<string, string> get_param_map() const { return params_; }
+  const unordered_set<string>&  get_flag_set() const noexcept { return flags_; }
+  const unordered_map<string, string>&  get_param_map() const noexcept { return params_; }
 
-  bool is_flag_set(const string &fl) const noexcept { return flags_.count(fl); }
+  bool is_flag_set(const string& fl) const noexcept { return flags_.count(fl); }
 
-  string get_param(const string &key) const noexcept {
+  string get_param(const string& key) const noexcept {
     auto fitr = params_.find(key);
-    if (fitr == params_.end()) return "";
+    if (fitr == params_.end()) return {};
     return fitr->second;
   }
 
-  void set_flag(const string &fl);
-  void set_param_value(string &key, string &val);
+  void set_flag(const string& fl) { flags_.insert(fl); }
+
+  void set_param_value(const string& key, const string& val) { params_[key] = val; }
+
   void print_options() const;
 };
 
-}  // namespace pln
+}
 
 #endif

planning/src/util/pln_log.cpp

@@ -1,9 +1,9 @@
 #include "util/pln_log.h"
 
-#include <stdarg.h>
 #include <alloca.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <stdarg.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
@@ -12,21 +12,13 @@ namespace pln {
 
 using namespace std;
 
+static void flush_all() noexcept;
+
 // log-trace value (debug print verbosity)
 // can be set in main() by calling set_ltrace()
 static uint16_t s_logLevel = 0;
-uint16_t ltrace() noexcept { return s_logLevel; }
 
-static void flush_all() noexcept {
-  // Flushing does not prevent interleaved stdout and stderr
-  // becauses FOEDAG messes with child process stdout.
-  // pin_c will create a separate 'pin_c.log' sometime.
-  fflush(stdout);
-  fflush(stderr);
-  cout.flush();
-  cerr.flush();
-  // ::fsync(1);
-}
+uint16_t ltrace() noexcept { return s_logLevel; }
 
 void set_ltrace(int t) noexcept {
   flush_all();
@@ -42,6 +34,52 @@ void set_ltrace(int t) noexcept {
   s_logLevel = t;
 }
 
+//
+// LOut is an ostream that splits the output,
+// i.e. it prints to a file (logfile) and to stdout.
+/////////////
+
+static constexpr size_t LOut_buf_cap = 65518;
+
+LOut::LOut() noexcept : std::ostream(this), buf_sz_(0) {
+  buf_ = (char*)::calloc(LOut_buf_cap + 2, 1);
+  assert(buf_);
+}
+
+LOut::~LOut() {
+  if (buf_sz_) cout << buf_ << endl;
+  fflush(stdout);
+  fflush(stderr);
+  cout.flush();
+  cerr.flush();
+}
+
+int LOut::overflow(int c) {
+  if (c == '\n') {
+    cout << buf_;
+    flush_out(true);
+    if (buf_sz_)
+      buf_sz_--;
+    return 0;
+  }
+  assert(buf_sz_ < LOut_buf_cap);
+  buf_[buf_sz_++] = c;
+  return 0;
+}
+
+/////////////
+
+static void flush_all() noexcept {
+  // Flushing does not prevent interleaved stdout and stderr
+  // becauses FOEDAG messes with child process stdout.
+  // pin_c will create a separate 'pin_c.log' sometime.
+  fflush(stdout);
+  fflush(stderr);
+  cout.flush();
+  cerr.flush();
+  // ::fsync(1);
+}
+
 #define LPUT if (cs && cs[0]) cout << cs;
 #define LEND cout << endl; fflush(stdout);
 

planning/src/util/pln_log.h

@@ -6,9 +6,7 @@
 //   lprintf2 : log-printf with CC to stderr
 //
 //     lputs  : log-puts
-//      lout  : replaces cout, will print to both stdout and logfile
-//
-//  currently, log- functions just print on stdout, real logfile can be added later
+//      LOut  : replaces cout, prints to both stdout and logfile
 //
 //  lputs<Number> functions are equivalent to lputs(),
 //  there are convenient "anchor points" for setting temporary breakpoints.
@@ -323,9 +321,24 @@ inline void logVec(const std::vector<T>& vec, CStr pref) noexcept {
 template <typename T>
 inline T* unconst(const T* p) noexcept { return const_cast<T*>(p); }
 
-}  // namespace pln
+//
+// LOut is an ostream that splits the output,
+// i.e. it prints to a file (logfile) and to stdout.
+//
+struct LOut : public std::ostream, public std::streambuf {
+  char* buf_ = nullptr;
+  uint buf_sz_ = 0;
 
-namespace pinc = pln;
+  LOut() noexcept;
+  virtual ~LOut();
+
+  virtual int overflow(int c) override;
+
+  LOut(const LOut&) = delete;
+  LOut& operator = (const LOut&) = delete;
+};
+
+}  // namespace pln
 
 const char* pln_get_version();