[Comgr] Create a Global Logger Class for Comgr

amd/comgr/CMakeLists.txt

@@ -113,6 +113,7 @@ set(SOURCES
   src/comgr-hotswap-patch-wmma-scale16.cpp
   src/comgr-hotswap-patch-wmma-split.cpp
   src/comgr-libcxx-headers.cpp
+  src/comgr-logger.cpp
   src/comgr-metadata.cpp
   src/comgr-signal.cpp
   src/comgr-spirv-command.cpp

amd/comgr/README.md

@@ -212,12 +212,28 @@ include:
 * `AMD_COMGR_SAVE_LLVM_TEMPS`: If this is set, Comgr forwards `--save-temps=obj`
   to Clang Driver invocations.
 * `AMD_COMGR_REDIRECT_LOGS`: If this is not set, or is set to "0", logs are
-  returned to the caller as normal. If this is set to "stdout"/"-" or "stderr",
-  logs are instead redirected to the standard output or error stream,
-  respectively. If this is set to any other value, it is interpreted as a
-  filename which logs should be appended to.
+  only returned to the caller (via `AMD_COMGR_DATA_KIND_LOG`) as normal. If this
+  is set to "stdout"/"-" or "stderr", logs are additionally copied to the
+  standard output or error stream, respectively. If this is set to any other
+  value, it is interpreted as a filename which logs are additionally appended
+  to. In all cases the logs are still returned to the caller as well; setting
+  this variable copies them to the extra destination, it does not move them.
+  When a filename is used, it is opened once and kept open for the lifetime of
+  the process, so the destination should not be rotated or removed while Comgr
+  is in use.
 * `AMD_COMGR_EMIT_VERBOSE_LOGS`: If this is set, and is not "0", logs will
-  include additional Comgr-specific informational messages.
+  include additional Comgr-specific informational messages. Equivalent to
+  setting `AMD_COMGR_LOG_LEVEL=debug`, but only when `AMD_COMGR_LOG_LEVEL` is
+  not set itself: an explicit `AMD_COMGR_LOG_LEVEL` always takes precedence (so
+  `AMD_COMGR_LOG_LEVEL=none` suppresses logs even if this is enabled).
+* `AMD_COMGR_LOG_LEVEL`: Controls the severity threshold of the global Comgr
+  logger. Valid values, from least to most verbose, are "none", "error",
+  "warning", "info", and "debug" (case-insensitive). The chosen level enables
+  that severity and every less-verbose (more severe) one; for example,
+  "warning" emits error and warning messages but suppresses info and debug.
+  "none" suppresses all messages. When set, this takes precedence over
+  `AMD_COMGR_EMIT_VERBOSE_LOGS`. If unset, the level defaults to "debug" when
+  `AMD_COMGR_EMIT_VERBOSE_LOGS` is enabled, and to "error" otherwise.
 * `AMD_COMGR_TIME_STATISTICS`: If this is set, and is not "0", logs will
   include additional Comgr-specific timing information for compilation actions.
 * `AMD_COMGR_TIME_STATISTICS_GRANULARITY`: If this is set to "us" or "ns",

amd/comgr/include/amd_comgr.h.in

@@ -142,12 +142,21 @@ extern "C" {
  *   forwards "--save-temps=obj" to Clang Driver invocations
  * - @p AMD_COMGR_REDIRECT_LOGS: If this is not set, or is set to "0", logs are
  *   returned to the caller as normal. If this is set to "stdout"/"-" or
- *   "stderr", logs are instead redirected to the standard output or error
+ *   "stderr", logs are additionally copied to the standard output or error
  *   stream, respectively. If this is set to any other value, it is interpreted
- *   as a filename which logs should be appended to. Logs may be redirected
- *   irrespective of whether logging is enabled.
+ *   as a filename which logs are appended to. In all cases logs are still
+ *   returned to the caller; this variable copies them, it does not move them.
+ *   Logs may be redirected irrespective of whether logging is enabled.
  * - @p AMD_COMGR_EMIT_VERBOSE_LOGS: If this is set, and is not "0", logs will
- *   include additional Comgr-specific informational messages.
+ *   include additional Comgr-specific informational messages. Equivalent to
+ *   AMD_COMGR_LOG_LEVEL=debug, unless AMD_COMGR_LOG_LEVEL is set, which takes
+ *   precedence.
+ * - @p AMD_COMGR_LOG_LEVEL: Sets the severity threshold of the Comgr logger.
+ *   Values from least to most verbose: "none", "error", "warning", "info",
+ *   "debug" (case-insensitive). A level enables that severity and all more
+ *   severe ones. Takes precedence over AMD_COMGR_EMIT_VERBOSE_LOGS; if unset,
+ *   defaults to "debug" when AMD_COMGR_EMIT_VERBOSE_LOGS is enabled, else
+ *   "error".
  */
 
 /** \defgroup symbol_versions_group Symbol Versions

amd/comgr/src/comgr-env.cpp

@@ -84,6 +84,11 @@ bool shouldEmitVerboseLogs() {
   return VerboseLogs && StringRef(VerboseLogs) != "0";
 }
 
+StringRef getLogLevel() {
+  static const char *LogLevel = getenv("AMD_COMGR_LOG_LEVEL");
+  return LogLevel ? StringRef(LogLevel) : StringRef();
+}
+
 llvm::StringRef getLLVMPath() {
   static const char *EnvLLVMPath = std::getenv("LLVM_PATH");
   return EnvLLVMPath;

amd/comgr/src/comgr-env.h

@@ -26,6 +26,11 @@ std::optional<llvm::StringRef> getRedirectLogs();
 /// Return whether the environment requests verbose logging.
 bool shouldEmitVerboseLogs();
 
+/// Return the raw value of AMD_COMGR_LOG_LEVEL (e.g. "none", "error",
+/// "warning", "info", "debug"), or an empty string if unset. The Logger parses
+/// this into a COMGR::LogLevel.
+llvm::StringRef getLogLevel();
+
 /// Return whether the environment requests time statistics collection.
 bool needTimeStatistics();
 

amd/comgr/src/comgr-logger.cpp

@@ -0,0 +1,156 @@
+//===- comgr-logger.cpp - Global Comgr logging facility -------------------===//
+//
+// Part of Comgr, under the Apache License v2.0 with LLVM Exceptions. See
+// amd/comgr/LICENSE.TXT in this repository for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file implements COMGR::Logger. See comgr-logger.h for the design.
+///
+//===----------------------------------------------------------------------===//
+
+#include "comgr-logger.h"
+#include "comgr-env.h"
+
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/FileSystem.h"
+
+using namespace llvm;
+
+namespace COMGR {
+
+namespace {
+
+// The capture stream is per-thread so that a captured Action on one thread does
+// not collect log output emitted by an unrelated API on another thread.
+thread_local raw_ostream *ThreadCaptureStream = nullptr;
+
+// Resolve the configured level from the environment. Delegates the mapping to
+// the testable parseLogLevel(); kept separate so the Logger constructor reads
+// the (cached) environment exactly once.
+LogLevel resolveLevel() {
+  return parseLogLevel(env::getLogLevel(), env::shouldEmitVerboseLogs());
+}
+
+StringRef severityPrefix(LogLevel Severity) {
+  switch (Severity) {
+  case LogLevel::Error:
+    return "comgr: error: ";
+  case LogLevel::Warning:
+    return "comgr: warning: ";
+  case LogLevel::Info:
+    return "comgr: info: ";
+  case LogLevel::Debug:
+    return "comgr: debug: ";
+  }
+  return "comgr: ";
+}
+
+} // namespace
+
+LogLevel parseLogLevel(StringRef Requested, bool VerboseFallback) {
+  // When the variable is unset or unrecognized, default to Debug if verbose
+  // logs are requested for back-compat with AMD_COMGR_EMIT_VERBOSE_LOGS,
+  // otherwise to Error. An explicit, recognized value always wins (including
+  // "none", which silences logging even when verbose logs are requested).
+  LogLevel Fallback = VerboseFallback ? LogLevel::Debug : LogLevel::Error;
+  if (Requested.empty())
+    return Fallback;
+
+  if (Requested.equals_insensitive("none"))
+    return LogLevel::None;
+  if (Requested.equals_insensitive("error"))
+    return LogLevel::Error;
+  if (Requested.equals_insensitive("warning"))
+    return LogLevel::Warning;
+  if (Requested.equals_insensitive("info"))
+    return LogLevel::Info;
+  if (Requested.equals_insensitive("debug"))
+    return LogLevel::Debug;
+
+  return Fallback;
+}
+
+Logger::Logger() : Level(resolveLevel()), Sink(nullptr) {
+  std::optional<StringRef> RedirectLogs = env::getRedirectLogs();
+  if (!RedirectLogs)
+    return;
+
+  StringRef RedirectLog = *RedirectLogs;
+  if (RedirectLog == "stdout" || RedirectLog == "-") {
+    Sink = &outs();
+  } else if (RedirectLog == "stderr") {
+    Sink = &errs();
+  } else {
+    std::error_code EC;
+    SinkFile = std::make_unique<raw_fd_ostream>(
+        RedirectLog, EC, sys::fs::OF_Text | sys::fs::OF_Append);
+    if (EC) {
+      SinkFile.reset();
+      // Record the failure rather than writing it to stderr here. The Logger is
+      // constructed before any action's log buffer exists; the action layer
+      // surfaces this message into the returned comgr.log via getSinkError(),
+      // restoring the pre-Logger behavior of reporting it to the caller.
+      SinkError = (Twine("unable to redirect log to file '") + RedirectLog +
+                   "': " + EC.message())
+                      .str();
+    } else {
+      Sink = SinkFile.get();
+    }
+  }
+}
+
+Logger::Logger(LogLevel Level, raw_ostream *Sink) : Level(Level), Sink(Sink) {}
+
+void Logger::writeToSink(StringRef Data) {
+  if (!Sink)
+    return;
+
+  // Share the same mutex as emit() so teed output and Logger messages never
+  // interleave mid-write on the shared sink. The sink is intentionally left
+  // unflushed here; the caller flushes once when the action completes.
+  std::scoped_lock<std::mutex> Lock(Mutex);
+  *Sink << Data;
+}
+
+void Logger::emit(LogLevel Severity, const Twine &Message) {
+  if (!isEnabled(Severity))
+    return;
+
+  SmallString<256> Buffer;
+  StringRef Text = Message.toStringRef(Buffer);
+  StringRef Prefix = severityPrefix(Severity);
+
+  std::scoped_lock<std::mutex> Lock(Mutex);
+
+  raw_ostream *Capture = ThreadCaptureStream;
+  if (Sink) {
+    *Sink << Prefix << Text << '\n';
+    Sink->flush();
+  }
+  // Guard against double-emission if a capture stream happens to alias the
+  // sink.
+  if (Capture && Capture != Sink) {
+    *Capture << Prefix << Text << '\n';
+    Capture->flush();
+  }
+}
+
+Logger &getLogger() {
+  static Logger TheLogger;
+  return TheLogger;
+}
+
+raw_ostream *getThreadCaptureStream() { return ThreadCaptureStream; }
+
+LogCaptureScope::LogCaptureScope(raw_ostream &OS)
+    : Previous(ThreadCaptureStream) {
+  ThreadCaptureStream = &OS;
+}
+
+LogCaptureScope::~LogCaptureScope() { ThreadCaptureStream = Previous; }
+
+} // namespace COMGR