[mlir] Delete most of the ops from the quant dialect.

* https://discourse.llvm.org/t/rfc-removing-the-quant-dialect/3643/8
* Removes most ops. Leaves casts given final comment (can remove more in a followup).
* There are a few uses in Tosa keeping some of the utilities alive. In a followup, I will probably elect to just move simplified versions of them into Tosa itself vs having this quasi-library dependency.

Differential Revision: https://reviews.llvm.org/D120204

Author: stellaraccident

mlir/include/mlir/Dialect/Quant/CMakeLists.txt

@@ -1,8 +1,2 @@
 add_mlir_dialect(QuantOps quant)
 add_mlir_doc(QuantOps QuantDialect Dialects/ -gen-dialect-doc)
-
-set(LLVM_TARGET_DEFINITIONS Passes.td)
-mlir_tablegen(Passes.h.inc -gen-pass-decls -name Quant)
-add_public_tablegen_target(MLIRQuantPassIncGen)
-
-add_mlir_doc(Passes QuantPasses ./ -gen-pass-doc)

mlir/include/mlir/Dialect/Quant/Passes.h

@@ -84,170 +84,4 @@ def quant_StorageCastOp : quant_Op<"scast", [NoSideEffect]> {
   let hasFolder = 1;
 }
 
-// A QuantizeRegion (region) represents a quantization unit which wraps
-// high-precision ops with quantization specifications for all the inputs
-// and outputs. Some quantization specifications can be undetermined and
-// derived from other ports by the target specification of the kernel.
-def quant_QuantizeRegionOp : quant_Op<"region", [
-    NoSideEffect,
-    IsolatedFromAbove,
-    SingleBlockImplicitTerminator<"ReturnOp">]> {
-  let summary = [{
-    The `region` operation wraps high-precision ops as a logical low-precision
-    quantized kernel.
-  }];
-
-  let arguments = (ins Variadic<AnyType>:$inputs,
-                    TypeArrayAttr:$input_specs,
-                    TypeArrayAttr:$output_specs,
-                    StrAttr:$logical_kernel);
-  let results = (outs Variadic<AnyType>:$outputs);
-  let regions = (region SizedRegion<1>:$body);
-  let hasVerifier = 1;
-}
-
-def quant_ReturnOp : quant_Op<"return", [Terminator]> {
-  let summary = [{
-    The `return` operation terminates a quantize region and returns values.
-  }];
-
-  let arguments = (ins Variadic<AnyTensor>:$results);
-}
-
-//===----------------------------------------------------------------------===//
-// Training integration and instrumentation ops
-//===----------------------------------------------------------------------===//
-
-def quant_ConstFakeQuant : quant_Op<"const_fake_quant",
-                                    [SameOperandsAndResultType, NoSideEffect]> {
-  let summary = [{
-    Simulates the effect of uniform quantization with const range.
-  }];
-
-  let description = [{
-    Given a const min, max, num_bits and narrow_range attribute, applies the
-    same uniform quantization simulation as is done by the TensorFlow
-    fake_quant_with_min_max_args op. See the fakeQuantAttrsToType() utility
-    method and the quant-convert-simulated-quantization pass for further details.
-  }];
-
-  let arguments = (ins
-    F32Tensor:$inputs,
-    F32Attr:$min,
-    F32Attr:$max,
-    // The bitwidth of the quantization; between 2 and 16, inclusive.
-    I64Attr:$num_bits,
-    // Quantization range starts from 0 or 1; starts from 1 if true.
-    DefaultValuedAttr<BoolAttr, "false">:$narrow_range,
-    // The sign of the quantization.
-    DefaultValuedAttr<BoolAttr, "false">:$is_signed
-  );
-
-  let results = (outs
-    F32Tensor:$outputs
-  );
-}
-
-def quant_ConstFakeQuantPerAxis : quant_Op<"const_fake_quant_per_axis",
-                                    [SameOperandsAndResultType, NoSideEffect]> {
-  let summary = [{
-    Simulates the effect of per axis uniform quantization with const range.
-  }];
-
-  let description = [{
-    Given a const min, max, num_bits and narrow_range attribute, applies the
-    same per axis uniform quantization simulation as is done by the TensorFlow
-    fake_quant_with_min_max_vars_per_channel op. See the fakeQuantAttrsToType()
-    utility method and the quant-convert-simulated-quantization pass for further
-    details.
-  }];
-
-  let arguments = (ins
-    F32Tensor:$inputs,
-    F32ArrayAttr:$min,
-    F32ArrayAttr:$max,
-    // The quantized dimension of the inputs tensor.
-    I64Attr:$axis,
-    // The bitwidth of the quantization; between 2 and 16, inclusive.
-    I64Attr:$num_bits,
-    // Quantization range starts from 0 or 1; starts from 1 if true.
-    DefaultValuedAttr<BoolAttr, "false">:$narrow_range,
-    // The sign of the quantization.
-    DefaultValuedAttr<BoolAttr, "false">:$is_signed
-  );
-
-  let results = (outs
-    F32Tensor:$outputs
-  );
-}
-
-def quant_StatisticsRefOp : quant_Op<"stats_ref", [SameOperandsAndResultType]> {
-  let summary = "Indicates that statistics are resolved by reference.";
-
-  let description = [{
-    This op acts as an identity that, when encountered at runtime, should result
-    in statistics being collected about about the value of its operand/result.
-    Such statistics will be stored with the provided key, allowing this node
-    to later be converted to a 'stats' op if statistics with that key have been
-    encountered.
-  }];
-
-  let arguments = (ins
-    quant_RealValueType:$arg,
-    StrAttr:$statsKey
-  );
-  let results = (outs quant_RealValueType);
-}
-
-def quant_StatisticsOp : quant_Op<"stats", [SameOperandsAndResultType]> {
-  let summary = "Identity op which associates statistics with the value.";
-
-  let description = [{
-    Associates statistics about the runtime ranges of values observed for
-    evaluations of this node.
-
-    Statistics about the entire type are reported in the 'layerStats' attribute
-    and those for each axis, in the (optional) `axisStats` attribute. The
-    interpretation of each is determined by the last dimension of its shape.
-    Currently, only dim=2 is supported, which is interpreted as [min, max].
-
-    `layerStats` must be a rank 1 tensor: [2]
-    `axisStats` must be a rank 2 tensor: [N, 2], where N=the slice size
-      splitted by the `axis` dimension. For example:
-
-    ```
-    <?x?x3x2>, axis=3 => N=2
-    <?x?x3x2>, axis=2 => N=6
-    ```
-  }];
-
-  let arguments = (ins
-    quant_RealValueType:$arg,
-    ElementsAttr:$layerStats,
-    OptionalAttr<ElementsAttr>:$axisStats,
-    OptionalAttr<I64Attr>:$axis);
-  let results = (outs quant_RealValueType);
-  let hasVerifier = 1;
-}
-
-def quant_CoupledRefOp : quant_Op<"coupled_ref", [SameOperandsAndResultType]> {
-  let summary = [{
-    Indicates that one point of the computation is coupled to another.
-  }];
-
-  let description = [{
-    Ordinarily, relationships between ops for the purposes of determining
-    compatible quantized types is explicit based on the use-def chain. However,
-    in some situations, a use may be separated from its def by arbitrary
-    external connections. In such a case, during analysis, all coupled_ref
-    nodes in a module which share a coupledKey will be considered to be
-    directly connected as via an identity op for the purpose of type inference.
-  }];
-
-  let arguments = (ins
-    quant_RealValueType:$arg,
-    StrAttr:$coupledKey);
-  let results = (outs quant_RealValueType);
-}
-
 #endif // DIALECT_QUANT_QUANT_OPS_

mlir/include/mlir/Dialect/Quant/Passes.td

@@ -25,7 +25,6 @@
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/MemRef/Transforms/Passes.h"
 #include "mlir/Dialect/NVGPU/Passes.h"
-#include "mlir/Dialect/Quant/Passes.h"
 #include "mlir/Dialect/SCF/Transforms/Passes.h"
 #include "mlir/Dialect/SPIRV/Transforms/Passes.h"
 #include "mlir/Dialect/Shape/Transforms/Passes.h"
@@ -69,7 +68,6 @@ inline void registerAllPasses() {
   registerSparseTensorPasses();
   LLVM::registerLLVMPasses();
   memref::registerMemRefPasses();
-  quant::registerQuantPasses();
   registerSCFPasses();
   registerShapePasses();
   spirv::registerSPIRVPasses();

mlir/include/mlir/Dialect/Quant/QuantOps.td

@@ -1,3 +1,2 @@
 add_subdirectory(IR)
-add_subdirectory(Transforms)
 add_subdirectory(Utils)