1//===- Remarks.cpp - C Interface for the MLIR Remark Engine ---------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "mlir-c/Remarks.h"
10#include "mlir/CAPI/IR.h"
11#include "mlir/CAPI/Remarks.h"
12#include "mlir/CAPI/Support.h"
13#include "mlir/CAPI/Utils.h"
14#include "mlir/IR/MLIRContext.h"
15#include "mlir/IR/Remarks.h"
16#include "mlir/Remark/RemarkStreamer.h"
17#include "llvm/Remarks/RemarkFormat.h"
18#include "llvm/Support/ErrorHandling.h"
19
20#include <cassert>
21#include <memory>
22
23using namespace mlir;
24using mlir::remark::detail::Remark;
25
26//===----------------------------------------------------------------------===//
27// Helpers
28//===----------------------------------------------------------------------===//
29
30namespace {
31/// A streamer forwarding every reported remark to a C callback.
32class CallbackRemarkStreamer : public remark::detail::MLIRRemarkStreamerBase {
33public:
34 CallbackRemarkStreamer(MlirRemarkCallback callback, void *userData,
35 void (*deleteUserData)(void *))
36 : callback(callback), userData(userData), deleteUserData(deleteUserData) {
37 }
38
39 ~CallbackRemarkStreamer() override {
40 if (deleteUserData)
41 deleteUserData(userData);
42 }
43
44 void streamOptimizationRemark(const Remark &remark) override {
45 callback(wrap(cpp: &remark), userData);
46 }
47
48private:
49 MlirRemarkCallback callback;
50 void *userData;
51 void (*deleteUserData)(void *);
52};
53} // namespace
54
55/// Every filter reaches the engine as a (possibly empty) string, as with
56/// mlir-opt's options: a kind is reported when its own filter or `all` matches.
57static remark::RemarkCategories unwrap(MlirRemarkCategories categories) {
58 return remark::RemarkCategories{
59 .all: unwrap(ref: categories.all).str(), .passed: unwrap(ref: categories.passed).str(),
60 .missed: unwrap(ref: categories.missed).str(), .analysis: unwrap(ref: categories.analysis).str(),
61 .failed: unwrap(ref: categories.failed).str()};
62}
63
64static std::unique_ptr<remark::detail::RemarkEmittingPolicyBase>
65createPolicy(MlirRemarkPolicy policy) {
66 switch (policy) {
67 case MlirRemarkPolicyAll:
68 return std::make_unique<remark::RemarkEmittingPolicyAll>();
69 case MlirRemarkPolicyFinal:
70 return std::make_unique<remark::RemarkEmittingPolicyFinal>();
71 }
72 llvm_unreachable("unknown remark policy");
73}
74
75static llvm::remarks::Format unwrap(MlirRemarkFileFormat format) {
76 switch (format) {
77 case MlirRemarkFileFormatYAML:
78 return llvm::remarks::Format::YAML;
79 case MlirRemarkFileFormatBitstream:
80 return llvm::remarks::Format::Bitstream;
81 }
82 llvm_unreachable("unknown remark file format");
83}
84
85static MlirRemarkKind wrap(remark::RemarkKind kind) {
86 switch (kind) {
87 case remark::RemarkKind::RemarkUnknown:
88 return MlirRemarkKindUnknown;
89 case remark::RemarkKind::RemarkPassed:
90 return MlirRemarkKindPassed;
91 case remark::RemarkKind::RemarkMissed:
92 return MlirRemarkKindMissed;
93 case remark::RemarkKind::RemarkFailure:
94 return MlirRemarkKindFailure;
95 case remark::RemarkKind::RemarkAnalysis:
96 return MlirRemarkKindAnalysis;
97 }
98 llvm_unreachable("unknown remark kind");
99}
100
101//===----------------------------------------------------------------------===//
102// Enabling and finalizing
103//===----------------------------------------------------------------------===//
104
105MlirLogicalResult mlirContextEnableOptimizationRemarks(
106 MlirContext context, MlirRemarkCategories categories,
107 MlirRemarkPolicy policy, bool printAsEmitRemarks) {
108 MLIRContext *ctx = unwrap(c: context);
109 if (ctx->getRemarkEngine())
110 return mlirLogicalResultFailure();
111 return wrap(res: remark::enableOptimizationRemarks(
112 ctx&: *ctx, /*streamer=*/nullptr, remarkEmittingPolicy: createPolicy(policy), cats: unwrap(categories),
113 printAsEmitRemarks));
114}
115
116MlirLogicalResult mlirContextEnableOptimizationRemarksToFile(
117 MlirContext context, MlirRemarkCategories categories,
118 MlirRemarkPolicy policy, MlirRemarkFileFormat format, MlirStringRef path,
119 bool printAsEmitRemarks) {
120 MLIRContext *ctx = unwrap(c: context);
121 if (ctx->getRemarkEngine())
122 return mlirLogicalResultFailure();
123 return wrap(res: remark::enableOptimizationRemarksWithLLVMStreamer(
124 ctx&: *ctx, filePath: unwrap(ref: path), fmt: unwrap(format), remarkEmittingPolicy: createPolicy(policy),
125 cat: unwrap(categories), printAsEmitRemarks));
126}
127
128MlirLogicalResult mlirContextEnableOptimizationRemarksWithCallback(
129 MlirContext context, MlirRemarkCategories categories,
130 MlirRemarkPolicy policy, MlirRemarkCallback callback, void *userData,
131 void (*deleteUserData)(void *), bool printAsEmitRemarks) {
132 assert(callback && "unexpected null remark callback");
133 MLIRContext *ctx = unwrap(c: context);
134 if (ctx->getRemarkEngine()) {
135 // The caller handed over `userData`; release it as on success.
136 if (deleteUserData)
137 deleteUserData(userData);
138 return mlirLogicalResultFailure();
139 }
140 return wrap(res: remark::enableOptimizationRemarks(
141 ctx&: *ctx,
142 streamer: std::make_unique<CallbackRemarkStreamer>(args&: callback, args&: userData,
143 args&: deleteUserData),
144 remarkEmittingPolicy: createPolicy(policy), cats: unwrap(categories), printAsEmitRemarks));
145}
146
147void mlirContextFinalizeOptimizationRemarks(MlirContext context) {
148 // The engine destructor reports the postponed remarks, then destroys the
149 // streamer.
150 unwrap(c: context)->setRemarkEngine(nullptr);
151}
152
153bool mlirContextHasRemarkEngine(MlirContext context) {
154 return unwrap(c: context)->getRemarkEngine() != nullptr;
155}
156
157//===----------------------------------------------------------------------===//
158// Remark accessors
159//===----------------------------------------------------------------------===//
160
161MlirRemarkKind mlirRemarkGetKind(MlirRemark remark) {
162 return wrap(kind: unwrap(c: remark)->getRemarkKind());
163}
164
165MlirStringRef mlirRemarkGetRemarkName(MlirRemark remark) {
166 return wrap(ref: unwrap(c: remark)->getRemarkName());
167}
168
169MlirStringRef mlirRemarkGetCategoryName(MlirRemark remark) {
170 return wrap(ref: unwrap(c: remark)->getCategoryName());
171}
172
173MlirStringRef mlirRemarkGetFullCategoryName(MlirRemark remark) {
174 return wrap(ref: unwrap(c: remark)->getCombinedCategoryName());
175}
176
177MlirStringRef mlirRemarkGetFunctionName(MlirRemark remark) {
178 return wrap(ref: unwrap(c: remark)->getFunction());
179}
180
181MlirLocation mlirRemarkGetLocation(MlirRemark remark) {
182 return wrap(cpp: unwrap(c: remark)->getLocation());
183}
184
185uint64_t mlirRemarkGetId(MlirRemark remark) {
186 return unwrap(c: remark)->getId().getValue();
187}
188
189intptr_t mlirRemarkGetNumRelatedRemarks(MlirRemark remark) {
190 return static_cast<intptr_t>(unwrap(c: remark)->getRelatedRemarkIds().size());
191}
192
193uint64_t mlirRemarkGetRelatedRemarkId(MlirRemark remark, intptr_t pos) {
194 ArrayRef<remark::RemarkId> ids = unwrap(c: remark)->getRelatedRemarkIds();
195 assert(pos >= 0 && static_cast<size_t>(pos) < ids.size() &&
196 "related remark index out of range");
197 return ids[pos].getValue();
198}
199
200intptr_t mlirRemarkGetNumArgs(MlirRemark remark) {
201 return static_cast<intptr_t>(unwrap(c: remark)->getArgs().size());
202}
203
204MlirStringRef mlirRemarkGetArgKey(MlirRemark remark, intptr_t pos) {
205 ArrayRef<Remark::Arg> args = unwrap(c: remark)->getArgs();
206 assert(pos >= 0 && static_cast<size_t>(pos) < args.size() &&
207 "remark argument index out of range");
208 return wrap(ref: llvm::StringRef(args[pos].key));
209}
210
211MlirStringRef mlirRemarkGetArgValue(MlirRemark remark, intptr_t pos) {
212 ArrayRef<Remark::Arg> args = unwrap(c: remark)->getArgs();
213 assert(pos >= 0 && static_cast<size_t>(pos) < args.size() &&
214 "remark argument index out of range");
215 return wrap(ref: llvm::StringRef(args[pos].val));
216}
217
218void mlirRemarkPrint(MlirRemark remark, MlirStringCallback callback,
219 void *userData) {
220 detail::CallbackOstream stream(callback, userData);
221 unwrap(c: remark)->print(os&: stream);
222}
223
224//===----------------------------------------------------------------------===//
225// Emission
226//===----------------------------------------------------------------------===//
227
228bool mlirEmitOptimizationRemark(
229 MlirLocation location, MlirRemarkKind kind, MlirStringRef remarkName,
230 MlirStringRef categoryName, MlirStringRef subCategoryName,
231 MlirStringRef functionName, MlirStringRef message, intptr_t numArgs,
232 const MlirStringRef *argKeys, const MlirStringRef *argValues) {
233 assert((numArgs == 0 || (argKeys && argValues)) &&
234 "remark arguments require both keys and values");
235 Location loc = unwrap(c: location);
236 remark::RemarkOpts opts = remark::RemarkOpts::name(n: unwrap(ref: remarkName))
237 .category(v: unwrap(ref: categoryName))
238 .subCategory(v: unwrap(ref: subCategoryName))
239 .function(v: unwrap(ref: functionName));
240 remark::detail::InFlightRemark inFlight;
241 switch (kind) {
242 case MlirRemarkKindUnknown:
243 return false;
244 case MlirRemarkKindPassed:
245 inFlight = remark::passed(loc, opts);
246 break;
247 case MlirRemarkKindMissed:
248 inFlight = remark::missed(loc, opts);
249 break;
250 case MlirRemarkKindFailure:
251 inFlight = remark::failed(loc, opts);
252 break;
253 case MlirRemarkKindAnalysis:
254 inFlight = remark::analysis(loc, opts);
255 break;
256 }
257 if (!inFlight)
258 return false;
259 if (message.length != 0)
260 inFlight << unwrap(ref: message);
261 for (intptr_t i = 0; i < numArgs; ++i)
262 inFlight << Remark::Arg(unwrap(ref: argKeys[i]), unwrap(ref: argValues[i]));
263 // The remark is reported when `inFlight` goes out of scope.
264 return true;
265}
266