[Mlir-commits] [mlir] [MLIR] Integrate LLVM Optimization Remarks Infrastructure (PR #152474)

[Mehdi Amini]

================
@@ -0,0 +1,453 @@
+//===- Remarks.h - MLIR Optimization Remark ----------------------*- C++-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines utilities for emitting optimization remarks.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_IR_REMARKS_H
+#define MLIR_IR_REMARKS_H
+
+#include "llvm/IR/DiagnosticInfo.h"
+#include "llvm/IR/DiagnosticPrinter.h"
+#include "llvm/Remarks/Remark.h"
+#include "llvm/Remarks/RemarkStreamer.h"
+#include "llvm/Support/ToolOutputFile.h"
+
+#include "mlir/IR/Diagnostics.h"
+#include "mlir/IR/MLIRContext.h"
+
+namespace mlir {
+
+/// Defines different remark kinds that can be used to categorize remarks.
+enum class RemarkKind {
+  OptimizationRemarkUnknown = 0,
+  OptimizationRemarkPass,
+  OptimizationRemarkMissed,
+  OptimizationRemarkFailure,
+  OptimizationRemarkAnalysis,
+};
+
+//===----------------------------------------------------------------------===//
+// Remark Base Class
+//===----------------------------------------------------------------------===//
+class RemarkBase : public llvm::DiagnosticInfo {
+
+public:
+  RemarkBase(RemarkKind remarkKind, DiagnosticSeverity severity,
+             const char *passName, StringRef remarkName, Location loc,
+             std::optional<StringRef> functionName = std::nullopt)
+      : llvm::DiagnosticInfo(makeLLVMKind(remarkKind),
+                             makeLLVMSeverity(severity)),
+        remarkKind(remarkKind), functionName(functionName), loc(loc),
+        passName(passName), remarkName(remarkName) {}
+
+  struct SetIsVerbose {};
+
+  struct SetExtraArgs {};
+
+  struct RemarkKeyValue {
+    std::string key;
+    std::string val;
+
+    explicit RemarkKeyValue(StringRef str = "") : key("String"), val(str) {}
+    RemarkKeyValue(StringRef key, Value value);
+    RemarkKeyValue(StringRef key, Type type);
+    RemarkKeyValue(StringRef key, StringRef s);
+    RemarkKeyValue(StringRef key, const char *s)
+        : RemarkKeyValue(key, StringRef(s)) {};
+    RemarkKeyValue(StringRef key, int n);
+    RemarkKeyValue(StringRef key, float n);
+    RemarkKeyValue(StringRef key, long n);
+    RemarkKeyValue(StringRef key, long long n);
+    RemarkKeyValue(StringRef key, unsigned n);
+    RemarkKeyValue(StringRef key, unsigned long n);
+    RemarkKeyValue(StringRef key, unsigned long long n);
+    RemarkKeyValue(StringRef key, bool b)
+        : key(key), val(b ? "true" : "false") {}
+  };
+
+  void insert(StringRef s);
+  void insert(RemarkKeyValue a);
+  void insert(SetIsVerbose v);
+  void insert(SetExtraArgs ea);
+
+  void print(llvm::DiagnosticPrinter &dp) const override;
+  void print() const;
+
+  virtual bool isEnabled() const = 0;
+  Location getLocation() const { return loc; }
+  /// Diagnostic -> Remark
+  llvm::remarks::Remark generateRemark() const;
+
+  StringRef getFunction() const {
+    if (functionName)
+      return *functionName;
+    return "<unknown function>";
+  }
+  StringRef getPassName() const { return passName; }
+  StringRef getRemarkName() const { return remarkName; }
+  std::string getMsg() const;
+
+  bool isVerbose() const { return isVerboseRemark; }
+
+  ArrayRef<RemarkKeyValue> getArgs() const { return args; }
+
+  llvm::remarks::Type getRemarkType() const;
+
+protected:
+  /// Keeps the MLIR diagnostic kind, which is used to determine the
+  /// diagnostic kind in the LLVM remark streamer.
+  RemarkKind remarkKind;
+  /// Name of the convering function like interface
+  std::optional<std::string> functionName;
+
+  Location loc;
+  /// Name of the pass that triggers this report.
+  const char *passName;
+
+  /// Textual identifier for the remark (single-word, CamelCase). Can be used
+  /// by external tools reading the output file for optimization remarks to
+  /// identify the remark.
+  StringRef remarkName;
+
+  /// RemarkKeyValues collected via the streaming interface.
+  SmallVector<RemarkKeyValue, 4> args;
+
+  /// The remark is expected to be noisy.
+  bool isVerboseRemark = false;
+
+private:
+  /// Convert the MLIR diagnostic severity to LLVM diagnostic severity.
+  static llvm::DiagnosticSeverity
+  makeLLVMSeverity(DiagnosticSeverity severity) {
+    switch (severity) {
+    case DiagnosticSeverity::Note:
+      return llvm::DiagnosticSeverity::DS_Note;
+    case DiagnosticSeverity::Warning:
+      return llvm::DiagnosticSeverity::DS_Warning;
+    case DiagnosticSeverity::Error:
+      return llvm::DiagnosticSeverity::DS_Error;
+    case DiagnosticSeverity::Remark:
+      return llvm::DiagnosticSeverity::DS_Remark;
+    }
+    llvm_unreachable("Unknown diagnostic severity");
+  }
+  /// Convert the MLIR remark kind to LLVM diagnostic kind.
+  static llvm::DiagnosticKind makeLLVMKind(RemarkKind remarkKind) {
+    switch (remarkKind) {
+    case RemarkKind::OptimizationRemarkUnknown:
+      return llvm::DiagnosticKind::DK_Generic;
+    case RemarkKind::OptimizationRemarkPass:
+      return llvm::DiagnosticKind::DK_OptimizationRemark;
+    case RemarkKind::OptimizationRemarkMissed:
+      return llvm::DiagnosticKind::DK_OptimizationRemarkMissed;
+    case RemarkKind::OptimizationRemarkFailure:
+      return llvm::DiagnosticKind::DK_OptimizationFailure;
+    case RemarkKind::OptimizationRemarkAnalysis:
+      return llvm::DiagnosticKind::DK_OptimizationRemarkAnalysis;
+    }
+    llvm_unreachable("Unknown diagnostic kind");
+  }
+};
+
+// clang-format off
+template <class RemarkT>
+decltype(auto) operator<<(
+    RemarkT &&r,
+    std::enable_if_t<std::is_base_of_v<RemarkBase,
+                                       std::remove_reference_t<RemarkT>>,
+                     StringRef>
+        s) {
+  r.insert(s);
+  return std::forward<RemarkT>(r);
+}
+
+template <class RemarkT>
+decltype(auto) operator<<(
+    RemarkT &&r,
+    std::enable_if_t<std::is_base_of_v<RemarkBase,
+                                       std::remove_reference_t<RemarkT>>,
+                     RemarkBase::RemarkKeyValue>
+        a) {
+  r.insert(std::move(a));
+  return std::forward<RemarkT>(r);
+}
+
+template <class RemarkT>
+decltype(auto) operator<<(
+    RemarkT &&r,
+    std::enable_if_t<std::is_base_of_v<RemarkBase,
+                                       std::remove_reference_t<RemarkT>>,
+                     RemarkBase::SetIsVerbose>
+        v) {
+  r.insert(v);
+  return std::forward<RemarkT>(r);
+}
+
+template <class RemarkT>
+decltype(auto) operator<<(
+    RemarkT &&r,
+    std::enable_if_t<std::is_base_of_v<RemarkBase,
+                                       std::remove_reference_t<RemarkT>>,
+                     RemarkBase::SetExtraArgs>
+        ea) {
+  r.insert(ea);
+  return std::forward<RemarkT>(r);
+}
+// clang-format on
+
+//===----------------------------------------------------------------------===//
+// Shorthand aliases for different kinds of remarks.
+//===----------------------------------------------------------------------===//
+
+template <RemarkKind K, DiagnosticSeverity S>
+class OptRemarkBase final : public RemarkBase {
+public:
+  explicit OptRemarkBase(Location loc, StringRef passName, StringRef remarkName)
+      : RemarkBase(K, S, passName.data(), remarkName, loc) {}
+
+  bool isEnabled() const override { return true; }
+};
+
+using OptRemarkAnalysis = OptRemarkBase<RemarkKind::OptimizationRemarkAnalysis,
+                                        DiagnosticSeverity::Remark>;
+
+using OptRemarkPass = OptRemarkBase<RemarkKind::OptimizationRemarkPass,
+                                    DiagnosticSeverity::Remark>;
+
+using OptRemarkMissed = OptRemarkBase<RemarkKind::OptimizationRemarkMissed,
+                                      DiagnosticSeverity::Remark>;
+
+using OptRemarkFailure = OptRemarkBase<RemarkKind::OptimizationRemarkFailure,
+                                       DiagnosticSeverity::Remark>;
+
+class RemarkEngine;
+
+//===----------------------------------------------------------------------===//
+// InFlightRemark
+//===----------------------------------------------------------------------===//
+
+/// InFlightRemark is a RAII class that holds a reference to a RemarkBase
+/// instance and allows to build the remark using the << operator. The remark
+/// is emitted when the InFlightRemark instance is destroyed, which happens
+/// when the scope ends or when the InFlightRemark instance is moved.
+/// Similar to InFlightDiagnostic, but for remarks.
+class InFlightRemark {
+public:
+  explicit InFlightRemark(RemarkBase *diag) : remark(diag) {}
+  InFlightRemark(RemarkEngine &eng, RemarkBase *diag)
+      : owner(&eng), remark(diag) {}
+
+  InFlightRemark() = default; // empty ctor
+
+  template <typename T>
+  InFlightRemark &operator<<(T &&arg) {
+    if (remark)
+      *remark << std::forward<T>(arg);
+    return *this;
+  }
+
+  explicit operator bool() const { return remark != nullptr; }
+
+  ~InFlightRemark();
+
+  InFlightRemark(const InFlightRemark &) = delete;
+  InFlightRemark &operator=(const InFlightRemark &) = delete;
+  InFlightRemark(InFlightRemark &&) = default;
+  InFlightRemark &operator=(InFlightRemark &&) = default;
+
+private:
+  RemarkEngine *owner{nullptr};
+  std::unique_ptr<RemarkBase> remark;
+};
+
+//===----------------------------------------------------------------------===//
+// MLIR Remark Streamer
+//===----------------------------------------------------------------------===//
+
+class MLIRRemarkStreamer {
+  llvm::remarks::RemarkStreamer &remarkStreamer;
+
+public:
+  explicit MLIRRemarkStreamer(llvm::remarks::RemarkStreamer &remarkStreamer)
+      : remarkStreamer(remarkStreamer) {}
+
+  void streamOptimizationRemark(const RemarkBase &remark);
+};
+
+//===----------------------------------------------------------------------===//
+// Remark Engine (MLIR Context will own this class)
+//===----------------------------------------------------------------------===//
+
+class RemarkEngine {
+private:
+  /// The category for missed optimization remarks.
----------------
joker-eph wrote:

```suggestion
  /// Regex that filters missed optimization remarks: only matching one are reporter.
```

(same below)

https://github.com/llvm/llvm-project/pull/152474