llvm
/
torch-mlir
mirror of https://github.com/llvm/torch-mlir
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Revert "[MLIR][TORCH] Add E2E support for aten.ne.float_int op" 

This reverts commit 51dd462592.
pull/808/head
Sean Silva 2022-04-28 13:36:42 +00:00
parent 5ef9f501fa
commit 7669ee4e4a
5 changed files with 1 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
include/torch-mlir/Dialect/Torch/IR/GeneratedTorchOps.td
View File

@ -6667,30 +6667,6 @@ def Torch_AtenGeFloatIntOp : Torch_Op<"aten.ge.float_int", [
}];
}
def Torch_AtenNeFloatIntOp : Torch_Op<"aten.ne.float_int", [
AllowsTypeRefinement,
HasValueSemantics,
ReadOnly
]> {
let summary = "Generated op for `aten::ne.float_int : (float, int) -> (bool)`";
let arguments = (ins
Torch_FloatType:$a,
Torch_IntType:$b
);
let results = (outs
Torch_BoolType:$result
);
let hasCustomAssemblyFormat = 1;
let extraClassDefinition = [{
ParseResult AtenNeFloatIntOp::parse(OpAsmParser &parser, OperationState &result) {
return parseDefaultTorchOp(parser, result, 2, 1);
}
void AtenNeFloatIntOp::print(OpAsmPrinter &printer) {
printDefaultTorchOp(printer, *this, 2, 1);
}
}];
}
def Torch_Aten__And__BoolOp : Torch_Op<"aten.__and__.bool", [
AllowsTypeRefinement,
HasValueSemantics,

5
lib/Conversion/TorchToStd/TorchToStd.cpp
View File

@ -211,16 +211,13 @@ public:
patterns.add<
ConvertAtenIntComparisonOp<AtenGtIntOp, arith::CmpIPredicate::sgt>>(
typeConverter, context);
target.addIllegalOp<AtenGeFloatOp, AtenGeFloatIntOp, AtenNeFloatIntOp>();
target.addIllegalOp<AtenGeFloatOp, AtenGeFloatIntOp>();
patterns.add<
ConvertAtenFloatComparisonOp<AtenGeFloatOp, arith::CmpFPredicate::UGE>>(
typeConverter, context);
patterns.add<ConvertAtenFloatComparisonOp<AtenGeFloatIntOp,
arith::CmpFPredicate::UGE>>(
typeConverter, context);
patterns.add<ConvertAtenFloatComparisonOp<AtenNeFloatIntOp,
arith::CmpFPredicate::UNE>>(
typeConverter, context);
target.addIllegalOp<ValueTensorLiteralOp>();
patterns.add<ConvertTorchTensorLiteralOp>(typeConverter, context);

1
python/torch_mlir/dialects/torch/importer/jit_ir/build_tools/torch_ods_gen.py
View File

@ -498,7 +498,6 @@ def emit_ops(emitter_td: TextEmitter, registry: Registry):
emit("aten::lt.float : (float, float) -> (bool)", has_folder=True)
emit("aten::lt.float_int : (float, int) -> (bool)")
emit("aten::ge.float_int : (float, int) -> (bool)")
emit("aten::ne.float_int : (float, int) -> (bool)")
emit("aten::__and__.bool : (bool, bool) -> (bool)")
emit("aten::ne.bool : (bool, bool) -> (bool)", has_folder=True)
emit("aten::__is__ : (t1, t2) -> (bool)", has_folder=True)

20
python/torch_mlir_e2e_test/test_suite/scalar_comparison.py
View File

@ -108,23 +108,3 @@ class GeFloatIntModule(torch.nn.Module):
@register_test_case(module_factory=lambda: GeFloatIntModule())
def GeFloatIntModule_basic(module, tu: TestUtils):
module.forward(torch.randn(()), torch.randint(-100, 100, ()))
# ==============================================================================
class NeFloatIntModule(torch.nn.Module):
def __init__(self):
super().__init__()
@export
@annotate_args([
None,
([], torch.float64, True),
([], torch.int64, True),
])
def forward(self, lhs, rhs):
return float(lhs) != int(rhs)
@register_test_case(module_factory=lambda: NeFloatIntModule())
def NeFloatIntModule_basic(module, tu: TestUtils):
module.forward(torch.randn(()), torch.randint(-100, 100, ()))

14
test/Conversion/TorchToStd/basic.mlir
View File

@ -193,17 +193,3 @@ func @torch.aten.ge.float_int(%arg0: !torch.float, %arg1: !torch.int) -> !torch.
%0 = torch.aten.ge.float_int %arg0, %arg1 : !torch.float, !torch.int -> !torch.bool
return %0 : !torch.bool
}
// CHECK-LABEL: func @torch.aten.ne.float_int(
// CHECK-SAME: %[[LHS:.*]]: !torch.float,
// CHECK-SAME: %[[RHS:.*]]: !torch.int) -> !torch.bool {
// CHECK: %[[LHS_F64:.*]] = torch_c.to_f64 %[[LHS]]
// CHECK: %[[RHS_I64:.*]] = torch_c.to_i64 %[[RHS]]
// CHECK: %[[RHS_F64:.*]] = arith.sitofp %[[RHS_I64]] : i64 to f64
// CHECK: %[[CMP:.*]] = arith.cmpf une, %[[LHS_F64]], %[[RHS_F64]] : f64
// CHECK: %[[CMP_TORCH_BOOL:.*]] = torch_c.from_i1 %[[CMP]]
// CHECK: return %[[CMP_TORCH_BOOL]] : !torch.bool
func @torch.aten.ne.float_int(%arg0: !torch.float, %arg1: !torch.int) -> !torch.bool {
%0 = torch.aten.ne.float_int %arg0, %arg1 : !torch.float, !torch.int -> !torch.bool
return %0 : !torch.bool
}