1 //===- AnalysisManagerTest.cpp - AnalysisManager unit tests ---------------===//
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/Pass/AnalysisManager.h"
10 #include "mlir/Dialect/Func/IR/FuncOps.h"
11 #include "mlir/IR/Builders.h"
12 #include "mlir/IR/BuiltinOps.h"
13 #include "mlir/Pass/Pass.h"
14 #include "mlir/Pass/PassManager.h"
15 #include "gtest/gtest.h"
16
17 using namespace mlir;
18 using namespace mlir::detail;
19
20 namespace {
21 /// Minimal class definitions for two analyses.
22 struct MyAnalysis {
23 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(MyAnalysis)
24
MyAnalysis__anon7c676c9d0111::MyAnalysis25 MyAnalysis(Operation *) {}
26 };
27 struct OtherAnalysis {
28 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OtherAnalysis)
29
OtherAnalysis__anon7c676c9d0111::OtherAnalysis30 OtherAnalysis(Operation *) {}
31 };
32 struct OpSpecificAnalysis {
33 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OpSpecificAnalysis)
34
OpSpecificAnalysis__anon7c676c9d0111::OpSpecificAnalysis35 OpSpecificAnalysis(ModuleOp) {}
36 };
37
TEST(AnalysisManagerTest,FineGrainModuleAnalysisPreservation)38 TEST(AnalysisManagerTest, FineGrainModuleAnalysisPreservation) {
39 MLIRContext context;
40
41 // Test fine grain invalidation of the module analysis manager.
42 OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
43 ModuleAnalysisManager mam(*module, /*passInstrumentor=*/nullptr);
44 AnalysisManager am = mam;
45
46 // Query two different analyses, but only preserve one before invalidating.
47 am.getAnalysis<MyAnalysis>();
48 am.getAnalysis<OtherAnalysis>();
49
50 detail::PreservedAnalyses pa;
51 pa.preserve<MyAnalysis>();
52 am.invalidate(pa);
53
54 // Check that only MyAnalysis is preserved.
55 EXPECT_TRUE(am.getCachedAnalysis<MyAnalysis>().has_value());
56 EXPECT_FALSE(am.getCachedAnalysis<OtherAnalysis>().has_value());
57 }
58
TEST(AnalysisManagerTest,FineGrainFunctionAnalysisPreservation)59 TEST(AnalysisManagerTest, FineGrainFunctionAnalysisPreservation) {
60 MLIRContext context;
61 context.loadDialect<func::FuncDialect>();
62 Builder builder(&context);
63
64 // Create a function and a module.
65 OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
66 func::FuncOp func1 =
67 func::FuncOp::create(builder.getUnknownLoc(), "foo",
68 builder.getFunctionType(std::nullopt, std::nullopt));
69 func1.setPrivate();
70 module->push_back(func1);
71
72 // Test fine grain invalidation of the function analysis manager.
73 ModuleAnalysisManager mam(*module, /*passInstrumentor=*/nullptr);
74 AnalysisManager am = mam;
75 AnalysisManager fam = am.nest(func1);
76
77 // Query two different analyses, but only preserve one before invalidating.
78 fam.getAnalysis<MyAnalysis>();
79 fam.getAnalysis<OtherAnalysis>();
80
81 detail::PreservedAnalyses pa;
82 pa.preserve<MyAnalysis>();
83 fam.invalidate(pa);
84
85 // Check that only MyAnalysis is preserved.
86 EXPECT_TRUE(fam.getCachedAnalysis<MyAnalysis>().has_value());
87 EXPECT_FALSE(fam.getCachedAnalysis<OtherAnalysis>().has_value());
88 }
89
TEST(AnalysisManagerTest,FineGrainChildFunctionAnalysisPreservation)90 TEST(AnalysisManagerTest, FineGrainChildFunctionAnalysisPreservation) {
91 MLIRContext context;
92 context.loadDialect<func::FuncDialect>();
93 Builder builder(&context);
94
95 // Create a function and a module.
96 OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
97 func::FuncOp func1 =
98 func::FuncOp::create(builder.getUnknownLoc(), "foo",
99 builder.getFunctionType(std::nullopt, std::nullopt));
100 func1.setPrivate();
101 module->push_back(func1);
102
103 // Test fine grain invalidation of a function analysis from within a module
104 // analysis manager.
105 ModuleAnalysisManager mam(*module, /*passInstrumentor=*/nullptr);
106 AnalysisManager am = mam;
107
108 // Check that the analysis cache is initially empty.
109 EXPECT_FALSE(am.getCachedChildAnalysis<MyAnalysis>(func1).has_value());
110
111 // Query two different analyses, but only preserve one before invalidating.
112 am.getChildAnalysis<MyAnalysis>(func1);
113 am.getChildAnalysis<OtherAnalysis>(func1);
114
115 detail::PreservedAnalyses pa;
116 pa.preserve<MyAnalysis>();
117 am.invalidate(pa);
118
119 // Check that only MyAnalysis is preserved.
120 EXPECT_TRUE(am.getCachedChildAnalysis<MyAnalysis>(func1).has_value());
121 EXPECT_FALSE(am.getCachedChildAnalysis<OtherAnalysis>(func1).has_value());
122 }
123
124 /// Test analyses with custom invalidation logic.
125 struct TestAnalysisSet {
126 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestAnalysisSet)
127 };
128
129 struct CustomInvalidatingAnalysis {
130 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(CustomInvalidatingAnalysis)
131
CustomInvalidatingAnalysis__anon7c676c9d0111::CustomInvalidatingAnalysis132 CustomInvalidatingAnalysis(Operation *) {}
133
isInvalidated__anon7c676c9d0111::CustomInvalidatingAnalysis134 bool isInvalidated(const AnalysisManager::PreservedAnalyses &pa) {
135 return !pa.isPreserved<TestAnalysisSet>();
136 }
137 };
138
TEST(AnalysisManagerTest,CustomInvalidation)139 TEST(AnalysisManagerTest, CustomInvalidation) {
140 MLIRContext context;
141 Builder builder(&context);
142
143 // Create a function and a module.
144 OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
145 ModuleAnalysisManager mam(*module, /*passInstrumentor=*/nullptr);
146 AnalysisManager am = mam;
147
148 detail::PreservedAnalyses pa;
149
150 // Check that the analysis is invalidated properly.
151 am.getAnalysis<CustomInvalidatingAnalysis>();
152 am.invalidate(pa);
153 EXPECT_FALSE(am.getCachedAnalysis<CustomInvalidatingAnalysis>().has_value());
154
155 // Check that the analysis is preserved properly.
156 am.getAnalysis<CustomInvalidatingAnalysis>();
157 pa.preserve<TestAnalysisSet>();
158 am.invalidate(pa);
159 EXPECT_TRUE(am.getCachedAnalysis<CustomInvalidatingAnalysis>().has_value());
160 }
161
TEST(AnalysisManagerTest,OpSpecificAnalysis)162 TEST(AnalysisManagerTest, OpSpecificAnalysis) {
163 MLIRContext context;
164
165 // Create a module.
166 OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
167 ModuleAnalysisManager mam(*module, /*passInstrumentor=*/nullptr);
168 AnalysisManager am = mam;
169
170 // Query the op specific analysis for the module and verify that its cached.
171 am.getAnalysis<OpSpecificAnalysis, ModuleOp>();
172 EXPECT_TRUE(am.getCachedAnalysis<OpSpecificAnalysis>().has_value());
173 }
174
175 struct AnalysisWithDependency {
176 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(AnalysisWithDependency)
177
AnalysisWithDependency__anon7c676c9d0111::AnalysisWithDependency178 AnalysisWithDependency(Operation *, AnalysisManager &am) {
179 am.getAnalysis<MyAnalysis>();
180 }
181
isInvalidated__anon7c676c9d0111::AnalysisWithDependency182 bool isInvalidated(const AnalysisManager::PreservedAnalyses &pa) {
183 return !pa.isPreserved<AnalysisWithDependency>() ||
184 !pa.isPreserved<MyAnalysis>();
185 }
186 };
187
TEST(AnalysisManagerTest,DependentAnalysis)188 TEST(AnalysisManagerTest, DependentAnalysis) {
189 MLIRContext context;
190
191 // Create a module.
192 OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
193 ModuleAnalysisManager mam(*module, /*passInstrumentor=*/nullptr);
194 AnalysisManager am = mam;
195
196 am.getAnalysis<AnalysisWithDependency>();
197 EXPECT_TRUE(am.getCachedAnalysis<AnalysisWithDependency>().has_value());
198 EXPECT_TRUE(am.getCachedAnalysis<MyAnalysis>().has_value());
199
200 detail::PreservedAnalyses pa;
201 pa.preserve<AnalysisWithDependency>();
202 am.invalidate(pa);
203
204 EXPECT_FALSE(am.getCachedAnalysis<AnalysisWithDependency>().has_value());
205 EXPECT_FALSE(am.getCachedAnalysis<MyAnalysis>().has_value());
206 }
207
208 struct AnalysisWithNestedDependency {
209 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(AnalysisWithNestedDependency)
210
AnalysisWithNestedDependency__anon7c676c9d0111::AnalysisWithNestedDependency211 AnalysisWithNestedDependency(Operation *, AnalysisManager &am) {
212 am.getAnalysis<AnalysisWithDependency>();
213 }
214
isInvalidated__anon7c676c9d0111::AnalysisWithNestedDependency215 bool isInvalidated(const AnalysisManager::PreservedAnalyses &pa) {
216 return !pa.isPreserved<AnalysisWithNestedDependency>() ||
217 !pa.isPreserved<AnalysisWithDependency>();
218 }
219 };
220
TEST(AnalysisManagerTest,NestedDependentAnalysis)221 TEST(AnalysisManagerTest, NestedDependentAnalysis) {
222 MLIRContext context;
223
224 // Create a module.
225 OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
226 ModuleAnalysisManager mam(*module, /*passInstrumentor=*/nullptr);
227 AnalysisManager am = mam;
228
229 am.getAnalysis<AnalysisWithNestedDependency>();
230 EXPECT_TRUE(am.getCachedAnalysis<AnalysisWithNestedDependency>().has_value());
231 EXPECT_TRUE(am.getCachedAnalysis<AnalysisWithDependency>().has_value());
232 EXPECT_TRUE(am.getCachedAnalysis<MyAnalysis>().has_value());
233
234 detail::PreservedAnalyses pa;
235 pa.preserve<AnalysisWithDependency>();
236 pa.preserve<AnalysisWithNestedDependency>();
237 am.invalidate(pa);
238
239 EXPECT_FALSE(
240 am.getCachedAnalysis<AnalysisWithNestedDependency>().has_value());
241 EXPECT_FALSE(am.getCachedAnalysis<AnalysisWithDependency>().has_value());
242 EXPECT_FALSE(am.getCachedAnalysis<MyAnalysis>().has_value());
243 }
244
245 struct AnalysisWith2Ctors {
246 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(AnalysisWith2Ctors)
247
AnalysisWith2Ctors__anon7c676c9d0111::AnalysisWith2Ctors248 AnalysisWith2Ctors(Operation *) { ctor1called = true; }
249
AnalysisWith2Ctors__anon7c676c9d0111::AnalysisWith2Ctors250 AnalysisWith2Ctors(Operation *, AnalysisManager &) { ctor2called = true; }
251
252 bool ctor1called = false;
253 bool ctor2called = false;
254 };
255
TEST(AnalysisManagerTest,DependentAnalysis2Ctors)256 TEST(AnalysisManagerTest, DependentAnalysis2Ctors) {
257 MLIRContext context;
258
259 // Create a module.
260 OwningOpRef<ModuleOp> module(ModuleOp::create(UnknownLoc::get(&context)));
261 ModuleAnalysisManager mam(*module, /*passInstrumentor=*/nullptr);
262 AnalysisManager am = mam;
263
264 auto &an = am.getAnalysis<AnalysisWith2Ctors>();
265 EXPECT_FALSE(an.ctor1called);
266 EXPECT_TRUE(an.ctor2called);
267 }
268
269 } // namespace
270