This is an archive of the discontinued LLVM Phabricator instance.

Differential D101794

[mlir] Update dstNode after DenseMap insertion in loop fusion pass.
ClosedPublic

Authored by ayzhuang on May 3 2021, 4:06 PM.

Details

Reviewers
bondhugula
vinayaka-polymage
tungld
andydavis1
Commits
rG5dc1ed3f627e: [mlir] Update dstNode after DenseMap insertion in loop fusion pass.

Diff Detail

Event Timeline

ayzhuang created this revision.May 3 2021, 4:06 PM
Herald added subscribers: dcaballe, cota, teijeong and 16 others. · View Herald TranscriptMay 3 2021, 4:06 PM
ayzhuang requested review of this revision.May 3 2021, 4:06 PM
Herald added a project: Restricted Project. · View Herald TranscriptMay 3 2021, 4:06 PM
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
Harbormaster completed remote builds in B102410: Diff 342576.May 3 2021, 5:51 PM
jbobba added a subscriber: jbobba.May 5 2021, 7:56 AM
ayzhuang retitled this revision from [mlir] Update dstNode after Densemap insertion in loop fusion pass. to [mlir] Update dstNode after DenseMap insertion in loop fusion pass..May 5 2021, 9:34 AM
ayzhuang added reviewers: vinayaka-polymage, tungld, andydavis1.
vinayaka-polymage accepted this revision.May 5 2021, 10:06 AM

Looks great, thanks for fixing this hard and non-trivial bug !

This revision is now accepted and ready to land.May 5 2021, 10:06 AM
ayzhuang added a comment.May 5 2021, 10:26 AM

@vinayaka-polymage Thank you for the review. We'll merge it tomorrow if there are no more comments.

Closed by commit rG5dc1ed3f627e: [mlir] Update dstNode after DenseMap insertion in loop fusion pass. (authored by ayzhuang, committed by sgrechanik). · Explain WhyMay 6 2021, 3:34 PM
This revision was automatically updated to reflect the committed changes.
sgrechanik added a commit: rG5dc1ed3f627e: [mlir] Update dstNode after DenseMap insertion in loop fusion pass..

Revision Contents

PathSize
mlir/
lib/
Transforms/
4 lines
test/
Transforms/
183 lines

Diff 343516

mlir/lib/Transforms/LoopFusion.cpp

Show First 20 Lines • Show All 1,639 Lines • ▼ Show 20 Lines while (!worklist.empty()) {
dstAffineForOp, storesForMemref[0], bestDstLoopDepth, dstAffineForOp, storesForMemref[0], bestDstLoopDepth,
fastMemorySpace, localBufSizeThreshold); fastMemorySpace, localBufSizeThreshold);
// Create new node in dependence graph for 'newMemRef' alloc op. // Create new node in dependence graph for 'newMemRef' alloc op.
unsigned newMemRefNodeId = unsigned newMemRefNodeId =
mdg->addNode(newMemRef.getDefiningOp()); mdg->addNode(newMemRef.getDefiningOp());
// Add edge from 'newMemRef' node to dstNode. // Add edge from 'newMemRef' node to dstNode.
mdg->addEdge(newMemRefNodeId, dstId, newMemRef); mdg->addEdge(newMemRefNodeId, dstId, newMemRef);
} }
// One or more entries for 'newMemRef' alloc op are inserted into
// the DenseMap mdg->nodes. Since an insertion may cause DenseMap to
// reallocate, update dstNode.
dstNode = mdg->getNode(dstId);
} }
// Collect dst loop stats after memref privatization transformation. // Collect dst loop stats after memref privatization transformation.
LoopNestStateCollector dstLoopCollector; LoopNestStateCollector dstLoopCollector;
dstLoopCollector.collect(dstAffineForOp.getOperation()); dstLoopCollector.collect(dstAffineForOp.getOperation());
// Clear and add back loads and stores. // Clear and add back loads and stores.
mdg->clearNodeLoadAndStores(dstNode->id); mdg->clearNodeLoadAndStores(dstNode->id);
▲ Show 20 Lines • Show All 304 Lines • Show Last 20 Lines

mlir/test/Transforms/loop-fusion.mlir

Show First 20 Lines • Show All 3,109 Lines • ▼ Show 20 Lines
// CHECK-LABEL: func @no_fusion_cannot_compute_valid_slice // CHECK-LABEL: func @no_fusion_cannot_compute_valid_slice
// CHECK: affine.for // CHECK: affine.for
// CHECK-NEXT: affine.load // CHECK-NEXT: affine.load
// CHECK-NEXT: affine.store // CHECK-NEXT: affine.store
// CHECK: affine.for // CHECK: affine.for
// CHECK-NEXT: affine.load // CHECK-NEXT: affine.load
// CHECK-NEXT: mulf // CHECK-NEXT: mulf
// CHECK-NEXT: affine.store // CHECK-NEXT: affine.store
// -----
// CHECK-LABEL: func @fuse_large_number_of_loops
func @fuse_large_number_of_loops(%arg0: memref<20x10xf32, 1>, %arg1: memref<20x10xf32, 1>, %arg2: memref<20x10xf32, 1>, %arg3: memref<20x10xf32, 1>, %arg4: memref<20x10xf32, 1>, %arg5: memref<f32, 1>, %arg6: memref<f32, 1>, %arg7: memref<f32, 1>, %arg8: memref<f32, 1>, %arg9: memref<20x10xf32, 1>, %arg10: memref<20x10xf32, 1>, %arg11: memref<20x10xf32, 1>, %arg12: memref<20x10xf32, 1>) {
%cst = constant 1.000000e+00 : f32
%0 = memref.alloc() : memref<f32, 1>
affine.store %cst, %0[] : memref<f32, 1>
%1 = memref.alloc() : memref<20x10xf32, 1>
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %arg6[] : memref<f32, 1>
affine.store %21, %1[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
%2 = memref.alloc() : memref<20x10xf32, 1>
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %1[%arg13, %arg14] : memref<20x10xf32, 1>
%22 = affine.load %arg3[%arg13, %arg14] : memref<20x10xf32, 1>
%23 = mulf %22, %21 : f32
affine.store %23, %2[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
%3 = memref.alloc() : memref<f32, 1>
%4 = affine.load %arg6[] : memref<f32, 1>
%5 = affine.load %0[] : memref<f32, 1>
%6 = subf %5, %4 : f32
affine.store %6, %3[] : memref<f32, 1>
%7 = memref.alloc() : memref<20x10xf32, 1>
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %3[] : memref<f32, 1>
affine.store %21, %7[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
%8 = memref.alloc() : memref<20x10xf32, 1>
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %arg1[%arg13, %arg14] : memref<20x10xf32, 1>
%22 = affine.load %7[%arg13, %arg14] : memref<20x10xf32, 1>
%23 = mulf %22, %21 : f32
affine.store %23, %8[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
%9 = memref.alloc() : memref<20x10xf32, 1>
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %arg1[%arg13, %arg14] : memref<20x10xf32, 1>
%22 = affine.load %8[%arg13, %arg14] : memref<20x10xf32, 1>
%23 = mulf %22, %21 : f32
affine.store %23, %9[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %9[%arg13, %arg14] : memref<20x10xf32, 1>
%22 = affine.load %2[%arg13, %arg14] : memref<20x10xf32, 1>
%23 = addf %22, %21 : f32
affine.store %23, %arg11[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
%10 = memref.alloc() : memref<20x10xf32, 1>
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %1[%arg13, %arg14] : memref<20x10xf32, 1>
%22 = affine.load %arg2[%arg13, %arg14] : memref<20x10xf32, 1>
%23 = mulf %22, %21 : f32
affine.store %23, %10[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %8[%arg13, %arg14] : memref<20x10xf32, 1>
%22 = affine.load %10[%arg13, %arg14] : memref<20x10xf32, 1>
%23 = addf %22, %21 : f32
affine.store %23, %arg10[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
%11 = memref.alloc() : memref<20x10xf32, 1>
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %arg10[%arg13, %arg14] : memref<20x10xf32, 1>
%22 = affine.load %arg10[%arg13, %arg14] : memref<20x10xf32, 1>
%23 = mulf %22, %21 : f32
affine.store %23, %11[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
%12 = memref.alloc() : memref<20x10xf32, 1>
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %11[%arg13, %arg14] : memref<20x10xf32, 1>
%22 = affine.load %arg11[%arg13, %arg14] : memref<20x10xf32, 1>
%23 = subf %22, %21 : f32
affine.store %23, %12[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
%13 = memref.alloc() : memref<20x10xf32, 1>
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %arg7[] : memref<f32, 1>
affine.store %21, %13[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
%14 = memref.alloc() : memref<20x10xf32, 1>
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %arg4[%arg13, %arg14] : memref<20x10xf32, 1>
%22 = affine.load %13[%arg13, %arg14] : memref<20x10xf32, 1>
%23 = mulf %22, %21 : f32
affine.store %23, %14[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
%15 = memref.alloc() : memref<20x10xf32, 1>
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %arg8[] : memref<f32, 1>
affine.store %21, %15[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
%16 = memref.alloc() : memref<20x10xf32, 1>
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %15[%arg13, %arg14] : memref<20x10xf32, 1>
%22 = affine.load %12[%arg13, %arg14] : memref<20x10xf32, 1>
%23 = addf %22, %21 : f32
affine.store %23, %16[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
%17 = memref.alloc() : memref<20x10xf32, 1>
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %16[%arg13, %arg14] : memref<20x10xf32, 1>
%22 = math.sqrt %21 : f32
affine.store %22, %17[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
%18 = memref.alloc() : memref<20x10xf32, 1>
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %arg5[] : memref<f32, 1>
affine.store %21, %18[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
%19 = memref.alloc() : memref<20x10xf32, 1>
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %arg1[%arg13, %arg14] : memref<20x10xf32, 1>
%22 = affine.load %18[%arg13, %arg14] : memref<20x10xf32, 1>
%23 = mulf %22, %21 : f32
affine.store %23, %19[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
%20 = memref.alloc() : memref<20x10xf32, 1>
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %17[%arg13, %arg14] : memref<20x10xf32, 1>
%22 = affine.load %19[%arg13, %arg14] : memref<20x10xf32, 1>
%23 = divf %22, %21 : f32
affine.store %23, %20[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %20[%arg13, %arg14] : memref<20x10xf32, 1>
%22 = affine.load %14[%arg13, %arg14] : memref<20x10xf32, 1>
%23 = addf %22, %21 : f32
affine.store %23, %arg12[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
affine.for %arg13 = 0 to 20 {
affine.for %arg14 = 0 to 10 {
%21 = affine.load %arg12[%arg13, %arg14] : memref<20x10xf32, 1>
%22 = affine.load %arg0[%arg13, %arg14] : memref<20x10xf32, 1>
%23 = subf %22, %21 : f32
affine.store %23, %arg9[%arg13, %arg14] : memref<20x10xf32, 1>
}
}
return
}
// CHECK: affine.for
// CHECK: affine.for
// CHECK-NOT: affine.for