This is an archive of the discontinued LLVM Phabricator instance.

Differential D159170

[mlir][sparse] fix crash when generating convolution kernel with sparse input in DCCD format.
ClosedPublic

Authored by Peiming on Aug 29 2023, 11:15 PM.

Details

Reviewers
aartbik
nicolasvasilache
anlunx
yinying-lisa-li
Commits
rG96e1914aa2e6: [mlir][sparse] fix crash when generating convolution kernel with sparse input…

Diff Detail

Event Timeline

Peiming created this revision.Aug 29 2023, 11:15 PM
Herald added a reviewer: aartbik. · View Herald TranscriptAug 29 2023, 11:15 PM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: K-Wu, bviyer, hanchung and 24 others. · View Herald Transcript
Peiming requested review of this revision.Aug 29 2023, 11:15 PM
Herald added a reviewer: nicolasvasilache. · View Herald TranscriptAug 29 2023, 11:15 PM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
Peiming added inline comments.Aug 29 2023, 11:16 PM
mlir/lib/Dialect/SparseTensor/Transforms/LoopEmitter.cpp
1816

No idea why it did not cause any problem before ;-(

Peiming added reviewers: anlunx, yinying-lisa-li.Aug 29 2023, 11:17 PM
anlunx accepted this revision.Aug 29 2023, 11:21 PM
This revision is now accepted and ready to land.Aug 29 2023, 11:21 PM
Peiming updated this revision to Diff 554590.Aug 29 2023, 11:47 PM

fix bugs.

Harbormaster completed remote builds in B255699: Diff 554590.Aug 30 2023, 1:14 AM
aartbik accepted this revision.Aug 30 2023, 9:11 AM
aartbik added inline comments.
mlir/lib/Dialect/SparseTensor/Transforms/LoopEmitter.cpp
1816

Yeah, surprising. But all is well now.

Closed by commit rG96e1914aa2e6: [mlir][sparse] fix crash when generating convolution kernel with sparse input… (authored by Peiming). · Explain WhyAug 30 2023, 10:49 AM
This revision was automatically updated to reflect the committed changes.
Peiming added a commit: rG96e1914aa2e6: [mlir][sparse] fix crash when generating convolution kernel with sparse input….

Revision Contents

PathSize
mlir/
lib/
Dialect/
SparseTensor/
Transforms/
8 lines
test/
Integration/
Dialect/
SparseTensor/
CPU/
2 lines
45 lines

Diff 554782

mlir/lib/Dialect/SparseTensor/Transforms/LoopEmitter.cpp

Show First 20 Lines • Show All 1,794 Lines • ▼ Show 20 Lines if (lvl == 0) {
pLo = c0; pLo = c0;
pHi = genIndexLoad(builder, loc, positionsBuffers[tid][0], c1); pHi = genIndexLoad(builder, loc, positionsBuffers[tid][0], c1);
} else { } else {
pLo = genIndexLoad(builder, loc, positionsBuffers[tid][lvl], pLo = genIndexLoad(builder, loc, positionsBuffers[tid][lvl],
posits[tid][lvl - 1]); posits[tid][lvl - 1]);
pHi = genIndexLoad(builder, loc, positionsBuffers[tid][lvl], pHi = genIndexLoad(builder, loc, positionsBuffers[tid][lvl],
ADDI(posits[tid][lvl - 1], c1)); ADDI(posits[tid][lvl - 1], c1));
} }
// Fills out pIdxBuffer[tid][lvl][0] with [/*memSize =*/4, 0, 0, pHi] // Fills out pIdxBuffer[tid][lvl][0] with [/*memSize =*/4, 0, pLo, pHi]
builder.create<memref::StoreOp>(loc, c4, sPtrBuf, c0); // memSize = 4 builder.create<memref::StoreOp>(loc, c4, sPtrBuf, c0); // memSize = 4
builder.create<memref::StoreOp>(loc, c0, sPtrBuf, c1); // index = 0 builder.create<memref::StoreOp>(loc, c0, sPtrBuf, c1); // index = 0
builder.create<memref::StoreOp>(loc, pLo, sPtrBuf, c2); // pLo builder.create<memref::StoreOp>(loc, pLo, sPtrBuf, c2); // pLo
builder.create<memref::StoreOp>(loc, pHi, sPtrBuf, c3); // pHi builder.create<memref::StoreOp>(loc, pHi, sPtrBuf, c3); // pHi
// This is an non empty tensor if 0 < pHi. // This is an non empty tensor if pLo < pHi.
Value isNonEmpty = CMPI(ult, c0, pHi); Value isNonEmpty = CMPI(ult, pLo, pHi);
// The minimal coord must be at the first on ordered level. // The minimal coord must be at the first on ordered level.
// FIXME: Technically we should load the coord only when the slice is // FIXME: Technically we should load the coord only when the slice is
// nonempty. though we assume that even on empty sparse tensors, a non-empty // nonempty. though we assume that even on empty sparse tensors, a non-empty
// ptr/idx buffer is allocated for each level so it would not cause OOB to // ptr/idx buffer is allocated for each level so it would not cause OOB to
// avoid generating a ifOp here. // avoid generating a ifOp here.
Value minCrd = genIndexLoad(builder, loc, coordinatesBuffers[tid][0], c0); Value minCrd = genIndexLoad(builder, loc, coordinatesBuffers[tid][lvl], pLo);
PeimingAuthorUnsubmitted
Done
ReplyInline Actions

No idea why it did not cause any problem before ;-(

Peiming: No idea why it did not cause any problem before ;-(
aartbikUnsubmitted
Not Done
ReplyInline Actions

Yeah, surprising. But all is well now.

aartbik: Yeah, surprising. But all is well now.
// FIXME: We need the relative offset related to the base slice. // FIXME: We need the relative offset related to the base slice.
Value absOffset = offsetFromMinCoord(builder, loc, minCrd, size, isNonEmpty); Value absOffset = offsetFromMinCoord(builder, loc, minCrd, size, isNonEmpty);
sliceStack[tid].emplace_back(minCrd, absOffset, isNonEmpty, lvl, sliceStack[tid].emplace_back(minCrd, absOffset, isNonEmpty, lvl,
/*depth=*/1); /*depth=*/1);
} }
// Fills in the slicePosBuffer before slice-driven loop begin. // Fills in the slicePosBuffer before slice-driven loop begin.
▲ Show 20 Lines • Show All 408 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/CPU/reshape_dot.mlir

Show All 11 Lines
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils // DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void // DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs} // DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs} // DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
// //
// DEFINE: %{env} = // DEFINE: %{env} =
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
// UNSUPPORTED: target={{.*}}
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
▲ Show 20 Lines • Show All 170 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_conv_2d_nhwc_hwcf.mlir

Show All 32 Lines
#CCCC = #sparse_tensor.encoding<{ #CCCC = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed", "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed", "compressed", "compressed" ]
}> }>
#CDCD = #sparse_tensor.encoding<{ #CDCD = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "dense", "compressed", "dense" ] lvlTypes = [ "compressed", "dense", "compressed", "dense" ]
}> }>
#DCCD = #sparse_tensor.encoding<{
lvlTypes = [ "dense", "compressed", "compressed", "dense" ]
}>
// Creates and returns 4-D buffer of size (%s1, %s2, %s3, %s4) filled with the value %f // Creates and returns 4-D buffer of size (%s1, %s2, %s3, %s4) filled with the value %f
func.func @alloc_4d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %s4 : index, %f : f32) -> tensor<?x?x?x?xf32> { func.func @alloc_4d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %s4 : index, %f : f32) -> tensor<?x?x?x?xf32> {
%buf = bufferization.alloc_tensor(%s1, %s2, %s3, %s4) : tensor<?x?x?x?xf32> %buf = bufferization.alloc_tensor(%s1, %s2, %s3, %s4) : tensor<?x?x?x?xf32>
%ret = linalg.fill ins(%f : f32) outs(%buf : tensor<?x?x?x?xf32>) -> tensor<?x?x?x?xf32> %ret = linalg.fill ins(%f : f32) outs(%buf : tensor<?x?x?x?xf32>) -> tensor<?x?x?x?xf32>
return %ret : tensor<?x?x?x?xf32> return %ret : tensor<?x?x?x?xf32>
} }
func.func @conv_2d_nhwc_hwcf(%arg0: tensor<?x?x?x?xf32>, %arg1: tensor<?x?x?x?xf32>, %arg2: tensor<?x?x?x?xf32>) -> tensor<?x?x?x?xf32> { func.func @conv_2d_nhwc_hwcf(%arg0: tensor<?x?x?x?xf32>, %arg1: tensor<?x?x?x?xf32>, %arg2: tensor<?x?x?x?xf32>) -> tensor<?x?x?x?xf32> {
Show All 23 Linesfunc.func @conv_2d_nhwc_hwcf_CDCD(%arg0: tensor<?x?x?x?xf32, #CDCD>, %arg1: tensor<?x?x?x?xf32>) -> tensor<?x?x?x?xf32, #CDCD> {
%s = bufferization.alloc_tensor(%c3, %c6, %c6, %c1) : tensor<?x?x?x?xf32, #CDCD> %s = bufferization.alloc_tensor(%c3, %c6, %c6, %c1) : tensor<?x?x?x?xf32, #CDCD>
%ret = linalg.conv_2d_nhwc_hwcf {dilations = dense<1> : tensor<2xi64>, %ret = linalg.conv_2d_nhwc_hwcf {dilations = dense<1> : tensor<2xi64>,
strides = dense<1> : tensor<2xi64>} strides = dense<1> : tensor<2xi64>}
ins (%arg0, %arg1: tensor<?x?x?x?xf32, #CDCD>, tensor<?x?x?x?xf32>) ins (%arg0, %arg1: tensor<?x?x?x?xf32, #CDCD>, tensor<?x?x?x?xf32>)
outs (%s: tensor<?x?x?x?xf32, #CDCD>) -> tensor<?x?x?x?xf32, #CDCD> outs (%s: tensor<?x?x?x?xf32, #CDCD>) -> tensor<?x?x?x?xf32, #CDCD>
return %ret : tensor<?x?x?x?xf32, #CDCD> return %ret : tensor<?x?x?x?xf32, #CDCD>
} }
func.func @conv_2d_nhwc_hwcf_DCCD(%arg0: tensor<?x?x?x?xf32, #DCCD>, %arg1: tensor<?x?x?x?xf32>) -> tensor<?x?x?x?xf32, #DCCD> {
%c1 = arith.constant 1 : index
%c3 = arith.constant 3 : index
%c6 = arith.constant 6 : index
%s = bufferization.alloc_tensor(%c3, %c6, %c6, %c1) : tensor<?x?x?x?xf32, #DCCD>
%ret = linalg.conv_2d_nhwc_hwcf {dilations = dense<1> : tensor<2xi64>,
strides = dense<1> : tensor<2xi64>}
ins (%arg0, %arg1: tensor<?x?x?x?xf32, #DCCD>, tensor<?x?x?x?xf32>)
outs (%s: tensor<?x?x?x?xf32, #DCCD>) -> tensor<?x?x?x?xf32, #DCCD>
return %ret : tensor<?x?x?x?xf32, #DCCD>
}
func.func @entry() { func.func @entry() {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%c3 = arith.constant 3 : index %c3 = arith.constant 3 : index
%c6 = arith.constant 6 : index %c6 = arith.constant 6 : index
%c8 = arith.constant 8 : index %c8 = arith.constant 8 : index
%f10 = arith.constant 10.00000e+00 : f32 %f10 = arith.constant 10.00000e+00 : f32
%val = arith.constant 2.00000e+00 : f32 %val = arith.constant 2.00000e+00 : f32
%zero = arith.constant 0.00000e+00 : f32 %zero = arith.constant 0.00000e+00 : f32
%filter2D_nhwc = call @alloc_4d_filled_f32(%c3, %c3, %c3, %c1, %val) :(index, index, index, index, f32) -> (tensor<?x?x?x?xf32>) %filter2D_nhwc = call @alloc_4d_filled_f32(%c3, %c3, %c3, %c1, %val) :(index, index, index, index, f32) -> (tensor<?x?x?x?xf32>)
%in2D_tmp = call @alloc_4d_filled_f32(%c3, %c8, %c8, %c3, %val) : (index, index, index, index, f32) -> (tensor<?x?x?x?xf32>) %in2D_tmp = call @alloc_4d_filled_f32(%c3, %c8, %c8, %c3, %val) : (index, index, index, index, f32) -> (tensor<?x?x?x?xf32>)
%in2D_nhwc = tensor.insert %f10 into %in2D_tmp[%c0, %c0, %c3, %c0] : tensor<?x?x?x?xf32> %in2D_nhwc = tensor.insert %f10 into %in2D_tmp[%c0, %c0, %c3, %c0] : tensor<?x?x?x?xf32>
%out2D_nhwc = call @alloc_4d_filled_f32(%c3, %c6, %c6, %c1, %zero) : (index, index, index, index, f32) -> (tensor<?x?x?x?xf32>) %out2D_nhwc = call @alloc_4d_filled_f32(%c3, %c6, %c6, %c1, %zero) : (index, index, index, index, f32) -> (tensor<?x?x?x?xf32>)
%in2D_nhwc_CCCC = sparse_tensor.convert %in2D_nhwc %in2D_nhwc_CCCC = sparse_tensor.convert %in2D_nhwc
: tensor<?x?x?x?xf32> to tensor<?x?x?x?xf32, #CCCC> : tensor<?x?x?x?xf32> to tensor<?x?x?x?xf32, #CCCC>
%in2D_nhwc_CDCD = sparse_tensor.convert %in2D_nhwc %in2D_nhwc_CDCD = sparse_tensor.convert %in2D_nhwc
: tensor<?x?x?x?xf32> to tensor<?x?x?x?xf32, #CDCD> : tensor<?x?x?x?xf32> to tensor<?x?x?x?xf32, #CDCD>
%in2D_nhwc_DCCD = sparse_tensor.convert %in2D_nhwc
: tensor<?x?x?x?xf32> to tensor<?x?x?x?xf32, #DCCD>
%dense_ret = call @conv_2d_nhwc_hwcf(%in2D_nhwc, %filter2D_nhwc, %out2D_nhwc) : (tensor<?x?x?x?xf32>, tensor<?x?x?x?xf32>, tensor<?x?x?x?xf32>) -> (tensor<?x?x?x?xf32>) %dense_ret = call @conv_2d_nhwc_hwcf(%in2D_nhwc, %filter2D_nhwc, %out2D_nhwc) : (tensor<?x?x?x?xf32>, tensor<?x?x?x?xf32>, tensor<?x?x?x?xf32>) -> (tensor<?x?x?x?xf32>)
%CCCC_ret = call @conv_2d_nhwc_hwcf_CCCC(%in2D_nhwc_CCCC, %filter2D_nhwc) : (tensor<?x?x?x?xf32, #CCCC>, tensor<?x?x?x?xf32>) -> (tensor<?x?x?x?xf32, #CCCC>) %CCCC_ret = call @conv_2d_nhwc_hwcf_CCCC(%in2D_nhwc_CCCC, %filter2D_nhwc) : (tensor<?x?x?x?xf32, #CCCC>, tensor<?x?x?x?xf32>) -> (tensor<?x?x?x?xf32, #CCCC>)
%CDCD_ret = call @conv_2d_nhwc_hwcf_CDCD(%in2D_nhwc_CDCD, %filter2D_nhwc) : (tensor<?x?x?x?xf32, #CDCD>, tensor<?x?x?x?xf32>) -> (tensor<?x?x?x?xf32, #CDCD>) %CDCD_ret = call @conv_2d_nhwc_hwcf_CDCD(%in2D_nhwc_CDCD, %filter2D_nhwc) : (tensor<?x?x?x?xf32, #CDCD>, tensor<?x?x?x?xf32>) -> (tensor<?x?x?x?xf32, #CDCD>)
%DCCD_ret = call @conv_2d_nhwc_hwcf_DCCD(%in2D_nhwc_DCCD, %filter2D_nhwc) : (tensor<?x?x?x?xf32, #DCCD>, tensor<?x?x?x?xf32>) -> (tensor<?x?x?x?xf32, #DCCD>)
// CHECK: ( ( ( ( 108 ), ( 124 ), ( 124 ), ( 124 ), ( 108 ), ( 108 ) ), // CHECK: ( ( ( ( 108 ), ( 124 ), ( 124 ), ( 124 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ), // CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ), // CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ), // CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ), // CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ) ), // CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ) ),
// CHECK-SAME: ( ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ), // CHECK-SAME: ( ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Linesfunc.func @entry() {
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ), // CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ) ) ) // CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ) ) )
%2 = sparse_tensor.convert %CDCD_ret %2 = sparse_tensor.convert %CDCD_ret
: tensor<?x?x?x?xf32, #CDCD> to tensor<?x?x?x?xf32> : tensor<?x?x?x?xf32, #CDCD> to tensor<?x?x?x?xf32>
%v2 = vector.transfer_read %2[%c0, %c0, %c0, %c0], %zero %v2 = vector.transfer_read %2[%c0, %c0, %c0, %c0], %zero
: tensor<?x?x?x?xf32>, vector<3x6x6x1xf32> : tensor<?x?x?x?xf32>, vector<3x6x6x1xf32>
vector.print %v2 : vector<3x6x6x1xf32> vector.print %v2 : vector<3x6x6x1xf32>
// CHECK: ( ( ( ( 108 ), ( 124 ), ( 124 ), ( 124 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ) ),
// CHECK-SAME: ( ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ) ),
// CHECK-SAME: ( ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ),
// CHECK-SAME: ( ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ), ( 108 ) ) ) )
%3 = sparse_tensor.convert %DCCD_ret
: tensor<?x?x?x?xf32, #DCCD> to tensor<?x?x?x?xf32>
%v3 = vector.transfer_read %3[%c0, %c0, %c0, %c0], %zero
: tensor<?x?x?x?xf32>, vector<3x6x6x1xf32>
vector.print %v3 : vector<3x6x6x1xf32>
// Free the resources // Free the resources
bufferization.dealloc_tensor %in2D_nhwc : tensor<?x?x?x?xf32> bufferization.dealloc_tensor %in2D_nhwc : tensor<?x?x?x?xf32>
bufferization.dealloc_tensor %filter2D_nhwc : tensor<?x?x?x?xf32> bufferization.dealloc_tensor %filter2D_nhwc : tensor<?x?x?x?xf32>
bufferization.dealloc_tensor %out2D_nhwc : tensor<?x?x?x?xf32> bufferization.dealloc_tensor %out2D_nhwc : tensor<?x?x?x?xf32>
bufferization.dealloc_tensor %in2D_nhwc_CDCD : tensor<?x?x?x?xf32, #CDCD> bufferization.dealloc_tensor %in2D_nhwc_CDCD : tensor<?x?x?x?xf32, #CDCD>
bufferization.dealloc_tensor %in2D_nhwc_CCCC : tensor<?x?x?x?xf32, #CCCC> bufferization.dealloc_tensor %in2D_nhwc_CCCC : tensor<?x?x?x?xf32, #CCCC>
bufferization.dealloc_tensor %in2D_nhwc_DCCD : tensor<?x?x?x?xf32, #DCCD>
bufferization.dealloc_tensor %CCCC_ret : tensor<?x?x?x?xf32, #CCCC> bufferization.dealloc_tensor %CCCC_ret : tensor<?x?x?x?xf32, #CCCC>
bufferization.dealloc_tensor %CDCD_ret : tensor<?x?x?x?xf32, #CDCD> bufferization.dealloc_tensor %CDCD_ret : tensor<?x?x?x?xf32, #CDCD>
bufferization.dealloc_tensor %DCCD_ret : tensor<?x?x?x?xf32, #DCCD>
return return
} }