This is an archive of the discontinued LLVM Phabricator instance.

Differential D105731

[mlir][sparse] add restrictive versions of division support
ClosedPublic

Authored by aartbik on Jul 9 2021, 1:53 PM.

Details

Reviewers
bixia
penpornk
gussmith23
tatianashp
Commits
rG622eb169f650: [mlir][sparse] add restrictive versions of division support
Summary

Right now, we only accept x/c with nonzero c, since this
conceptually can be treated as a x*(1/c) conjunction for both
FP and INT as far as lattice computations go. The codegen
keeps the division though to preserve precise semantics.

See discussion:
https://llvm.discourse.group/t/sparse-tensors-in-mlir/3389/28

Diff Detail

Event Timeline

aartbik created this revision.Jul 9 2021, 1:53 PM
Herald added subscribers: dcaballe, cota, teijeong and 15 others. · View Herald TranscriptJul 9 2021, 1:53 PM
aartbik requested review of this revision.Jul 9 2021, 1:53 PM
Herald added a project: Restricted Project. · View Herald TranscriptJul 9 2021, 1:53 PM
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
aartbik added reviewers: bixia, penpornk, gussmith23, tatianashp.Jul 9 2021, 1:56 PM
aartbik updated this revision to Diff 357638.Jul 9 2021, 2:20 PM

extra table

Harbormaster completed remote builds in B113292: Diff 357638.Jul 9 2021, 4:16 PM
aartbik updated this revision to Diff 357694.Jul 9 2021, 9:02 PM

more compact if

Harbormaster completed remote builds in B113340: Diff 357694.Jul 9 2021, 9:32 PM
• post.kadirselcuk added a child revision: D34362: [LNT] Support for different DataSet usage in Polybench for "lnt runtest nt".Jul 10 2021, 5:55 PM
• post.kadirselcuk added a parent revision: D105762: [X86] Teach X86FloatingPoint's handleCall to only erase the FP stack if there is a regmask operand that clobbers the FP stack..Jul 10 2021, 8:06 PM
craig.topper removed a parent revision: D105762: [X86] Teach X86FloatingPoint's handleCall to only erase the FP stack if there is a regmask operand that clobbers the FP stack..Jul 10 2021, 9:47 PM
gussmith23 added inline comments.Jul 12 2021, 2:28 PM
mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp
357

Out of curiosity, any reason for the brackets here when you don't have them on the kMulI/kMulF cases?

mlir/test/Dialect/SparseTensor/sparse_int_ops.mlir
249

Is it possible to test the situations where we can't prove that the denominator is zero, and thus code can't be generated? At first I thought that could go in invalid.mlir, but it doesn't seem like that would be the right place.

aartbik marked 2 inline comments as done.Jul 12 2021, 2:33 PM
aartbik added inline comments.
mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp
357

ah, left over from when I had a local. Thanks. Removed!

mlir/test/Dialect/SparseTensor/sparse_int_ops.mlir
249

Not easy with the CHECK, but it will become possible with your unit test!

aartbik updated this revision to Diff 358071.Jul 12 2021, 2:38 PM
aartbik marked 2 inline comments as done.

removed braces

gussmith23 accepted this revision.Jul 12 2021, 2:42 PM

This looks good to me!

This revision is now accepted and ready to land.Jul 12 2021, 2:42 PM
This revision was landed with ongoing or failed builds.Jul 12 2021, 3:00 PM
Closed by commit rG622eb169f650: [mlir][sparse] add restrictive versions of division support (authored by aartbik). · Explain Why
This revision was automatically updated to reflect the committed changes.
aartbik added a commit: rG622eb169f650: [mlir][sparse] add restrictive versions of division support.
Harbormaster completed remote builds in B113595: Diff 358071.Jul 12 2021, 3:52 PM
efriedma removed a child revision: D34362: [LNT] Support for different DataSet usage in Polybench for "lnt runtest nt".Jul 17 2021, 3:02 PM

Revision Contents

PathSize
mlir/
include/
mlir/
Dialect/
SparseTensor/
Utils/
5 lines
lib/
Dialect/
SparseTensor/
Transforms/
6 lines
Utils/
55 lines
test/
Dialect/
SparseTensor/
44 lines
77 lines

Diff 358077

mlir/include/mlir/Dialect/SparseTensor/Utils/Merger.h

Show All 26 Lines
enum class Kind { enum class Kind {
// Leaf. // Leaf.
kTensor, kTensor,
kInvariant, kInvariant,
kZero, kZero,
// Operation. // Operation.
kMulF, kMulF,
kMulI, kMulI,
kDivF,
kDivS, // signed
kDivU, // unsigned
kAddF, kAddF,
kAddI, kAddI,
kSubF, kSubF,
kSubI kSubI
}; };
/// Children subexpressions of tensor operations. /// Children subexpressions of tensor operations.
struct Children { struct Children {
▲ Show 20 Lines • Show All 149 Lines • ▼ Show 20 Lines#endif
/// Returns index of the root expression. /// Returns index of the root expression.
unsigned buildLattices(unsigned exp, unsigned idx); unsigned buildLattices(unsigned exp, unsigned idx);
/// Builds a tensor expression from the given Linalg operation. /// Builds a tensor expression from the given Linalg operation.
/// Returns index of the root expression on success. /// Returns index of the root expression on success.
Optional<unsigned> buildTensorExpFromLinalg(linalg::GenericOp op); Optional<unsigned> buildTensorExpFromLinalg(linalg::GenericOp op);
private: private:
bool maybeZero(unsigned e);
/// Traverses the SSA tree (possibly a DAG) to build a tensor expression. /// Traverses the SSA tree (possibly a DAG) to build a tensor expression.
Optional<unsigned> buildTensorExp(linalg::GenericOp op, Value val); Optional<unsigned> buildTensorExp(linalg::GenericOp op, Value val);
const unsigned outTensor; const unsigned outTensor;
const unsigned syntheticTensor; const unsigned syntheticTensor;
const unsigned numTensors; const unsigned numTensors;
const unsigned numLoops; const unsigned numLoops;
Show All 10 Lines

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

Show First 20 Lines • Show All 640 Lines • ▼ Show 20 Linesstatic Value genExp(Merger &merger, CodeGen &codegen, PatternRewriter &rewriter,
case Kind::kTensor: case Kind::kTensor:
case Kind::kInvariant: case Kind::kInvariant:
case Kind::kZero: case Kind::kZero:
llvm_unreachable("handled above"); llvm_unreachable("handled above");
case Kind::kMulF: case Kind::kMulF:
return rewriter.create<MulFOp>(loc, v0, v1); return rewriter.create<MulFOp>(loc, v0, v1);
case Kind::kMulI: case Kind::kMulI:
return rewriter.create<MulIOp>(loc, v0, v1); return rewriter.create<MulIOp>(loc, v0, v1);
case Kind::kDivF:
return rewriter.create<DivFOp>(loc, v0, v1);
case Kind::kDivS:
return rewriter.create<SignedDivIOp>(loc, v0, v1);
case Kind::kDivU:
return rewriter.create<UnsignedDivIOp>(loc, v0, v1);
case Kind::kAddF: case Kind::kAddF:
return rewriter.create<AddFOp>(loc, v0, v1); return rewriter.create<AddFOp>(loc, v0, v1);
case Kind::kAddI: case Kind::kAddI:
return rewriter.create<AddIOp>(loc, v0, v1); return rewriter.create<AddIOp>(loc, v0, v1);
case Kind::kSubF: case Kind::kSubF:
return rewriter.create<SubFOp>(loc, v0, v1); return rewriter.create<SubFOp>(loc, v0, v1);
case Kind::kSubI: case Kind::kSubI:
return rewriter.create<SubIOp>(loc, v0, v1); return rewriter.create<SubIOp>(loc, v0, v1);
▲ Show 20 Lines • Show All 569 Lines • Show Last 20 Lines

mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp

Show First 20 Lines • Show All 195 Lines • ▼ Show 20 Lines
// Print methods (for debugging). // Print methods (for debugging).
// //
static char kindToOpSymbol(Kind kind) { static char kindToOpSymbol(Kind kind) {
switch (kind) { switch (kind) {
case Kind::kMulF: case Kind::kMulF:
case Kind::kMulI: case Kind::kMulI:
return '*'; return '*';
case Kind::kDivF:
case Kind::kDivS:
case Kind::kDivU:
return '/';
case Kind::kAddF: case Kind::kAddF:
case Kind::kAddI: case Kind::kAddI:
return '+'; return '+';
case Kind::kSubF: case Kind::kSubF:
case Kind::kSubI: case Kind::kSubI:
return '-'; return '-';
default: default:
break; break;
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines case Kind::kZero: {
// is set to a synthetic tensor with undefined indices only. // is set to a synthetic tensor with undefined indices only.
unsigned s = addSet(); unsigned s = addSet();
unsigned t = kind == Kind::kTensor ? tensorExps[e].tensor : syntheticTensor; unsigned t = kind == Kind::kTensor ? tensorExps[e].tensor : syntheticTensor;
latSets[s].push_back(addLat(t, idx, e)); latSets[s].push_back(addLat(t, idx, e));
return s; return s;
} }
case Kind::kMulF: case Kind::kMulF:
case Kind::kMulI: case Kind::kMulI:
// A multiplicative operation only needs to be performed
// for the conjunction of sparse iteration spaces.
//
// x*y|!y | y |
// ---+---+---+
// !x | 0 | 0 |
// x | 0 |x*y|
return takeConj(kind, // take binary conjunction
buildLattices(tensorExps[e].children.e0, idx),
buildLattices(tensorExps[e].children.e1, idx));
case Kind::kDivF:
case Kind::kDivS:
case Kind::kDivU:
// A division is tricky, since 0/0, 0/c, c/0 all have
// specific outcomes for floating-point and integers.
// Thus, we need to traverse the full iteration space.
//
// x/y|!y | y |
// ---+---+---+
// !x |0/0|0/y| FP: 0/0=NaN,c/0=Inf,0/c=0 with c true nonzero
// x |x/0|x/y| INT: x/0=exception for any x
//
// TODO: for now we "fixed" this by only accepting x/c cases
// during expression building, so that the conjunction
// rules applies (viz. x/c = x*(1/c) as far as lattice
// construction is concerned).
return takeConj(kind, // take binary conjunction return takeConj(kind, // take binary conjunction
buildLattices(tensorExps[e].children.e0, idx), buildLattices(tensorExps[e].children.e0, idx),
buildLattices(tensorExps[e].children.e1, idx)); buildLattices(tensorExps[e].children.e1, idx));
case Kind::kSubF: case Kind::kSubF:
case Kind::kSubI: case Kind::kSubI:
// Special case: 0-y is -y.
if (tensorExps[tensorExps[e].children.e0].kind == Kind::kZero) if (tensorExps[tensorExps[e].children.e0].kind == Kind::kZero)
return mapZero(kind, // maps to 0-y with just y's lattices return mapZero(kind, // maps to 0-y with just y's lattices
buildLattices(tensorExps[e].children.e1, idx)); buildLattices(tensorExps[e].children.e1, idx));
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
case Kind::kAddF: case Kind::kAddF:
case Kind::kAddI: case Kind::kAddI:
// An additive operation needs to be performed
// for the disjunction of sparse iteration spaces.
//
// x+y|!y | y | x-y|!y | y |
// ---+---+---+ ---+---+---+
// !x | 0 | y | !x | 0 |-y |
// x | x |x+y| x | x |x-y|
return takeDisj(kind, // take binary disjunction return takeDisj(kind, // take binary disjunction
buildLattices(tensorExps[e].children.e0, idx), buildLattices(tensorExps[e].children.e0, idx),
buildLattices(tensorExps[e].children.e1, idx)); buildLattices(tensorExps[e].children.e1, idx));
} }
gussmith23Unsubmitted
Done
ReplyInline Actions

Out of curiosity, any reason for the brackets here when you don't have them on the kMulI/kMulF cases?

gussmith23: Out of curiosity, any reason for the brackets here when you don't have them on the…
aartbikAuthorUnsubmitted
Done
ReplyInline Actions

ah, left over from when I had a local. Thanks. Removed!

aartbik: ah, left over from when I had a local. Thanks. Removed!
llvm_unreachable("unexpected expression kind"); llvm_unreachable("unexpected expression kind");
} }
Optional<unsigned> Merger::buildTensorExpFromLinalg(linalg::GenericOp op) { Optional<unsigned> Merger::buildTensorExpFromLinalg(linalg::GenericOp op) {
Operation *yield = op.region().front().getTerminator(); Operation *yield = op.region().front().getTerminator();
return buildTensorExp(op, yield->getOperand(0)); return buildTensorExp(op, yield->getOperand(0));
} }
bool Merger::maybeZero(unsigned e) {
if (tensorExps[e].kind == Kind::kInvariant) {
if (auto c = tensorExps[e].val.getDefiningOp<ConstantIntOp>())
return c.getValue() == 0;
if (auto c = tensorExps[e].val.getDefiningOp<ConstantFloatOp>())
return c.getValue().isZero();
}
return true;
}
Optional<unsigned> Merger::buildTensorExp(linalg::GenericOp op, Value val) { Optional<unsigned> Merger::buildTensorExp(linalg::GenericOp op, Value val) {
if (auto arg = val.dyn_cast<BlockArgument>()) { if (auto arg = val.dyn_cast<BlockArgument>()) {
unsigned argN = arg.getArgNumber(); unsigned argN = arg.getArgNumber();
// Any argument of the generic op that is not marked as a scalar // Any argument of the generic op that is not marked as a scalar
// argument is considered a tensor, indexed by the implicit loop // argument is considered a tensor, indexed by the implicit loop
// bounds. This includes rank-0 tensor arguments. // bounds. This includes rank-0 tensor arguments.
if (arg.getOwner()->getParentOp() == op) { if (arg.getOwner()->getParentOp() == op) {
OpOperand *t = op.getInputAndOutputOperands()[argN]; OpOperand *t = op.getInputAndOutputOperands()[argN];
Show All 16 Lines if (x.hasValue()) {
unsigned e0 = addExp(Kind::kZero); unsigned e0 = addExp(Kind::kZero);
unsigned e1 = x.getValue(); unsigned e1 = x.getValue();
if (isa<NegFOp>(def)) if (isa<NegFOp>(def))
return addExp(Kind::kSubF, e0, e1); return addExp(Kind::kSubF, e0, e1);
// TODO: no negi in std? // TODO: no negi in std?
} }
} }
// Construct binary operations if subexpressions can be built. // Construct binary operations if subexpressions can be built.
// TODO: see buildLattices() for an explanation of rejecting certain divisions
if (def->getNumOperands() == 2) { if (def->getNumOperands() == 2) {
auto x = buildTensorExp(op, def->getOperand(0)); auto x = buildTensorExp(op, def->getOperand(0));
auto y = buildTensorExp(op, def->getOperand(1)); auto y = buildTensorExp(op, def->getOperand(1));
if (x.hasValue() && y.hasValue()) { if (x.hasValue() && y.hasValue()) {
unsigned e0 = x.getValue(); unsigned e0 = x.getValue();
unsigned e1 = y.getValue(); unsigned e1 = y.getValue();
if (isa<MulFOp>(def)) if (isa<MulFOp>(def))
return addExp(Kind::kMulF, e0, e1); return addExp(Kind::kMulF, e0, e1);
if (isa<MulIOp>(def)) if (isa<MulIOp>(def))
return addExp(Kind::kMulI, e0, e1); return addExp(Kind::kMulI, e0, e1);
if (isa<DivFOp>(def) && !maybeZero(e1))
return addExp(Kind::kDivF, e0, e1);
if (isa<SignedDivIOp>(def) && !maybeZero(e1))
return addExp(Kind::kDivS, e0, e1);
if (isa<UnsignedDivIOp>(def) && !maybeZero(e1))
return addExp(Kind::kDivU, e0, e1);
if (isa<AddFOp>(def)) if (isa<AddFOp>(def))
return addExp(Kind::kAddF, e0, e1); return addExp(Kind::kAddF, e0, e1);
if (isa<AddIOp>(def)) if (isa<AddIOp>(def))
return addExp(Kind::kAddI, e0, e1); return addExp(Kind::kAddI, e0, e1);
if (isa<SubFOp>(def)) if (isa<SubFOp>(def))
return addExp(Kind::kSubF, e0, e1); return addExp(Kind::kSubF, e0, e1);
if (isa<SubIOp>(def)) if (isa<SubIOp>(def))
return addExp(Kind::kSubI, e0, e1); return addExp(Kind::kSubI, e0, e1);
} }
} }
// Cannot build. // Cannot build.
return None; return None;
} }
} // namespace sparse_tensor } // namespace sparse_tensor
} // namespace mlir } // namespace mlir

mlir/test/Dialect/SparseTensor/sparse_fp_ops.mlir

Show All 16 Lines indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)>, // b affine_map<(i) -> (i)>, // b
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
doc = "x(i) = a(i) OP b(i)" doc = "x(i) = a(i) OP b(i)"
} }
#traitc = {
indexing_maps = [
affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)> // x (out)
],
iterator_types = ["parallel"],
doc = "x(i) = a(i) OP c"
}
// CHECK-LABEL: func @neg( // CHECK-LABEL: func @neg(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf64, #sparse_tensor.encoding<{{{.*}}}>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf64, #sparse_tensor.encoding<{{{.*}}}>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf64> {linalg.inplaceable = true}) -> tensor<32xf64> { // CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf64> {linalg.inplaceable = true}) -> tensor<32xf64> {
// CHECK: %[[VAL_2:.*]] = constant 0 : index // CHECK: %[[VAL_2:.*]] = constant 0 : index
// CHECK: %[[VAL_3:.*]] = constant 1 : index // CHECK: %[[VAL_3:.*]] = constant 1 : index
// CHECK: %[[VAL_4:.*]] = constant 0.000000e+00 : f64 // CHECK: %[[VAL_4:.*]] = constant 0.000000e+00 : f64
// CHECK: %[[VAL_5:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_2]] : tensor<32xf64, #sparse_tensor.encoding<{{{.*}}}>> // CHECK: %[[VAL_5:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_2]] : tensor<32xf64, #sparse_tensor.encoding<{{{.*}}}>>
// CHECK: %[[VAL_6:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_2]] : tensor<32xf64, #sparse_tensor.encoding<{{{.*}}}>> // CHECK: %[[VAL_6:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_2]] : tensor<32xf64, #sparse_tensor.encoding<{{{.*}}}>>
▲ Show 20 Lines • Show All 175 Lines • ▼ Show 20 Lines %0 = linalg.generic #trait2
ins(%arga, %argb: tensor<32xf64, #SV>, tensor<32xf64>) ins(%arga, %argb: tensor<32xf64, #SV>, tensor<32xf64>)
outs(%argx: tensor<32xf64>) { outs(%argx: tensor<32xf64>) {
^bb(%a: f64, %b: f64, %x: f64): ^bb(%a: f64, %b: f64, %x: f64):
%0 = mulf %a, %b : f64 %0 = mulf %a, %b : f64
linalg.yield %0 : f64 linalg.yield %0 : f64
} -> tensor<32xf64> } -> tensor<32xf64>
return %0 : tensor<32xf64> return %0 : tensor<32xf64>
} }
// CHECK-LABEL: func @divbyc(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf64, #sparse_tensor.encoding<{{{.*}}}>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf64> {linalg.inplaceable = true}) -> tensor<32xf64> {
// CHECK: %[[VAL_2:.*]] = constant 2.000000e+00 : f64
// CHECK: %[[VAL_3:.*]] = constant 0 : index
// CHECK: %[[VAL_4:.*]] = constant 1 : index
// CHECK: %[[VAL_5:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_3]] : tensor<32xf64, #sparse_tensor.encoding<{{{.*}}}>>
// CHECK: %[[VAL_6:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_3]] : tensor<32xf64, #sparse_tensor.encoding<{{{.*}}}>>
// CHECK: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf64, #sparse_tensor.encoding<{{{.*}}}>>
// CHECK: %[[VAL_8:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32xf64>
// CHECK: %[[VAL_9:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_11:.*]] = %[[VAL_9]] to %[[VAL_10]] step %[[VAL_4]] {
// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_11]]] : memref<?xindex>
// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_11]]] : memref<?xf64>
// CHECK: %[[VAL_14:.*]] = divf %[[VAL_13]], %[[VAL_2]] : f64
// CHECK: memref.store %[[VAL_14]], %[[VAL_8]]{{\[}}%[[VAL_12]]] : memref<32xf64>
// CHECK: }
// CHECK: %[[VAL_15:.*]] = memref.tensor_load %[[VAL_8]] : memref<32xf64>
// CHECK: return %[[VAL_15]] : tensor<32xf64>
// CHECK: }
func @divbyc(%arga: tensor<32xf64, #SV>,
%argx: tensor<32xf64> {linalg.inplaceable = true}) -> tensor<32xf64> {
%c = constant 2.0 : f64
%0 = linalg.generic #traitc
ins(%arga: tensor<32xf64, #SV>)
outs(%argx: tensor<32xf64>) {
^bb(%a: f64, %x: f64):
%0 = divf %a, %c : f64
linalg.yield %0 : f64
} -> tensor<32xf64>
return %0 : tensor<32xf64>
}

mlir/test/Dialect/SparseTensor/sparse_int_ops.mlir

// NOTE: Assertions have been autogenerated by utils/generate-test-checks.py // NOTE: Assertions have been autogenerated by utils/generate-test-checks.py
// RUN: mlir-opt %s -sparsification | FileCheck %s // RUN: mlir-opt %s -sparsification | FileCheck %s
#SV = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SV = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>
#trait2 = { #trait2 = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)>, // b affine_map<(i) -> (i)>, // b
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
doc = "x(i) = a(i) OP b(i)" doc = "x(i) = a(i) OP b(i)"
} }
#traitc = {
indexing_maps = [
affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)> // x (out)
],
iterator_types = ["parallel"],
doc = "x(i) = a(i) OP c"
}
// CHECK-LABEL: func @add( // CHECK-LABEL: func @add(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xi64, #sparse_tensor.encoding<{{{.*}}}>>, // CHECK-SAME: %[[VAL_0:.*]]: tensor<32xi64, #sparse_tensor.encoding<{{{.*}}}>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xi64>, // CHECK-SAME: %[[VAL_1:.*]]: tensor<32xi64>,
// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xi64> {linalg.inplaceable = true}) -> tensor<32xi64> { // CHECK-SAME: %[[VAL_2:.*]]: tensor<32xi64> {linalg.inplaceable = true}) -> tensor<32xi64> {
// CHECK: %[[VAL_3:.*]] = constant 32 : index // CHECK: %[[VAL_3:.*]] = constant 32 : index
// CHECK: %[[VAL_4:.*]] = constant 0 : index // CHECK: %[[VAL_4:.*]] = constant 0 : index
// CHECK: %[[VAL_5:.*]] = constant true // CHECK: %[[VAL_5:.*]] = constant true
// CHECK: %[[VAL_6:.*]] = constant 1 : index // CHECK: %[[VAL_6:.*]] = constant 1 : index
▲ Show 20 Lines • Show All 142 Lines • ▼ Show 20 Lines %0 = linalg.generic #trait2
ins(%arga, %argb: tensor<32xi64, #SV>, tensor<32xi64>) ins(%arga, %argb: tensor<32xi64, #SV>, tensor<32xi64>)
outs(%argx: tensor<32xi64>) { outs(%argx: tensor<32xi64>) {
^bb(%a: i64, %b: i64, %x: i64): ^bb(%a: i64, %b: i64, %x: i64):
%0 = muli %a, %b : i64 %0 = muli %a, %b : i64
linalg.yield %0 : i64 linalg.yield %0 : i64
} -> tensor<32xi64> } -> tensor<32xi64>
return %0 : tensor<32xi64> return %0 : tensor<32xi64>
} }
// CHECK-LABEL: func @divsbyc(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xi64, #sparse_tensor.encoding<{{{.*}}}>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xi64> {linalg.inplaceable = true}) -> tensor<32xi64> {
// CHECK: %[[VAL_2:.*]] = constant 2 : i64
// CHECK: %[[VAL_3:.*]] = constant 0 : index
// CHECK: %[[VAL_4:.*]] = constant 1 : index
// CHECK: %[[VAL_5:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_3]] : tensor<32xi64, #sparse_tensor.encoding<{{{.*}}}>>
// CHECK: %[[VAL_6:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_3]] : tensor<32xi64, #sparse_tensor.encoding<{{{.*}}}>>
// CHECK: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xi64, #sparse_tensor.encoding<{{{.*}}}>>
// CHECK: %[[VAL_8:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32xi64>
// CHECK: %[[VAL_9:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_11:.*]] = %[[VAL_9]] to %[[VAL_10]] step %[[VAL_4]] {
// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_11]]] : memref<?xindex>
// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_11]]] : memref<?xi64>
// CHECK: %[[VAL_14:.*]] = divi_signed %[[VAL_13]], %[[VAL_2]] : i64
// CHECK: memref.store %[[VAL_14]], %[[VAL_8]]{{\[}}%[[VAL_12]]] : memref<32xi64>
// CHECK: }
// CHECK: %[[VAL_15:.*]] = memref.tensor_load %[[VAL_8]] : memref<32xi64>
// CHECK: return %[[VAL_15]] : tensor<32xi64>
// CHECK: }
func @divsbyc(%arga: tensor<32xi64, #SV>,
%argx: tensor<32xi64> {linalg.inplaceable = true}) -> tensor<32xi64> {
%c = constant 2 : i64
%0 = linalg.generic #traitc
ins(%arga: tensor<32xi64, #SV>)
outs(%argx: tensor<32xi64>) {
^bb(%a: i64, %x: i64):
%0 = divi_signed %a, %c : i64
linalg.yield %0 : i64
} -> tensor<32xi64>
return %0 : tensor<32xi64>
}
// CHECK-LABEL: func @divubyc(
// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xi64, #sparse_tensor.encoding<{{{.*}}}>>,
// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xi64> {linalg.inplaceable = true}) -> tensor<32xi64> {
// CHECK: %[[VAL_2:.*]] = constant 2 : i64
// CHECK: %[[VAL_3:.*]] = constant 0 : index
// CHECK: %[[VAL_4:.*]] = constant 1 : index
// CHECK: %[[VAL_5:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_3]] : tensor<32xi64, #sparse_tensor.encoding<{{.*}}}>>
// CHECK: %[[VAL_6:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_3]] : tensor<32xi64, #sparse_tensor.encoding<{{{.*}}}>>
// CHECK: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xi64, #sparse_tensor.encoding<{{{.*}}}>>
// CHECK: %[[VAL_8:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32xi64>
// CHECK: %[[VAL_9:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
// CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
// CHECK: scf.for %[[VAL_11:.*]] = %[[VAL_9]] to %[[VAL_10]] step %[[VAL_4]] {
// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_11]]] : memref<?xindex>
// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_11]]] : memref<?xi64>
// CHECK: %[[VAL_14:.*]] = divi_unsigned %[[VAL_13]], %[[VAL_2]] : i64
// CHECK: memref.store %[[VAL_14]], %[[VAL_8]]{{\[}}%[[VAL_12]]] : memref<32xi64>
// CHECK: }
// CHECK: %[[VAL_15:.*]] = memref.tensor_load %[[VAL_8]] : memref<32xi64>
// CHECK: return %[[VAL_15]] : tensor<32xi64>
// CHECK: }
func @divubyc(%arga: tensor<32xi64, #SV>,
%argx: tensor<32xi64> {linalg.inplaceable = true}) -> tensor<32xi64> {
%c = constant 2 : i64
%0 = linalg.generic #traitc
ins(%arga: tensor<32xi64, #SV>)
outs(%argx: tensor<32xi64>) {
^bb(%a: i64, %x: i64):
%0 = divi_unsigned %a, %c : i64
linalg.yield %0 : i64
} -> tensor<32xi64>
return %0 : tensor<32xi64>
gussmith23Unsubmitted
Done
ReplyInline Actions

Is it possible to test the situations where we can't prove that the denominator is zero, and thus code can't be generated? At first I thought that could go in invalid.mlir, but it doesn't seem like that would be the right place.

gussmith23: Is it possible to test the situations where we can't prove that the denominator is zero, and…
aartbikAuthorUnsubmitted
Done
ReplyInline Actions

Not easy with the CHECK, but it will become possible with your unit test!

aartbik: Not easy with the CHECK, but it will become possible with your unit test!
}