Logging.h

Go to the documentation of this file.

//============================================================================
//  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 vtk_m_cont_Logging_h
#define vtk_m_cont_Logging_h
 
#include <vtkm/internal/Configure.h>
#include <vtkm/internal/ExportMacros.h>
 
#include <vtkm/Types.h>
 
#include <vtkm/cont/vtkm_cont_export.h>
 
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <typeindex>
#include <typeinfo>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
#define VTKM_CONCAT_IMPL(s1, s2) s1##s2
#define VTKM_CONCAT(s1, s2) VTKM_CONCAT_IMPL(s1, s2)
 
#ifdef __COUNTER__
#define VTKM_ANONYMOUS_VARIABLE VTKM_CONCAT(vtk_m_anonymous_, __COUNTER__)
#else
#define VTKM_ANONYMOUS_VARIABLE VTKM_CONCAT(vtk_m_anonymous_, __LINE__)
#endif
 
#if defined(VTKM_ENABLE_LOGGING)
 
#define VTKM_LOG_IF_S(level, cond, ...) \
  vtkm::cont::LogCondStream(level, cond, __FILE__, __LINE__) << __VA_ARGS__
 
#define VTKM_LOG_IF_F(level, cond, ...) \
  vtkm::cont::LogCond(level, cond, __FILE__, __LINE__, __VA_ARGS__)
 
#define VTKM_LOG_S(level, ...) VTKM_LOG_IF_S(level, true, __VA_ARGS__)
#define VTKM_LOG_F(level, ...) VTKM_LOG_IF_F(level, true, __VA_ARGS__)
 
#define VTKM_LOG_SCOPE(level, ...) \
  vtkm::cont::detail::LogScope VTKM_ANONYMOUS_VARIABLE { level, __FILE__, __LINE__, __VA_ARGS__ }
 
#define VTKM_LOG_SCOPE_FUNCTION(level) VTKM_LOG_SCOPE(level, __func__)
#define VTKM_LOG_ALWAYS_S(level, ...) VTKM_LOG_S(level, __VA_ARGS__)
 
 
// Convenience macros:
 
// Cast success:
#define VTKM_LOG_CAST_SUCC(inObj, outObj)              \
  VTKM_LOG_F(vtkm::cont::LogLevel::Cast,               \
             "Cast succeeded: %s (%p) --> %s (%p)",    \
             vtkm::cont::TypeToString(inObj).c_str(),  \
             &inObj,                                   \
             vtkm::cont::TypeToString(outObj).c_str(), \
             &outObj)
 
// Cast failure:
#define VTKM_LOG_CAST_FAIL(inObj, outType)            \
  VTKM_LOG_F(vtkm::cont::LogLevel::Cast,              \
             "Cast failed: %s (%p) --> %s",           \
             vtkm::cont::TypeToString(inObj).c_str(), \
             &inObj,                                  \
             vtkm::cont::TypeToString<outType>().c_str())
 
// TryExecute failure
#define VTKM_LOG_TRYEXECUTE_FAIL(errorMessage, functorName, deviceId)                           \
  VTKM_LOG_S(vtkm::cont::LogLevel::Error, "TryExecute encountered an error: " << errorMessage); \
  VTKM_LOG_S(vtkm::cont::LogLevel::Error, "Failing functor: " << functorName);                  \
  VTKM_LOG_S(vtkm::cont::LogLevel::Error, "Failing device: " << deviceId.GetName())
 
// Same, but disabling device:
#define VTKM_LOG_TRYEXECUTE_DISABLE(errorMessage, functorName, deviceId)                        \
  VTKM_LOG_S(vtkm::cont::LogLevel::Error, "TryExecute encountered an error: " << errorMessage); \
  VTKM_LOG_S(vtkm::cont::LogLevel::Error, "Failing functor: " << functorName);                  \
  VTKM_LOG_S(vtkm::cont::LogLevel::Error, "Failing device: " << deviceId.GetName());            \
  VTKM_LOG_S(vtkm::cont::LogLevel::Error, "The failing device has been disabled.")
 
// Custom log level
#define VTKM_DEFINE_USER_LOG_LEVEL(name, offset)                                  \
  static constexpr vtkm::cont::LogLevel name = static_cast<vtkm::cont::LogLevel>( \
    static_cast<typename std::underlying_type<vtkm::cont::LogLevel>::type>(       \
      vtkm::cont::LogLevel::UserFirst) +                                          \
    offset %                                                                      \
      static_cast<typename std::underlying_type<vtkm::cont::LogLevel>::type>(     \
        vtkm::cont::LogLevel::UserLast))
 
#else // VTKM_ENABLE_LOGGING
 
#define VTKM_LOG_S(level, ...)
#define VTKM_LOG_F(level, ...)
#define VTKM_LOG_IF_S(level, cond, ...)
#define VTKM_LOG_IF_F(level, cond, ...)
#define VTKM_LOG_SCOPE(level, ...)
#define VTKM_LOG_SCOPE_FUNCTION(level)
#define VTKM_LOG_ERROR_CONTEXT(desc, data)
#define VTKM_LOG_CAST_SUCC(inObj, outObj)
#define VTKM_LOG_CAST_FAIL(inObj, outType)
#define VTKM_DEFINE_USER_LOG_LEVEL(name, offset)
 
// Always emitted. When logging is disabled, std::cerr is used.
 
#define VTKM_LOG_ALWAYS_S(level, ...)                   \
  (static_cast<int>(level) < 0 ? std::cerr : std::cout) \
    << vtkm::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 VTKM_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 VTKM_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 // VTKM_ENABLE_LOGGING
 
namespace vtkm
{
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
};
 
 
VTKM_CONT_EXPORT
VTKM_CONT
void InitLogging(int& argc,
                 char* argv[],
                 const std::string& loggingFlag = "--vtkm-log-level",
                 const std::string& loggingEnv = "VTKM_LOG_LEVEL");
VTKM_CONT_EXPORT
VTKM_CONT
void InitLogging();
VTKM_CONT_EXPORT
VTKM_CONT
void SetStderrLogLevel(const char* verbosity);
 
VTKM_CONT_EXPORT
VTKM_CONT
void SetStderrLogLevel(vtkm::cont::LogLevel level);
VTKM_CONT_EXPORT
VTKM_CONT
vtkm::cont::LogLevel GetStderrLogLevel();
 
VTKM_CONT_EXPORT
VTKM_CONT
void SetLogLevelName(vtkm::cont::LogLevel level, const std::string& name);
 
VTKM_CONT_EXPORT
VTKM_CONT
std::string GetLogLevelName(vtkm::cont::LogLevel level);
 
VTKM_CONT_EXPORT
VTKM_CONT
void SetLogThreadName(const std::string& name);
VTKM_CONT_EXPORT
VTKM_CONT
std::string GetLogThreadName();
// Per-thread error context, not currently used, undocumented....
VTKM_CONT_EXPORT
VTKM_CONT
std::string GetLogErrorContext();
 
VTKM_CONT_EXPORT
VTKM_CONT
std::string GetStackTrace(vtkm::Int32 skip = 0);
 
VTKM_CONT_EXPORT
VTKM_CONT
std::string GetHumanReadableSize(vtkm::UInt64 bytes, int prec = 2);
 
template <typename T>
VTKM_CONT inline std::string GetHumanReadableSize(T&& bytes, int prec = 2)
{
  return GetHumanReadableSize(static_cast<vtkm::UInt64>(std::forward<T>(bytes)), prec);
}
 
VTKM_CONT_EXPORT
VTKM_CONT
std::string GetSizeString(vtkm::UInt64 bytes, int prec = 2);
 
template <typename T>
VTKM_CONT inline std::string GetSizeString(T&& bytes, int prec = 2)
{
  return GetSizeString(static_cast<vtkm::UInt64>(std::forward<T>(bytes)), prec);
}
 
VTKM_CONT_EXPORT VTKM_CONT std::string TypeToString(const std::type_info& t);
VTKM_CONT_EXPORT VTKM_CONT std::string TypeToString(const std::type_index& t);
template <typename T>
inline VTKM_CONT std::string TypeToString()
{
  return TypeToString(typeid(T));
}
template <typename T>
inline VTKM_CONT std::string TypeToString(const T&)
{
  return TypeToString(typeid(T));
}
#ifdef VTKM_ENABLE_LOGGING
 
VTKM_CONT_EXPORT
VTKM_CONT
void LogCond(LogLevel level, bool cond, const char* file, unsigned line, const char* format...);
 
namespace detail
{
 
class VTKM_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.
   */
  VTKM_CONT
  LogScope(LogLevel level, const char* file, unsigned line, const char* format...);
 
  VTKM_CONT ~LogScope();
};
 
 
} // namespace detail
 
struct VTKM_CONT_EXPORT LogCondStream
{
  VTKM_CONT
  LogCondStream(LogLevel level, bool cond, const char* file, int line)
    : Level(level)
    , Condition(cond)
    , File(file)
    , Line(line)
  {
  }
 
  VTKM_CONT
  ~LogCondStream() noexcept(false);
 
  template <typename T>
  VTKM_CONT LogCondStream& operator<<(const T& in)
  {
    SStream << in;
    return *this;
  }
 
  VTKM_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 // VTKM_ENABLE_LOGGING
 
}
} // end namespace vtkm::cont
 
#endif // vtk_m_cont_Logging_h