|| || || || || ||

---

ILog.h

Go to the documentation of this file.

#ifndef Impala_Basis_ILog_h
#define Impala_Basis_ILog_h

//#include "Link/OGL/UndefLinkListMacros.h"
#include "Basis/LibConfig.h"
#include "Basis/String.h"
#include "Basis/StringList.h"

// Currently, we have 3 loggers:
// 1 (LOG4CPP_USED) : Log4cpp : external library 
// 2 (BASISLOG_USED): Basis/Logger : Ork's logger
// 3:(STDLOG_USED)  : StdLog : just put messages on std::cout
#ifndef LOG4CPP_USED
#ifndef STDLOG_USED
#define BASISLOG_USED
#endif
#endif

#ifdef __CUDACC__
#undef LOG4CPP_USED
#undef BASISLOG_USED
#define STDLOG_USED
#endif // __CUDACC__



static int ILOG_EXIT_CODE = 42;
static bool gExitOnErrorLogged = false;
static bool gLog4CppFlushOutput = false;

#ifdef LOG4CPP_USED
#include <log4cpp/PropertyConfigurator.hh>
#include <log4cpp/Category.hh>
#include <log4cpp/NDC.hh>
#include <log4cpp/FileAppender.hh>
#include <log4cpp/OstreamAppender.hh>
#include <log4cpp/BasicLayout.hh>
#include <log4cpp/PatternLayout.hh>
#include <log4cpp/StringQueueAppender.hh>
#include "Basis/FileExists.h"
#include "Link/Mpi/MpiFuncs.h"
#include <strstream>

#define ILOG_VAR_DEC static log4cpp::Category& sLog

#define ILOG_VAR_INIT(classstring,pathstring) \
    log4cpp::Category& classstring::sLog( \
        log4cpp::Category::getInstance( #pathstring "." #classstring))

// Following variations are for template classes.
// A variation with 9 template args is left as an exercise for the reader ;-)
#define ILOG_VAR_INIT_TEMPL_1(classstring,templ,pathstring) \
    template <class templ> \
    log4cpp::Category& classstring<templ>::sLog( \
            log4cpp::Category::getInstance( #pathstring "." #classstring))

#define ILOG_VAR_INIT_TEMPL_2(classstring,templ1,templ2,pathstring) \
    template <class templ1, class templ2> \
    log4cpp::Category& classstring<templ1,templ2>::sLog( \
            log4cpp::Category::getInstance( #pathstring "." #classstring))

#define ILOG_VAR_INIT_TEMPL_4(classstring,templ1,templ2,templ3,templ4,pathstring) \
    template <class templ1, class templ2, class templ3, class templ4> \
    log4cpp::Category& classstring<templ1,templ2,templ3,templ4>::sLog( \
            log4cpp::Category::getInstance( #pathstring "." #classstring))

#define ILOG_VAR(funcstring) \
    static log4cpp::Category& sLog = log4cpp::Category::getInstance( #funcstring )

#define ILOG_DEBUG(message)                     \
    {                                           \
        if (sLog.isDebugEnabled())              \
        {                                       \
            sLog.debugStream() << message;      \
            if (gLog4CppFlushOutput)            \
            {                                   \
                sLog.debugStream().flush();     \
                std::cout.flush();              \
            }                                   \
        }                                       \
    }

#define ILOG_INFO(message)                      \
    {                                           \
        if (sLog.isInfoEnabled())               \
        {                                       \
            sLog.infoStream() << message;       \
            if (gLog4CppFlushOutput)            \
            {                                   \
                sLog.infoStream().flush();      \
                std::cout.flush();              \
            }                                   \
        }                                       \
    }

#define ILOG_WARN(message)                      \
    {                                           \
        if (sLog.isWarnEnabled())               \
        {                                       \
            sLog.warnStream() << message;       \
            if (gLog4CppFlushOutput)            \
            {                                   \
                sLog.warnStream().flush();      \
                std::cout.flush();              \
            }                                   \
        }                                       \
    }

#define ILOG_ERROR(message)                     \
    {                                           \
        if (sLog.isErrorEnabled())              \
        {                                       \
            sLog.errorStream() << message;      \
            if (gLog4CppFlushOutput)            \
            {                                   \
                sLog.errorStream().flush();     \
                std::cout.flush();              \
                std::cerr.flush();              \
            }                                   \
        }                                       \
        if (gExitOnErrorLogged)                 \
            exit(ILOG_EXIT_CODE);               \
    }

// Sander: experimental
#define ILOG_STATS_VAR_DECL static log4cpp::Category& sStatsLog
#define ILOG_STATS_VAR_INIT(classstring,pathstring) log4cpp::Category& classstring::sStatsLog(log4cpp::Category::getInstance( #pathstring "." #classstring))
#define ILOG_STATS_PRE(message) { sStatsLog.infoStream() << "PRE : " << message; }
#define ILOG_STATS_POST(message) { sStatsLog.infoStream() << "POST: " << message; }

// Ork: to be redefined later:
#define ILOG_USER(message) { if (sLog.isInfoEnabled()) sLog.infoStream() << "USER:" << message; }
#define ILOG_SYSTEM(message) { if (sLog.isInfoEnabled()) sLog.infoStream() << "USER:" << message; }

// Ork: to be nicely redefined later:
#define ILOG_STARTACTION(actionname, level) { sLog.infoStream() << "START: " << level << " " << actionname; }
#define ILOG_ENDACTION(actionname) { sLog.infoStream() << "STOP:  " << actionname; }
#define ILOG_LEVEL_DEBUG 1
#define ILOG_LEVEL_INFO 2
#define ILOG_LEVEL_SYSTEM 6
#define ILOG_LEVEL_USER 7

inline void
ILOG_START_DEBUG()
{
    log4cpp::Category& root = log4cpp::Category::getRoot();
    root.setPriority(log4cpp::Priority::DEBUG);
}

inline void
ILOG_STOP_DEBUG()
{
    log4cpp::Category& root = log4cpp::Category::getRoot();
    root.setPriority(log4cpp::Priority::INFO);
}

#define ILOG_NDC_PUSH(message) { \
        std::ostringstream oss; \
        oss << message; \
        log4cpp::NDC::push(oss.str()); }
#define ILOG_NDC_POP log4cpp::NDC::pop()

#endif // LOG4CPP_USED

#ifdef BASISLOG_USED
#include "Basis/Logger.h"

#define ILOG_VAR_DEC static Impala::String sLog
#define ILOG_VAR_INIT(classstring,pathstring) Impala::String classstring::sLog = #pathstring "." #classstring
#define ILOG_VAR_INIT_TEMPL_1(classstring,templ,pathstring) \
    template <class templ> \
    Impala::String classstring<templ>::sLog = #pathstring "." #classstring
#define ILOG_VAR_INIT_TEMPL_2(classstring,templ1,templ2,pathstring) \
    template <class templ1,class templ2>                                             \
    Impala::String classstring<templ1,templ2>::sLog = #pathstring "." #classstring
#define ILOG_VAR_INIT_TEMPL_4(classstring,templ1,templ2,templ3,templ4,pathstring) \
    template <class templ1,class templ2,class templ3,class templ4>                     \
    Impala::String classstring<templ1,templ2,templ3,templ4>::sLog = #pathstring "." #classstring
#define ILOG_VAR(funcstring) static Impala::String sLog = #funcstring
#define ILOG_DEBUG(message) { Impala::Logger::Debug() << sLog << " " << message << std::endl; }
#define ILOG_INFO(message) { Impala::Logger::Information() << sLog << " " << message << std::endl; }
#define ILOG_WARN(message) { Impala::Logger::Warning() << sLog << " " << message << std::endl; }
#define ILOG_ERROR(message) { Impala::Logger::Error() << sLog << " " << message << std::endl; if (gExitOnErrorLogged) exit(ILOG_EXIT_CODE); }
#define ILOG_USER(message) { Impala::Logger::User() << sLog << " " << message << std::endl; }
#define ILOG_SYSTEM(message) { Impala::Logger::System() << sLog << " " << message << std::endl; }

// Ork: note: level nrs correspond to level nrs in Logger...
#define ILOG_STARTACTION(actionname, level) { Impala::Logger::StartAction(actionname, level); }
#define ILOG_ENDACTION(actionname) { Impala::Logger::EndAction(actionname); }
#define ILOG_LEVEL_DEBUG 1
#define ILOG_LEVEL_INFO 2
#define ILOG_LEVEL_SYSTEM 6
#define ILOG_LEVEL_USER 7

#define ILOG_NDC_PUSH(message)
#define ILOG_NDC_POP

#endif // BASISLOG_USED

#ifdef STDLOG_USED
#define ILOG_DEBUG(message) { }
#define ILOG_WARN(message)  { std::cout << "[WARN] " << message << std::endl; }
#define ILOG_INFO(message)  { std::cout << "[INFO] " << message << std::endl; }
#define ILOG_ERROR(message) { std::cerr << "[ERROR] " << message << std::endl; }
#define ILOG_VAR_DEC 
#define ILOG_VAR_DECL
#define ILOG_VAR_INIT(message, msg2) 
#define ILOG_VAR_INIT_TEMPL_1(a1, a2, a3) 
#define ILOG_VAR_INIT_TEMPL_2(a1, a2, a3, a4) 
#define ILOG_VAR_INIT_TEMPL_4(a1, a2, a3, a4, a5, a6) 
#define ILOG_VAR(message) 
#endif // STDLOG_USED


#define ILOG_VAR_DECL ILOG_VAR_DEC
#define ILOG_WARNING ILOG_WARN
// these alternative names are added in the hope that they prove easier to remember
#define ILOG_FUNCTION ILOG_VAR
#define ILOG_CLASS ILOG_VAR_DEC
#define ILOG_CLASS_INIT ILOG_VAR_INIT

/* These versions can be used inside a loop to print progress without flooding
   the output stream. Messages are printed as INFO messages. All messages within
   'timeout' seconds of the last printed message are suppressed.
   This works in loops and recursive functions. But since it is implemented
   through a static timer in the function where it is used the timeout is
   limited. We could move the timer to the log4cpp implementation if we want.
*/
#define ILOG_PROGRESS(message, timeout)  \
    {                                    \
        static double sLastTime=-0.;     \
        static Timer sTimer(0);          \
        double now = sTimer.SplitTime(); \
        if(now - sLastTime > timeout)    \
        {                                \
            sLastTime = now;             \
            ILOG_INFO(message);          \
        }                                \
    }

// this one is added for naming consistency, at the end you might want to print
// a progress message regardless of the timeout :)
#define ILOG_PROGRESS_DONE(message) \
    ILOG_INFO(message)

#define ILOG_WARNING_ONCE(message)                                     \
    {                                                                  \
        ILOG_WARNING_ONCE_IMPL(message, sDid ## __LINE__ ## __FILE__ ) \
    }                                                                   

#define ILOG_WARNING_ONCE_IMPL(message, varname)  \
    static bool varname = false;                  \
    if(! varname )                                \
    {                                             \
        varname = true;                           \
        ILOG_WARNING(message);                    \
    }                                                       




namespace Impala
{

class ILogErrors
{

public:

    static ILogErrors&
    GetInstance()
    {
        static ILogErrors theILog;
        return theILog;
    }

    void
    SetAppender(void* appender)
    {
        mAppender = appender;
    }

    int
    GetTotalNrErrors()
    {
        Sync();
        return mErrors.size();
    }

    void
    Mark()
    {
        Sync();
        mMark = mErrors.size();
    }

    int
    GetNrErrorsSinceMark()
    {
        Sync();
        return mErrors.size() - mMark;
    }

    std::vector<String>
    GetErrorsSinceMark()
    {
        Sync();
        std::vector<String> res;
        for (int i=mMark ; i<mErrors.size() ; i++)
            res.push_back(mErrors[i]);
    }

    String
    GetLastErrorSinceMark()
    {
        Sync();
        return mErrors[mErrors.size() - 1];
    }

    void
    Print(bool fromMark)
    {
        Sync();
        int start = (fromMark) ? mMark : 0;
        for (int i=start ; i<mErrors.size() ; i++)
            std::cout << "ILog: " << mErrors[i] << std::endl;
    }

private:

    void
    Sync()
    {
#ifdef LOG4CPP_USED
        log4cpp::StringQueueAppender* appender = 
            (log4cpp::StringQueueAppender*) mAppender;
        while (appender->queueSize() > 0)
            mErrors.push_back(appender->popMessage());
#endif
    }

    ILogErrors()
    {
        mMark = 0;
    }

    ILogErrors(const ILogErrors&)
    {
    }

    ILogErrors&
    operator=(const ILogErrors&)
    {
    }

    int                 mMark;
    std::vector<String> mErrors;
    void*               mAppender;

};

#define ILOG_ERROR_COUNT ILogErrors::GetInstance().GetTotalNrErrors()

} // namespace Impala

#endif

---