orthanc: Core/Logging.cpp comparison

comparison Core/Logging.cpp @ 1495:fbe40117eb21

improve the performance of the internal logger

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Thu, 06 Aug 2015 18:19:32 +0200
parents	a13581480b1f
children	46b2794042d6

comparison

equal deleted inserted replaced

-:a13581480b1f
+:fbe40117eb21
 /*********************************************************
 * Use internal logger, not Google Log
 *********************************************************/
 #include "OrthancException.h"
+#include "Enumerations.h"
 #include "Toolbox.h"
 #include <fstream>
 #include <boost/filesystem.hpp>
 #include <boost/thread.hpp>
 #endif
 namespace
 {
-struct NullStream : public std::ostream
+struct LoggingState
 {
-NullStream() : std::ios(0), std::ostream(0)
+bool infoEnabled_;
+bool traceEnabled_;
+std::ostream* error_;
+std::ostream* warning_;
+std::ostream* info_;
+std::auto_ptr<std::ofstream> errorFile_;
+std::auto_ptr<std::ofstream> warningFile_;
+std::auto_ptr<std::ofstream> infoFile_;
+LoggingState() :
+infoEnabled_(false),
+traceEnabled_(false),
+error_(&std::cerr),
+warning_(&std::cerr),
+info_(&std::cerr)
 {
 }
 };
 }
-static boost::mutex  mutex_;
-static bool infoEnabled_ = false;
+static std::auto_ptr<LoggingState> loggingState_;
-static bool traceEnabled_ = false;
+static boost::mutex  loggingMutex_;
-static std::ostream* error_ = &std::cerr;
-static std::ostream* warning_ = &std::cerr;
-static std::ostream* info_ = &std::cerr;
-static NullStream null_;
-static std::auto_ptr<std::ofstream> errorFile_;
-static std::auto_ptr<std::ofstream> warningFile_;
-static std::auto_ptr<std::ofstream> infoFile_;
 namespace Orthanc
 {
 namespace Logging
 {
 }
 void Initialize()
 {
-infoEnabled_ = false;
+boost::mutex::scoped_lock lock(loggingMutex_);
-traceEnabled_ = false;
+loggingState_.reset(new LoggingState);
 }
 void Finalize()
 {
-errorFile_.reset(NULL);
+boost::mutex::scoped_lock lock(loggingMutex_);
-warningFile_.reset(NULL);
+loggingState_.reset(NULL);
-infoFile_.reset(NULL);
 }
 void EnableInfoLevel(bool enabled)
 {
-boost::mutex::scoped_lock lock(mutex_);
+boost::mutex::scoped_lock lock(loggingMutex_);
-infoEnabled_ = enabled;
+assert(loggingState_.get() != NULL);
+loggingState_->infoEnabled_ = enabled;
 }
 void EnableTraceLevel(bool enabled)
 {
-boost::mutex::scoped_lock lock(mutex_);
+boost::mutex::scoped_lock lock(loggingMutex_);
-traceEnabled_ = enabled;
+assert(loggingState_.get() != NULL);
+loggingState_->traceEnabled_ = enabled;
 if (enabled)
 {
 // Also enable the "INFO" level when trace-level debugging is enabled
-infoEnabled_ = true;
+loggingState_->infoEnabled_ = true;
 }
 }
 void SetTargetFolder(const std::string& path)
 {
-boost::mutex::scoped_lock lock(mutex_);
+boost::mutex::scoped_lock lock(loggingMutex_);
-PrepareLogFile(error_, errorFile_, "ERROR", path);
+assert(loggingState_.get() != NULL);
-PrepareLogFile(warning_, warningFile_, "WARNING", path);
-PrepareLogFile(info_, infoFile_, "INFO", path);
+PrepareLogFile(loggingState_->error_,   loggingState_->errorFile_,   "ERROR", path);
+PrepareLogFile(loggingState_->warning_, loggingState_->warningFile_, "WARNING", path);
+PrepareLogFile(loggingState_->info_,    loggingState_->infoFile_,    "INFO", path);
 }
 InternalLogger::InternalLogger(const char* level,
 const char* file,
 int line) :
-lock_(mutex_)
+lock_(loggingMutex_),
-{
+stream_(&null_)  // By default, logging to "/dev/null" is simulated
-char c;
+{
+if (loggingState_.get() == NULL)
-if (strcmp(level, "ERROR") == 0)
+{
-{
+fprintf(stderr, "ERROR: Trying to log a message after the finalization of the logging engine\n");
-stream_ = error_;
+return;
-c = 'E';
+}
-}
-else if (strcmp(level, "WARNING") == 0)
+LogLevel l = StringToLogLevel(level);
-{
-stream_ = warning_;
+if ((l == LogLevel_Info  && !loggingState_->infoEnabled_) ||
-c = 'W';
+(l == LogLevel_Trace && !loggingState_->traceEnabled_))
-}
+{
-else if (strcmp(level, "INFO") == 0)
+// This logging level is disabled, directly exit and unlock
-{
+// the mutex to speed-up things. The stream is set to "/dev/null"
-stream_ = infoEnabled_ ? info_ : &null_;
+lock_.unlock();
-c = 'I';
+return;
 }
-else if (strcmp(level, "TRACE") == 0)
-{
+// Compute the header of the line, temporary release the lock as
-stream_ = traceEnabled_ ? info_ : &null_;
+// this is a time-consuming operation
-c = 'T';
+lock_.unlock();
-}
+std::string header;
-else
-{
-// Unknown logging level
-throw OrthancException(ErrorCode_InternalError);
-}
-if (stream_ != &null_)
 {
 boost::filesystem::path path(file);
 boost::posix_time::ptime now = boost::posix_time::microsec_clock::local_time();
 boost::posix_time::time_duration duration = now.time_of_day();
 In this implementation, "threadid" is not printed.
 **/
 char date[32];
-sprintf(date, "%c%02d%02d %02d:%02d:%02d.%06d ", c,
+sprintf(date, "%c%02d%02d %02d:%02d:%02d.%06d ",
+level[0],
 now.date().month().as_number(),
 now.date().day().as_number(),
 duration.hours(),
 duration.minutes(),
 duration.seconds(),
 static_cast<int>(duration.fractional_seconds()));
-*stream_ << date << path.filename().string() << ":" << line << "] ";
+header = std::string(date) + path.filename().string() + ":" + boost::lexical_cast<std::string>(line) + "] ";
 }
+// The header is computed, we now re-lock the mutex to access
+// the stream objects. Pay attention that "loggingState_",
+// "infoEnabled_" or "traceEnabled_" might have changed while
+// the mutex was unlocked.
+lock_.lock();
+if (loggingState_.get() == NULL)
+{
+fprintf(stderr, "ERROR: Trying to log a message after the finalization of the logging engine\n");
+return;
+}
+switch (l)
+{
+case LogLevel_Error:
+stream_ = loggingState_->error_;
+break;
+case LogLevel_Warning:
+stream_ = loggingState_->warning_;
+break;
+case LogLevel_Info:
+if (loggingState_->infoEnabled_)
+{
+stream_ = loggingState_->info_;
+}
+break;
+case LogLevel_Trace:
+if (loggingState_->traceEnabled_)
+{
+stream_ = loggingState_->info_;
+}
+break;
+default:
+throw OrthancException(ErrorCode_InternalError);
+}
+if (stream_ == &null_)
+{
+// The logging is disabled for this level. The stream is the
+// "null_" member of this object, so we can release the global
+// mutex.
+lock_.unlock();
+}
+(*stream_) << header;
 }
 }
 }
 #endif

Mercurial > hg > orthanc

comparison Core/Logging.cpp @ 1495:fbe40117eb21