src/framework/JetScapeLogger.cc

0001 /*******************************************************************************
0002  * Copyright (c) The JETSCAPE Collaboration, 2018
0003  *
0004  * Modular, task-based framework for simulating all aspects of heavy-ion collisions
0005  *
0006  * For the list of contributors see AUTHORS.
0007  *
0008  * Report issues at https://github.com/JETSCAPE/JETSCAPE/issues
0009  *
0010  * or via email to bugs.jetscape@gmail.com
0011  *
0012  * Distributed under the GNU General Public License 3.0 (GPLv3 or later).
0013  * See COPYING for details.
0014  ******************************************************************************/
0015
0016 #include <stddef.h>
0017 #include <fstream>
0018
0019 #include "JetScapeLogger.h"
0020
0021 using namespace std;
0022
0023 // For Linux systems (also Mac)
0024 // only shows max usage throughtout the program
0025
0026 #include <sys/time.h>
0027 #include <sys/resource.h>
0028
0029 long getMemoryUsage() {
0030   struct rusage usage;
0031   // NOTE: Reported in kB on BSD/Linux, bytes in Mac/Darwin
0032   // Could try to explicitly catch __linux__ as well
0033   float mbsize = 1024;
0034 #ifdef __MACH__
0035   mbsize = 1024 * 1024;
0036 #endif
0037
0038   if (0 == getrusage(RUSAGE_SELF, &usage))
0039     return usage.ru_maxrss / mbsize;
0040   else
0041     return 0;
0042 }
0043
0044 /*
0045 //For mac os x only ...
0046 // shows current usage
0047 #include <mach/mach.h>
0048 #include <mach/task.h>
0049
0050 int getMemoryUsage()
0051 {
0052   struct mach_task_basic_info info;
0053   mach_msg_type_number_t size = MACH_TASK_BASIC_INFO_COUNT;
0054   kern_return_t kerr = task_info(mach_task_self(),
0055                  MACH_TASK_BASIC_INFO,
0056                  (task_info_t)&info,
0057                  &size);
0058   if( kerr == KERN_SUCCESS )
0059     return info.resident_size/1024./1024.;
0060   else {
0061     cout<<"Error with task_info(): "<<mach_error_string(kerr)<<endl;
0062     return -1;}
0063 }
0064  */
0065
0066 // Just some definition of colors for colored terminal log output
0067 // Resetting to default color in LogStreamer!
0068
0069 #define BLACK "\033[30m"              /* Black */
0070 #define RED "\033[31m"                /* Red */
0071 #define GREEN "\033[32m"              //\033[7;30m" bkg     /* Green */
0072 #define YELLOW "\033[33m"             /* Yellow */
0073 #define BLUE "\033[34m"               /* Blue */
0074 #define MAGENTA "\033[35m"            /* Magenta */
0075 #define CYAN "\033[36m"               /* Cyan */
0076 #define WHITE "\033[37m"              /* White */
0077 #define BOLDBLACK "\033[1m\033[30m"   /* Bold Black */
0078 #define BOLDRED "\033[1m\033[31m"     /* Bold Red */
0079 #define BOLDGREEN "\033[1m\033[32m"   /* Bold Green */
0080 #define BOLDYELLOW "\033[1m\033[33m"  /* Bold Yellow */
0081 #define BOLDBLUE "\033[1m\033[34m"    /* Bold Blue */
0082 #define BOLDMAGENTA "\033[1m\033[35m" /* Bold Magenta */
0083 #define BOLDCYAN "\033[1m\033[36m"    /* Bold Cyan */
0084 #define BOLDWHITE "\033[1m\033[37m"   /* Bold White */
0085
0086 #define CLEAR "\033[2J" // clear screen escape code
0087
0088 namespace Jetscape {
0089
0090 std::ostringstream null;
0091
0092 SafeOstream safe_cout(std::cout);
0093 SafeOstream safe_cerr(std::cerr);
0094 SafeOstream safe_null(null);
0095
0096 JetScapeLogger *JetScapeLogger::m_pInstance = NULL;
0097
0098 JetScapeLogger *JetScapeLogger::Instance() {
0099   if (!m_pInstance)
0100     m_pInstance = new JetScapeLogger();
0101
0102   return m_pInstance;
0103 }
0104
0105 LogStreamer JetScapeLogger::Warn() {
0106   string s = "[Warning] ";
0107   //s << __PRETTY_FUNCTION__ <<":"<<__LINE__<<" ";
0108   //return LogStreamer(std::cout<<s<<__PRETTY_FUNCTION__ <<":"<<__LINE__<<" ");
0109   return LogStreamer(std::cout << BOLDRED << s);
0110 }
0111
0112 LogStreamerThread JetScapeLogger::DebugThread() {
0113   if (debug) {
0114     string s = "[Debug Thread] ";
0115     //s <<  __PRETTY_FUNCTION__ <<":"<<__LINE__<<" ";
0116     s += to_string(getMemoryUsage());
0117     s += "MB ";
0118     return (LogStreamerThread(safe_cout) << BLUE << s);
0119   } else {
0120     // check if it is not written in some system log files ...
0121     //safe_null.setstate(std::ios_base::failbit);
0122     return LogStreamerThread(safe_null);
0123   }
0124 }
0125
0126 LogStreamer JetScapeLogger::Debug() {
0127   if (debug) {
0128     string s = "[Debug] ";
0129     //s <<  __PRETTY_FUNCTION__ <<":"<<__LINE__<<" ";
0130     s += to_string(getMemoryUsage());
0131     s += "MB ";
0132     return LogStreamer(std::cout << BLUE << s);
0133   } else {
0134     null.setstate(std::ios_base::failbit);
0135     return LogStreamer(null);
0136   }
0137 }
0138
0139 LogStreamer JetScapeLogger::Info() {
0140   string s = "[Info] ";
0141   // s <<  __PRETTY_FUNCTION__ <<":"<<__LINE__<<" ";
0142   if (info) {
0143     string s = "[Info] ";
0144     // s <<  __PRETTY_FUNCTION__ <<":"<<__LINE__<<" ";
0145     s += to_string(getMemoryUsage());
0146     s += "MB ";
0147     return LogStreamer(std::cout << s);
0148   } else {
0149     null.setstate(std::ios_base::failbit);
0150     return LogStreamer(null);
0151   }
0152 }
0153
0154 LogStreamer JetScapeLogger::InfoNice() {
0155   string s = "[Info] ";
0156   // s <<  __PRETTY_FUNCTION__ <<":"<<__LINE__<<" ";
0157   //s += to_string(getMemoryUsage()); s+="MB ";
0158   if (info) {
0159     return LogStreamer(std::cout << s);
0160   } else {
0161     null.setstate(std::ios_base::failbit);
0162     return LogStreamer(null);
0163   }
0164 }
0165
0166 LogStreamer JetScapeLogger::Remark() {
0167   if (remark) {
0168     string s = "[REMARK] ";
0169     return LogStreamer(std::cout << BOLDMAGENTA << s);
0170   } else {
0171     null.setstate(std::ios_base::failbit);
0172     return LogStreamer(null);
0173   }
0174 }
0175
0176 LogStreamer JetScapeLogger::Verbose(unsigned short m_vlevel) {
0177   if (m_vlevel < vlevel) // or if (m_vlevel==vlevel)
0178   {
0179     string s = "[Verbose][";
0180     s += std::to_string(m_vlevel);
0181     s += "] ";
0182     s += to_string(getMemoryUsage());
0183     s += "MB ";
0184     return LogStreamer(std::cout << GREEN << s);
0185   } else {
0186     null.setstate(std::ios_base::failbit);
0187     return LogStreamer(null);
0188   }
0189 }
0190
0191 LogStreamer JetScapeLogger::VerboseShower(unsigned short m_vlevel) {
0192   if (m_vlevel < vlevel) // or if (m_vlevel==vlevel)
0193   {
0194     string s = "[Verbose][";
0195     s += std::to_string(m_vlevel);
0196     s += "] ";
0197     s += to_string(getMemoryUsage());
0198     s += "MB ";
0199     return LogStreamer(std::cout << BOLDCYAN << s);
0200   } else {
0201     null.setstate(std::ios_base::failbit);
0202     return LogStreamer(null);
0203   }
0204 }
0205
0206 LogStreamer JetScapeLogger::VerboseParton(unsigned short m_vlevel, Parton &p) {
0207   if (m_vlevel < vlevel) // or if (m_vlevel==vlevel)
0208   {
0209     string s = "[Verbose][";
0210     s += std::to_string(m_vlevel);
0211     s += "] Parton: ";
0212     return LogStreamer(std::cout << GREEN << s << " " << p << endl);
0213   } else {
0214     null.setstate(std::ios_base::failbit);
0215     return LogStreamer(null);
0216   }
0217 }
0218
0219 LogStreamer JetScapeLogger::VerboseVertex(unsigned short m_vlevel, Vertex &v) {
0220   if (m_vlevel < vlevel) // or if (m_vlevel==vlevel)
0221   {
0222     string s = "[Verbose][";
0223     s += std::to_string(m_vlevel);
0224     s += "] Vertex: ";
0225     return LogStreamer(std::cout << GREEN << s << " " << v << endl);
0226   } else {
0227     null.setstate(std::ios_base::failbit);
0228     return LogStreamer(null);
0229   }
0230 }
0231
0232 } // end namespace Jetscape