Logging.h

Go to the documentation of this file.

//============================================================================
//  The contents of this file are covered by the Viskores license. See
//  LICENSE.txt for details.
//
//  By contributing to this file, all contributors agree to the Developer
//  Certificate of Origin Version 1.1 (DCO 1.1) as stated in DCO.txt.
//============================================================================
 
//============================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt for details.
//
//  This software is distributed WITHOUT ANY WARRANTY; without even
//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//  PURPOSE.  See the above copyright notice for more information.
//============================================================================
#ifndef viskores_cont_Logging_h
#define viskores_cont_Logging_h
 
#include <viskores/internal/Configure.h>
#include <viskores/internal/ExportMacros.h>
 
#include <viskores/Types.h>
 
#include <viskores/cont/viskores_cont_export.h>
 
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <typeindex>
#include <typeinfo>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
#define VISKORES_CONCAT_IMPL(s1, s2) s1##s2
#define VISKORES_CONCAT(s1, s2) VISKORES_CONCAT_IMPL(s1, s2)
 
#ifdef __COUNTER__
#define VISKORES_ANONYMOUS_VARIABLE VISKORES_CONCAT(viskores_anonymous_, __COUNTER__)
#else
#define VISKORES_ANONYMOUS_VARIABLE VISKORES_CONCAT(viskores_anonymous_, __LINE__)
#endif
 
#if defined(VISKORES_ENABLE_LOGGING)
 
#define VISKORES_LOG_IF_S(level, cond, ...) \
  viskores::cont::LogCondStream(level, cond, __FILE__, __LINE__) << __VA_ARGS__
 
#define VISKORES_LOG_IF_F(level, cond, ...) \
  viskores::cont::LogCond(level, cond, __FILE__, __LINE__, __VA_ARGS__)
 
#define VISKORES_LOG_S(level, ...) VISKORES_LOG_IF_S(level, true, __VA_ARGS__)
#define VISKORES_LOG_F(level, ...) VISKORES_LOG_IF_F(level, true, __VA_ARGS__)
 
#define VISKORES_LOG_SCOPE(level, ...)                         \
  viskores::cont::detail::LogScope VISKORES_ANONYMOUS_VARIABLE \
  {                                                            \
    level, __FILE__, __LINE__, __VA_ARGS__                     \
  }
 
#define VISKORES_LOG_SCOPE_FUNCTION(level) VISKORES_LOG_SCOPE(level, __func__)
#define VISKORES_LOG_ALWAYS_S(level, ...) VISKORES_LOG_S(level, __VA_ARGS__)
 
 
// Convenience macros:
 
// Cast success:
#define VISKORES_LOG_CAST_SUCC(inObj, outObj)                  \
  VISKORES_LOG_F(viskores::cont::LogLevel::Cast,               \
                 "Cast succeeded: %s (%p) --> %s (%p)",        \
                 viskores::cont::TypeToString(inObj).c_str(),  \
                 &inObj,                                       \
                 viskores::cont::TypeToString(outObj).c_str(), \
                 &outObj)
 
// Cast failure:
#define VISKORES_LOG_CAST_FAIL(inObj, outType)                \
  VISKORES_LOG_F(viskores::cont::LogLevel::Cast,              \
                 "Cast failed: %s (%p) --> %s",               \
                 viskores::cont::TypeToString(inObj).c_str(), \
                 &inObj,                                      \
                 viskores::cont::TypeToString<outType>().c_str())
 
// TryExecute failure
#define VISKORES_LOG_TRYEXECUTE_FAIL(errorMessage, functorName, deviceId)              \
  VISKORES_LOG_S(viskores::cont::LogLevel::Error,                                      \
                 "TryExecute encountered an error: " << errorMessage);                 \
  VISKORES_LOG_S(viskores::cont::LogLevel::Error, "Failing functor: " << functorName); \
  VISKORES_LOG_S(viskores::cont::LogLevel::Error, "Failing device: " << deviceId.GetName())
 
// Same, but disabling device:
#define VISKORES_LOG_TRYEXECUTE_DISABLE(errorMessage, functorName, deviceId)                 \
  VISKORES_LOG_S(viskores::cont::LogLevel::Error,                                            \
                 "TryExecute encountered an error: " << errorMessage);                       \
  VISKORES_LOG_S(viskores::cont::LogLevel::Error, "Failing functor: " << functorName);       \
  VISKORES_LOG_S(viskores::cont::LogLevel::Error, "Failing device: " << deviceId.GetName()); \
  VISKORES_LOG_S(viskores::cont::LogLevel::Error, "The failing device has been disabled.")
 
// Custom log level
#define VISKORES_DEFINE_USER_LOG_LEVEL(name, offset)                                      \
  static constexpr viskores::cont::LogLevel name = static_cast<viskores::cont::LogLevel>( \
    static_cast<typename std::underlying_type<viskores::cont::LogLevel>::type>(           \
      viskores::cont::LogLevel::UserFirst) +                                              \
    offset %                                                                              \
      static_cast<typename std::underlying_type<viskores::cont::LogLevel>::type>(         \
        viskores::cont::LogLevel::UserLast))
 
#else // VISKORES_ENABLE_LOGGING
 
#define VISKORES_LOG_S(level, ...)
#define VISKORES_LOG_F(level, ...)
#define VISKORES_LOG_IF_S(level, cond, ...)
#define VISKORES_LOG_IF_F(level, cond, ...)
#define VISKORES_LOG_SCOPE(level, ...)
#define VISKORES_LOG_SCOPE_FUNCTION(level)
#define VISKORES_LOG_ERROR_CONTEXT(desc, data)
#define VISKORES_LOG_CAST_SUCC(inObj, outObj)
#define VISKORES_LOG_CAST_FAIL(inObj, outType)
#define VISKORES_DEFINE_USER_LOG_LEVEL(name, offset)
 
// Always emitted. When logging is disabled, std::cerr is used.
 
#define VISKORES_LOG_ALWAYS_S(level, ...)               \
  (static_cast<int>(level) < 0 ? std::cerr : std::cout) \
    << viskores::cont::GetLogLevelName(level) << ": " << __VA_ARGS__ << "\n"
 
// TryExecute failures are still important enough to log, but we just write to
// std::cerr when logging is disabled.
#define VISKORES_LOG_TRYEXECUTE_FAIL(errorMessage, functorName, deviceId)         \
  std::cerr << "Error: TryExecute encountered an error: " << errorMessage << "\n" \
            << "\t- Failing functor: " << functorName << "\n"                     \
            << "\t- Failing device: " << deviceId.GetName() << "\n\n"
#define VISKORES_LOG_TRYEXECUTE_DISABLE(errorMessage, functorName, deviceId)      \
  std::cerr << "Error: TryExecute encountered an error: " << errorMessage << "\n" \
            << "\t- Failing functor: " << functorName << "\n"                     \
            << "\t- Failing device: " << deviceId.GetName() << "\n"               \
            << "The failing device has been disabled.\n\n"
 
#endif // VISKORES_ENABLE_LOGGING
 
namespace viskores
{
namespace cont
{
 
enum class LogLevel
{
  Off = -9, //loguru::Verbosity_OFF,
 
  Fatal = -3, // loguru::Verbosity_FATAL,
 
  Error = -2, // loguru::Verbosity_ERROR,
 
  Warn = -1, // loguru::Verbosity_WARNING,
 
  Info = 0, //loguru::Verbosity_INFO,
 
  UserFirst = 1,
  UserLast = 255,
 
  DevicesEnabled,
 
  Perf,
 
  MemCont,
 
  MemExec,
 
  MemTransfer,
 
  KernelLaunches,
 
  Cast,
 
  UserVerboseFirst = 1024,
  UserVerboseLast = 2047
};
 
 
VISKORES_CONT_EXPORT
VISKORES_CONT
void InitLogging(int& argc,
                 char* argv[],
                 const std::string& loggingFlag = "--viskores-log-level",
                 const std::string& loggingEnv = "VISKORES_LOG_LEVEL");
VISKORES_CONT_EXPORT
VISKORES_CONT
void InitLogging();
VISKORES_CONT_EXPORT
VISKORES_CONT
void SetStderrLogLevel(const char* verbosity);
 
VISKORES_CONT_EXPORT
VISKORES_CONT
void SetStderrLogLevel(viskores::cont::LogLevel level);
VISKORES_CONT_EXPORT
VISKORES_CONT
viskores::cont::LogLevel GetStderrLogLevel();
 
VISKORES_CONT_EXPORT
VISKORES_CONT
void SetLogLevelName(viskores::cont::LogLevel level, const std::string& name);
 
VISKORES_CONT_EXPORT
VISKORES_CONT
std::string GetLogLevelName(viskores::cont::LogLevel level);
 
VISKORES_CONT_EXPORT
VISKORES_CONT
void SetLogThreadName(const std::string& name);
VISKORES_CONT_EXPORT
VISKORES_CONT
std::string GetLogThreadName();
// Per-thread error context, not currently used, undocumented....
VISKORES_CONT_EXPORT
VISKORES_CONT
std::string GetLogErrorContext();
 
VISKORES_CONT_EXPORT
VISKORES_CONT
std::string GetStackTrace(viskores::Int32 skip = 0);
 
VISKORES_CONT_EXPORT
VISKORES_CONT
std::string GetHumanReadableSize(viskores::UInt64 bytes, int prec = 2);
 
template <typename T>
VISKORES_CONT inline std::string GetHumanReadableSize(T&& bytes, int prec = 2)
{
  return GetHumanReadableSize(static_cast<viskores::UInt64>(std::forward<T>(bytes)), prec);
}
 
VISKORES_CONT_EXPORT
VISKORES_CONT
std::string GetSizeString(viskores::UInt64 bytes, int prec = 2);
 
template <typename T>
VISKORES_CONT inline std::string GetSizeString(T&& bytes, int prec = 2)
{
  return GetSizeString(static_cast<viskores::UInt64>(std::forward<T>(bytes)), prec);
}
 
VISKORES_CONT_EXPORT VISKORES_CONT std::string TypeToString(const std::type_info& t);
VISKORES_CONT_EXPORT VISKORES_CONT std::string TypeToString(const std::type_index& t);
template <typename T>
inline VISKORES_CONT std::string TypeToString()
{
  return TypeToString(typeid(T));
}
template <typename T>
inline VISKORES_CONT std::string TypeToString(const T&)
{
  return TypeToString(typeid(T));
}
#ifdef VISKORES_ENABLE_LOGGING
 
VISKORES_CONT_EXPORT
VISKORES_CONT
void LogCond(LogLevel level, bool cond, const char* file, unsigned line, const char* format...);
 
namespace detail
{
 
class VISKORES_CONT_EXPORT LogScope
{
  struct InternalStruct;
  std::unique_ptr<InternalStruct> Internals;
 
public:
  /*
   * \param level  Desired LogLevel value for the log message.
   * \param cond   When false this function is no-op.
   * \param format Printf like format string.
   */
  VISKORES_CONT
  LogScope(LogLevel level, const char* file, unsigned line, const char* format...);
 
  VISKORES_CONT ~LogScope();
};
 
 
} // namespace detail
 
struct VISKORES_CONT_EXPORT LogCondStream
{
  VISKORES_CONT
  LogCondStream(LogLevel level, bool cond, const char* file, int line)
    : Level(level)
    , Condition(cond)
    , File(file)
    , Line(line)
  {
  }
 
  VISKORES_CONT
  ~LogCondStream() noexcept(false);
 
  template <typename T>
  VISKORES_CONT LogCondStream& operator<<(const T& in)
  {
    SStream << in;
    return *this;
  }
 
  VISKORES_CONT
  LogCondStream& operator<<(std::ostream& (*f)(std::ostream&))
  {
    f(SStream);
    return *this;
  }
 
private:
  LogLevel Level;
  bool Condition;
  const char* File;
  int Line;
  std::ostringstream SStream;
};
#endif // VISKORES_ENABLE_LOGGING
 
}
} // end namespace viskores::cont
 
#endif // viskores_cont_Logging_h