1 //===--------- PolyhedralInfo.cpp  - Create Scops from LLVM IR-------------===//
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 // An interface to the Polyhedral analysis engine(Polly) of LLVM.
10 //
11 // This pass provides an interface to the polyhedral analysis performed by
12 // Polly.
13 //
14 // This interface provides basic interface like isParallel, isVectorizable
15 // that can be used in LLVM transformation passes.
16 //
17 // Work in progress, this file is subject to change.
18 //
19 //===----------------------------------------------------------------------===//
20 
21 #include "polly/PolyhedralInfo.h"
22 #include "polly/DependenceInfo.h"
23 #include "polly/LinkAllPasses.h"
24 #include "polly/Options.h"
25 #include "polly/ScopInfo.h"
26 #include "polly/Support/GICHelper.h"
27 #include "llvm/Analysis/LoopInfo.h"
28 #include "llvm/Support/Debug.h"
29 #include "isl/union_map.h"
30 
31 using namespace llvm;
32 using namespace polly;
33 
34 #define DEBUG_TYPE "polyhedral-info"
35 
36 static cl::opt<bool> CheckParallel("polly-check-parallel",
37                                    cl::desc("Check for parallel loops"),
38                                    cl::Hidden, cl::init(false), cl::ZeroOrMore,
39                                    cl::cat(PollyCategory));
40 
41 static cl::opt<bool> CheckVectorizable("polly-check-vectorizable",
42                                        cl::desc("Check for vectorizable loops"),
43                                        cl::Hidden, cl::init(false),
44                                        cl::ZeroOrMore, cl::cat(PollyCategory));
45 
46 void PolyhedralInfo::getAnalysisUsage(AnalysisUsage &AU) const {
47   AU.addRequiredTransitive<DependenceInfoWrapperPass>();
48   AU.addRequired<LoopInfoWrapperPass>();
49   AU.addRequiredTransitive<ScopInfoWrapperPass>();
50   AU.setPreservesAll();
51 }
52 
53 bool PolyhedralInfo::runOnFunction(Function &F) {
54   DI = &getAnalysis<DependenceInfoWrapperPass>();
55   SI = getAnalysis<ScopInfoWrapperPass>().getSI();
56   return false;
57 }
58 
59 void PolyhedralInfo::print(raw_ostream &OS, const Module *) const {
60   auto &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
61   for (auto *TopLevelLoop : LI) {
62     for (auto *L : depth_first(TopLevelLoop)) {
63       OS.indent(2) << L->getHeader()->getName() << ":\t";
64       if (CheckParallel && isParallel(L))
65         OS << "Loop is parallel.\n";
66       else if (CheckParallel)
67         OS << "Loop is not parallel.\n";
68     }
69   }
70 }
71 
72 bool PolyhedralInfo::checkParallel(Loop *L, isl_pw_aff **MinDepDistPtr) const {
73   bool IsParallel;
74   const Scop *S = getScopContainingLoop(L);
75   if (!S)
76     return false;
77   const Dependences &D =
78       DI->getDependences(const_cast<Scop *>(S), Dependences::AL_Access);
79   if (!D.hasValidDependences())
80     return false;
81   LLVM_DEBUG(dbgs() << "Loop :\t" << L->getHeader()->getName() << ":\n");
82 
83   isl_union_map *Deps =
84       D.getDependences(Dependences::TYPE_RAW | Dependences::TYPE_WAW |
85                        Dependences::TYPE_WAR | Dependences::TYPE_RED)
86           .release();
87 
88   LLVM_DEBUG(dbgs() << "Dependences :\t" << stringFromIslObj(Deps) << "\n");
89 
90   isl_union_map *Schedule = getScheduleForLoop(S, L);
91   LLVM_DEBUG(dbgs() << "Schedule: \t" << stringFromIslObj(Schedule) << "\n");
92 
93   IsParallel = D.isParallel(Schedule, Deps, MinDepDistPtr);
94   isl_union_map_free(Schedule);
95   return IsParallel;
96 }
97 
98 bool PolyhedralInfo::isParallel(Loop *L) const { return checkParallel(L); }
99 
100 const Scop *PolyhedralInfo::getScopContainingLoop(Loop *L) const {
101   assert((SI) && "ScopInfoWrapperPass is required by PolyhedralInfo pass!\n");
102   for (auto &It : *SI) {
103     Region *R = It.first;
104     if (R->contains(L))
105       return It.second.get();
106   }
107   return nullptr;
108 }
109 
110 //  Given a Loop and the containing SCoP, we compute the partial schedule
111 //  by taking union of individual schedules of each ScopStmt within the loop
112 //  and projecting out the inner dimensions from the range of the schedule.
113 //   for (i = 0; i < n; i++)
114 //      for (j = 0; j < n; j++)
115 //        A[j] = 1;  //Stmt
116 //
117 //  The original schedule will be
118 //    Stmt[i0, i1] -> [i0, i1]
119 //  The schedule for the outer loop will be
120 //    Stmt[i0, i1] -> [i0]
121 //  The schedule for the inner loop will be
122 //    Stmt[i0, i1] -> [i0, i1]
123 __isl_give isl_union_map *PolyhedralInfo::getScheduleForLoop(const Scop *S,
124                                                              Loop *L) const {
125   isl_union_map *Schedule = isl_union_map_empty(S->getParamSpace().release());
126   int CurrDim = S->getRelativeLoopDepth(L);
127   LLVM_DEBUG(dbgs() << "Relative loop depth:\t" << CurrDim << "\n");
128   assert(CurrDim >= 0 && "Loop in region should have at least depth one");
129 
130   for (auto &SS : *S) {
131     if (L->contains(SS.getSurroundingLoop())) {
132 
133       unsigned int MaxDim = SS.getNumIterators();
134       LLVM_DEBUG(dbgs() << "Maximum depth of Stmt:\t" << MaxDim << "\n");
135       isl_map *ScheduleMap = SS.getSchedule().release();
136       assert(
137           ScheduleMap &&
138           "Schedules that contain extension nodes require special handling.");
139 
140       ScheduleMap = isl_map_project_out(ScheduleMap, isl_dim_out, CurrDim + 1,
141                                         MaxDim - CurrDim - 1);
142       ScheduleMap = isl_map_set_tuple_id(ScheduleMap, isl_dim_in,
143                                          SS.getDomainId().release());
144       Schedule =
145           isl_union_map_union(Schedule, isl_union_map_from_map(ScheduleMap));
146     }
147   }
148   Schedule = isl_union_map_coalesce(Schedule);
149   return Schedule;
150 }
151 
152 char PolyhedralInfo::ID = 0;
153 
154 Pass *polly::createPolyhedralInfoPass() { return new PolyhedralInfo(); }
155 
156 INITIALIZE_PASS_BEGIN(PolyhedralInfo, "polyhedral-info",
157                       "Polly - Interface to polyhedral analysis engine", false,
158                       false);
159 INITIALIZE_PASS_DEPENDENCY(DependenceInfoWrapperPass);
160 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass);
161 INITIALIZE_PASS_DEPENDENCY(ScopInfoWrapperPass);
162 INITIALIZE_PASS_END(PolyhedralInfo, "polyhedral-info",
163                     "Polly - Interface to polyhedral analysis engine", false,
164                     false)
165