MLIR  18.0.0git
Utils.h
Go to the documentation of this file.
1 //===- Utils.h - Affine dialect utilities -----------------------*- C++ -*-===//
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 // This header file declares a set of utilities for the affine dialect ops.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef MLIR_DIALECT_AFFINE_UTILS_H
14 #define MLIR_DIALECT_AFFINE_UTILS_H
15 
18 #include <optional>
19 
20 namespace mlir {
21 class DominanceInfo;
22 class Operation;
23 class PostDominanceInfo;
24 
25 namespace func {
26 class FuncOp;
27 } // namespace func
28 
29 namespace memref {
30 class AllocOp;
31 } // namespace memref
32 
33 struct LogicalResult;
34 
35 namespace affine {
36 class AffineForOp;
37 class AffineIfOp;
38 class AffineParallelOp;
39 
41 
42 /// Replaces a parallel affine.for op with a 1-d affine.parallel op. `forOp`'s
43 /// body is taken by the affine.parallel op and the former is erased.
44 /// (mlir::isLoopParallel can be used to detect a parallel affine.for op.) The
45 /// reductions specified in `parallelReductions` are also parallelized.
46 /// Parallelization will fail in the presence of loop iteration arguments that
47 /// are not listed in `parallelReductions`. `resOp` if non-null is set to the
48 /// newly created affine.parallel op.
49 LogicalResult affineParallelize(AffineForOp forOp,
50  ArrayRef<LoopReduction> parallelReductions = {},
51  AffineParallelOp *resOp = nullptr);
52 
53 /// Hoists out affine.if/else to as high as possible, i.e., past all invariant
54 /// affine.fors/parallel's. Returns success if any hoisting happened; folded` is
55 /// set to true if the op was folded or erased. This hoisting could lead to
56 /// significant code expansion in some cases.
57 LogicalResult hoistAffineIfOp(AffineIfOp ifOp, bool *folded = nullptr);
58 
59 /// Holds parameters to perform n-D vectorization on a single loop nest.
60 /// For example, for the following loop nest:
61 ///
62 /// func @vec2d(%in: memref<64x128x512xf32>, %out: memref<64x128x512xf32>) {
63 /// affine.for %i0 = 0 to 64 {
64 /// affine.for %i1 = 0 to 128 {
65 /// affine.for %i2 = 0 to 512 {
66 /// %ld = affine.load %in[%i0, %i1, %i2] : memref<64x128x512xf32>
67 /// affine.store %ld, %out[%i0, %i1, %i2] : memref<64x128x512xf32>
68 /// }
69 /// }
70 /// }
71 /// return
72 /// }
73 ///
74 /// and VectorizationStrategy = 'vectorSizes = {8, 4}', 'loopToVectorDim =
75 /// {{i1->0}, {i2->1}}', SuperVectorizer will generate:
76 ///
77 /// func @vec2d(%arg0: memref<64x128x512xf32>, %arg1: memref<64x128x512xf32>) {
78 /// affine.for %arg2 = 0 to 64 {
79 /// affine.for %arg3 = 0 to 128 step 8 {
80 /// affine.for %arg4 = 0 to 512 step 4 {
81 /// %cst = arith.constant 0.000000e+00 : f32
82 /// %0 = vector.transfer_read %arg0[%arg2, %arg3, %arg4], %cst : ...
83 /// vector.transfer_write %0, %arg1[%arg2, %arg3, %arg4] : ...
84 /// }
85 /// }
86 /// }
87 /// return
88 /// }
89 // TODO: Hoist to a VectorizationStrategy.cpp when appropriate.
91  // Vectorization factors to apply to each target vector dimension.
92  // Each factor will be applied to a different loop.
94  // Maps each AffineForOp vectorization candidate with its vector dimension.
95  // The candidate will be vectorized using the vectorization factor in
96  // 'vectorSizes' for that dimension.
98  // Maps loops that implement vectorizable reductions to the corresponding
99  // reduction descriptors.
101 };
102 
103 /// Replace affine store and load accesses by scalars by forwarding stores to
104 /// loads and eliminate invariant affine loads; consequently, eliminate dead
105 /// allocs.
106 void affineScalarReplace(func::FuncOp f, DominanceInfo &domInfo,
107  PostDominanceInfo &postDomInfo);
108 
109 /// Vectorizes affine loops in 'loops' using the n-D vectorization factors in
110 /// 'vectorSizes'. By default, each vectorization factor is applied
111 /// inner-to-outer to the loops of each loop nest. 'fastestVaryingPattern' can
112 /// be optionally used to provide a different loop vectorization order.
113 /// If `reductionLoops` is not empty, the given reduction loops may be
114 /// vectorized along the reduction dimension.
115 /// TODO: Vectorizing reductions is supported only for 1-D vectorization.
117  Operation *parentOp,
119  ArrayRef<int64_t> vectorSizes, ArrayRef<int64_t> fastestVaryingPattern,
120  const ReductionLoopMap &reductionLoops = ReductionLoopMap());
121 
122 /// External utility to vectorize affine loops from a single loop nest using an
123 /// n-D vectorization strategy (see doc in VectorizationStrategy definition).
124 /// Loops are provided in a 2D vector container. The first dimension represents
125 /// the nesting level relative to the loops to be vectorized. The second
126 /// dimension contains the loops. This means that:
127 /// a) every loop in 'loops[i]' must have a parent loop in 'loops[i-1]',
128 /// b) a loop in 'loops[i]' may or may not have a child loop in 'loops[i+1]'.
129 ///
130 /// For example, for the following loop nest:
131 ///
132 /// func @vec2d(%in0: memref<64x128x512xf32>, %in1: memref<64x128x128xf32>,
133 /// %out0: memref<64x128x512xf32>,
134 /// %out1: memref<64x128x128xf32>) {
135 /// affine.for %i0 = 0 to 64 {
136 /// affine.for %i1 = 0 to 128 {
137 /// affine.for %i2 = 0 to 512 {
138 /// %ld = affine.load %in0[%i0, %i1, %i2] : memref<64x128x512xf32>
139 /// affine.store %ld, %out0[%i0, %i1, %i2] : memref<64x128x512xf32>
140 /// }
141 /// affine.for %i3 = 0 to 128 {
142 /// %ld = affine.load %in1[%i0, %i1, %i3] : memref<64x128x128xf32>
143 /// affine.store %ld, %out1[%i0, %i1, %i3] : memref<64x128x128xf32>
144 /// }
145 /// }
146 /// }
147 /// return
148 /// }
149 ///
150 /// loops = {{%i0}, {%i2, %i3}}, to vectorize the outermost and the two
151 /// innermost loops;
152 /// loops = {{%i1}, {%i2, %i3}}, to vectorize the middle and the two innermost
153 /// loops;
154 /// loops = {{%i2}}, to vectorize only the first innermost loop;
155 /// loops = {{%i3}}, to vectorize only the second innermost loop;
156 /// loops = {{%i1}}, to vectorize only the middle loop.
159  const VectorizationStrategy &strategy);
160 
161 /// Normalize a affine.parallel op so that lower bounds are 0 and steps are 1.
162 /// As currently implemented, this transformation cannot fail and will return
163 /// early if the op is already in a normalized form.
164 void normalizeAffineParallel(AffineParallelOp op);
165 
166 /// Normalize an affine.for op. An affine.for op is normalized by converting the
167 /// lower bound to zero and loop step to one. The upper bound is set to the trip
168 /// count of the loop. Original loops must have a lower bound with only a single
169 /// result. There is no such restriction on upper bounds. Returns success if the
170 /// loop has been normalized (or is already in the normal form). If
171 /// `promoteSingleIter` is true, the loop is simply promoted if it has a single
172 /// iteration.
173 LogicalResult normalizeAffineFor(AffineForOp op,
174  bool promoteSingleIter = false);
175 
176 /// Traverse `e` and return an AffineExpr where all occurrences of `dim` have
177 /// been replaced by either:
178 /// - `min` if `positivePath` is true when we reach an occurrence of `dim`
179 /// - `max` if `positivePath` is true when we reach an occurrence of `dim`
180 /// `positivePath` is negated each time we hit a multiplicative or divisive
181 /// binary op with a constant negative coefficient.
183  AffineExpr max, bool positivePath = true);
184 
185 /// Replaces all "dereferencing" uses of `oldMemRef` with `newMemRef` while
186 /// optionally remapping the old memref's indices using the supplied affine map,
187 /// `indexRemap`. The new memref could be of a different shape or rank.
188 /// `extraIndices` provides any additional access indices to be added to the
189 /// start.
190 ///
191 /// `indexRemap` remaps indices of the old memref access to a new set of indices
192 /// that are used to index the memref. Additional input operands to indexRemap
193 /// can be optionally provided in `extraOperands`, and they occupy the start
194 /// of its input list. `indexRemap`'s dimensional inputs are expected to
195 /// correspond to memref's indices, and its symbolic inputs if any should be
196 /// provided in `symbolOperands`.
197 ///
198 /// `domOpFilter`, if non-null, restricts the replacement to only those
199 /// operations that are dominated by the former; similarly, `postDomOpFilter`
200 /// restricts replacement to only those operations that are postdominated by it.
201 ///
202 /// 'allowNonDereferencingOps', if set, allows replacement of non-dereferencing
203 /// uses of a memref without any requirement for access index rewrites as long
204 /// as the user operation has the MemRefsNormalizable trait. The default value
205 /// of this flag is false.
206 ///
207 /// 'replaceInDeallocOp', if set, lets DeallocOp, a non-dereferencing user, to
208 /// also be a candidate for replacement. The default value of this flag is
209 /// false.
210 ///
211 /// Returns true on success and false if the replacement is not possible,
212 /// whenever a memref is used as an operand in a non-dereferencing context and
213 /// 'allowNonDereferencingOps' is false, except for dealloc's on the memref
214 /// which are left untouched. See comments at function definition for an
215 /// example.
216 //
217 // Ex: to replace load %A[%i, %j] with load %Abuf[%t mod 2, %ii - %i, %j]:
218 // The SSA value corresponding to '%t mod 2' should be in 'extraIndices', and
219 // index remap will perform (%i, %j) -> (%ii - %i, %j), i.e., indexRemap = (d0,
220 // d1, d2) -> (d0 - d1, d2), and %ii will be the extra operand. Without any
221 // extra operands, note that 'indexRemap' would just be applied to existing
222 // indices (%i, %j).
223 // TODO: allow extraIndices to be added at any position.
225  Value oldMemRef, Value newMemRef, ArrayRef<Value> extraIndices = {},
226  AffineMap indexRemap = AffineMap(), ArrayRef<Value> extraOperands = {},
227  ArrayRef<Value> symbolOperands = {}, Operation *domOpFilter = nullptr,
228  Operation *postDomOpFilter = nullptr, bool allowNonDereferencingOps = false,
229  bool replaceInDeallocOp = false);
230 
231 /// Performs the same replacement as the other version above but only for the
232 /// dereferencing uses of `oldMemRef` in `op`, except in cases where
233 /// 'allowNonDereferencingOps' is set to true where we replace the
234 /// non-dereferencing uses as well.
235 LogicalResult replaceAllMemRefUsesWith(Value oldMemRef, Value newMemRef,
236  Operation *op,
237  ArrayRef<Value> extraIndices = {},
238  AffineMap indexRemap = AffineMap(),
239  ArrayRef<Value> extraOperands = {},
240  ArrayRef<Value> symbolOperands = {},
241  bool allowNonDereferencingOps = false);
242 
243 /// Rewrites the memref defined by this alloc op to have an identity layout map
244 /// and updates all its indexing uses. Returns failure if any of its uses
245 /// escape (while leaving the IR in a valid state).
246 LogicalResult normalizeMemRef(memref::AllocOp *op);
247 
248 /// Normalizes `memrefType` so that the affine layout map of the memref is
249 /// transformed to an identity map with a new shape being computed for the
250 /// normalized memref type and returns it. The old memref type is simplify
251 /// returned if the normalization failed.
252 MemRefType normalizeMemRefType(MemRefType memrefType);
253 
254 /// Given an operation, inserts one or more single result affine apply
255 /// operations, results of which are exclusively used by this operation.
256 /// The operands of these newly created affine apply ops are
257 /// guaranteed to be loop iterators or terminal symbols of a function.
258 ///
259 /// Before
260 ///
261 /// affine.for %i = 0 to #map(%N)
262 /// %idx = affine.apply (d0) -> (d0 mod 2) (%i)
263 /// send %A[%idx], ...
264 /// %v = "compute"(%idx, ...)
265 ///
266 /// After
267 ///
268 /// affine.for %i = 0 to #map(%N)
269 /// %idx = affine.apply (d0) -> (d0 mod 2) (%i)
270 /// send %A[%idx], ...
271 /// %idx_ = affine.apply (d0) -> (d0 mod 2) (%i)
272 /// %v = "compute"(%idx_, ...)
273 
274 /// This allows the application of different transformations on send and
275 /// compute (for eg. different shifts/delays)
276 ///
277 /// Fills `sliceOps` with the list of affine.apply operations.
278 /// In the following cases, `sliceOps` remains empty:
279 /// 1. If none of opInst's operands were the result of an affine.apply
280 /// (i.e., there was no affine computation slice to create).
281 /// 2. If all the affine.apply op's supplying operands to this opInst did not
282 /// have any uses other than those in this opInst.
283 void createAffineComputationSlice(Operation *opInst,
284  SmallVectorImpl<AffineApplyOp> *sliceOps);
285 
286 /// Emit code that computes the given affine expression using standard
287 /// arithmetic operations applied to the provided dimension and symbol values.
288 Value expandAffineExpr(OpBuilder &builder, Location loc, AffineExpr expr,
289  ValueRange dimValues, ValueRange symbolValues);
290 
291 /// Create a sequence of operations that implement the `affineMap` applied to
292 /// the given `operands` (as it it were an AffineApplyOp).
293 std::optional<SmallVector<Value, 8>> expandAffineMap(OpBuilder &builder,
294  Location loc,
295  AffineMap affineMap,
296  ValueRange operands);
297 
298 /// Holds the result of (div a, b) and (mod a, b).
299 struct DivModValue {
302 };
303 
304 /// Create IR to calculate (div lhs, rhs) and (mod lhs, rhs).
306 
307 /// Generate the IR to delinearize `linearIndex` given the `basis` and return
308 /// the multi-index.
310  Value linearIndex,
311  ArrayRef<Value> basis);
312 
313 /// Ensure that all operations that could be executed after `start`
314 /// (noninclusive) and prior to `memOp` (e.g. on a control flow/op path
315 /// between the operations) do not have the potential memory effect
316 /// `EffectType` on `memOp`. `memOp` is an operation that reads or writes to
317 /// a memref. For example, if `EffectType` is MemoryEffects::Write, this method
318 /// will check if there is no write to the memory between `start` and `memOp`
319 /// that would change the read within `memOp`.
320 template <typename EffectType, typename T>
321 bool hasNoInterveningEffect(Operation *start, T memOp);
322 
324  explicit AffineValueExpr(AffineExpr e) : e(e) {}
326  this->v = v;
327  return *this;
328  }
330  this->v = v;
331  return *this;
332  }
333  operator AffineExpr() const { return e; }
334  operator OpFoldResult() const { return v; }
337 };
338 
339 /// Helper struct to build simple AffineValueExprs with minimal type inference
340 /// support.
342  AffineBuilder(OpBuilder &b, Location loc) : b(b), loc(loc) {}
344  return makeComposedFoldedAffineApply(b, loc, {lhs.e + rhs.e}, {lhs, rhs});
345  }
347  return makeComposedFoldedAffineApply(b, loc, {lhs.e - rhs.e}, {lhs, rhs});
348  }
350  return makeComposedFoldedAffineApply(b, loc, {lhs.e * rhs.e}, {lhs, rhs});
351  }
353  return makeComposedFoldedAffineApply(b, loc, {lhs.e.floorDiv(rhs.e)},
354  {lhs, rhs});
355  }
357  return makeComposedFoldedAffineApply(b, loc, {lhs.e.ceilDiv(rhs.e)},
358  {lhs, rhs});
359  }
362  b, loc, AffineMap::getMultiDimIdentityMap(vals.size(), b.getContext()),
363  vals);
364  }
367  b, loc, AffineMap::getMultiDimIdentityMap(vals.size(), b.getContext()),
368  vals);
369  }
370 
371 private:
372  OpBuilder &b;
373  Location loc;
374 };
375 
376 } // namespace affine
377 } // namespace mlir
378 
379 #endif // MLIR_DIALECT_AFFINE_UTILS_H
static Value max(ImplicitLocOpBuilder &builder, Value value, Value bound)
static Value min(ImplicitLocOpBuilder &builder, Value value, Value bound)
Base type for affine expression.
Definition: AffineExpr.h:68
AffineExpr floorDiv(uint64_t v) const
Definition: AffineExpr.cpp:867
AffineExpr ceilDiv(uint64_t v) const
Definition: AffineExpr.cpp:910
A multi-dimensional affine map Affine map's are immutable like Type's, and they are uniqued.
Definition: AffineMap.h:47
static AffineMap getMultiDimIdentityMap(unsigned numDims, MLIRContext *context)
Returns an AffineMap with 'numDims' identity result dim exprs.
Definition: AffineMap.cpp:312
MLIRContext * getContext() const
Definition: Builders.h:55
A class for computing basic dominance information.
Definition: Dominance.h:121
This class provides support for representing a failure result, or a valid value of type T.
Definition: LogicalResult.h:78
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
Definition: Location.h:63
This class helps build Operations.
Definition: Builders.h:206
This class represents a single result from folding an operation.
Definition: OpDefinition.h:266
Operation is the basic unit of execution within MLIR.
Definition: Operation.h:88
A class for computing basic postdominance information.
Definition: Dominance.h:180
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
Definition: Value.h:96
std::optional< SmallVector< Value, 8 > > expandAffineMap(OpBuilder &builder, Location loc, AffineMap affineMap, ValueRange operands)
Create a sequence of operations that implement the affineMap applied to the given operands (as it it ...
Definition: Utils.cpp:223
FailureOr< SmallVector< Value > > delinearizeIndex(OpBuilder &b, Location loc, Value linearIndex, ArrayRef< Value > basis)
Generate the IR to delinearize linearIndex given the basis and return the multi-index.
Definition: Utils.cpp:1851
Value expandAffineExpr(OpBuilder &builder, Location loc, AffineExpr expr, ValueRange dimValues, ValueRange symbolValues)
Emit code that computes the given affine expression using standard arithmetic operations applied to t...
Definition: Utils.cpp:213
void normalizeAffineParallel(AffineParallelOp op)
Normalize a affine.parallel op so that lower bounds are 0 and steps are 1.
Definition: Utils.cpp:489
LogicalResult affineParallelize(AffineForOp forOp, ArrayRef< LoopReduction > parallelReductions={}, AffineParallelOp *resOp=nullptr)
Replaces a parallel affine.for op with a 1-d affine.parallel op.
Definition: Utils.cpp:346
OpFoldResult makeComposedFoldedAffineMax(OpBuilder &b, Location loc, AffineMap map, ArrayRef< OpFoldResult > operands)
Constructs an AffineMinOp that computes a maximum across the results of applying map to operands,...
Definition: AffineOps.cpp:1283
void vectorizeAffineLoops(Operation *parentOp, llvm::DenseSet< Operation *, DenseMapInfo< Operation * >> &loops, ArrayRef< int64_t > vectorSizes, ArrayRef< int64_t > fastestVaryingPattern, const ReductionLoopMap &reductionLoops=ReductionLoopMap())
Vectorizes affine loops in 'loops' using the n-D vectorization factors in 'vectorSizes'.
LogicalResult normalizeAffineFor(AffineForOp op, bool promoteSingleIter=false)
Normalize an affine.for op.
Definition: Utils.cpp:553
OpFoldResult makeComposedFoldedAffineMin(OpBuilder &b, Location loc, AffineMap map, ArrayRef< OpFoldResult > operands)
Constructs an AffineMinOp that computes a minimum across the results of applying map to operands,...
Definition: AffineOps.cpp:1276
LogicalResult normalizeMemRef(memref::AllocOp *op)
Rewrites the memref defined by this alloc op to have an identity layout map and updates all its index...
Definition: Utils.cpp:1687
OpFoldResult makeComposedFoldedAffineApply(OpBuilder &b, Location loc, AffineMap map, ArrayRef< OpFoldResult > operands)
Constructs an AffineApplyOp that applies map to operands after composing the map with the maps of any...
Definition: AffineOps.cpp:1172
void affineScalarReplace(func::FuncOp f, DominanceInfo &domInfo, PostDominanceInfo &postDomInfo)
Replace affine store and load accesses by scalars by forwarding stores to loads and eliminate invaria...
Definition: Utils.cpp:1034
bool hasNoInterveningEffect(Operation *start, T memOp)
Ensure that all operations that could be executed after start (noninclusive) and prior to memOp (e....
Definition: Utils.cpp:679
MemRefType normalizeMemRefType(MemRefType memrefType)
Normalizes memrefType so that the affine layout map of the memref is transformed to an identity map w...
Definition: Utils.cpp:1744
DenseMap< Operation *, SmallVector< LoopReduction, 2 > > ReductionLoopMap
Definition: Utils.h:40
DivModValue getDivMod(OpBuilder &b, Location loc, Value lhs, Value rhs)
Create IR to calculate (div lhs, rhs) and (mod lhs, rhs).
Definition: Utils.cpp:1825
void createAffineComputationSlice(Operation *opInst, SmallVectorImpl< AffineApplyOp > *sliceOps)
Given an operation, inserts one or more single result affine apply operations, results of which are e...
Definition: Utils.cpp:1382
LogicalResult hoistAffineIfOp(AffineIfOp ifOp, bool *folded=nullptr)
Hoists out affine.if/else to as high as possible, i.e., past all invariant affine....
Definition: Utils.cpp:408
AffineExpr substWithMin(AffineExpr e, AffineExpr dim, AffineExpr min, AffineExpr max, bool positivePath=true)
Traverse e and return an AffineExpr where all occurrences of dim have been replaced by either:
Definition: Utils.cpp:462
LogicalResult replaceAllMemRefUsesWith(Value oldMemRef, Value newMemRef, ArrayRef< Value > extraIndices={}, AffineMap indexRemap=AffineMap(), ArrayRef< Value > extraOperands={}, ArrayRef< Value > symbolOperands={}, Operation *domOpFilter=nullptr, Operation *postDomOpFilter=nullptr, bool allowNonDereferencingOps=false, bool replaceInDeallocOp=false)
Replaces all "dereferencing" uses of oldMemRef with newMemRef while optionally remapping the old memr...
Definition: Utils.cpp:1266
LogicalResult vectorizeAffineLoopNest(std::vector< SmallVector< AffineForOp, 2 >> &loops, const VectorizationStrategy &strategy)
External utility to vectorize affine loops from a single loop nest using an n-D vectorization strateg...
Include the generated interface declarations.
This class represents an efficient way to signal success or failure.
Definition: LogicalResult.h:26
Helper struct to build simple AffineValueExprs with minimal type inference support.
Definition: Utils.h:341
OpFoldResult add(AffineValueExpr lhs, AffineValueExpr rhs)
Definition: Utils.h:343
OpFoldResult min(ArrayRef< OpFoldResult > vals)
Definition: Utils.h:360
OpFoldResult ceil(AffineValueExpr lhs, AffineValueExpr rhs)
Definition: Utils.h:356
OpFoldResult max(ArrayRef< OpFoldResult > vals)
Definition: Utils.h:365
AffineBuilder(OpBuilder &b, Location loc)
Definition: Utils.h:342
OpFoldResult floor(AffineValueExpr lhs, AffineValueExpr rhs)
Definition: Utils.h:352
OpFoldResult sub(AffineValueExpr lhs, AffineValueExpr rhs)
Definition: Utils.h:346
OpFoldResult mul(AffineValueExpr lhs, AffineValueExpr rhs)
Definition: Utils.h:349
AffineValueExpr(AffineExpr e)
Definition: Utils.h:324
AffineValueExpr bind(Value v)
Definition: Utils.h:325
AffineValueExpr bind(OpFoldResult v)
Definition: Utils.h:329
Holds the result of (div a, b) and (mod a, b).
Definition: Utils.h:299
Holds parameters to perform n-D vectorization on a single loop nest.
Definition: Utils.h:90
SmallVector< int64_t, 8 > vectorSizes
Definition: Utils.h:93
DenseMap< Operation *, unsigned > loopToVectorDim
Definition: Utils.h:97
ReductionLoopMap reductionLoops
Definition: Utils.h:100