Renamed to QuantStorageTypeInterface and removed redundant dyn_cast checks

Author: Roman-Pevnyi

mlir/include/mlir/IR/BuiltinTypes.h

@@ -167,7 +167,7 @@ class BaseMemRefType : public Type,
 // Tablegen Type Declarations
 //===----------------------------------------------------------------------===//
 
-#include "mlir/IR/QuantizationInterface.h"
+#include "mlir/IR/QuantStorageTypeInterface.h"
 
 #define GET_TYPEDEF_CLASSES
 #include "mlir/IR/BuiltinTypes.h.inc"

mlir/include/mlir/IR/BuiltinTypes.td

@@ -17,7 +17,7 @@
 include "mlir/IR/AttrTypeBase.td"
 include "mlir/IR/BuiltinDialect.td"
 include "mlir/IR/BuiltinTypeInterfaces.td"
-include "mlir/IR/QuantizationInterface.td"
+include "mlir/IR/QuantStorageTypeInterface.td"
 include "mlir/IR/CommonTypeConstraints.td"
 
 // TODO: Currently the types defined in this file are prefixed with `Builtin_`.
@@ -102,7 +102,7 @@ class Builtin_CachedFloatType<string name, string mnemonic,
 //===----------------------------------------------------------------------===//
 
 def Builtin_Float8E5M2 : Builtin_FloatType<"Float8E5M2", "f8E5M2", 
-                                   ["QuantizationInterface"]> {
+                                   ["QuantStorageTypeInterface"]> {
   let summary = "8-bit floating point with 2 bit mantissa";
   let description = [{
     An 8-bit floating point type with 1 sign bit, 5 bits exponent and 2 bits
@@ -120,7 +120,7 @@ def Builtin_Float8E5M2 : Builtin_FloatType<"Float8E5M2", "f8E5M2",
   }];
 
   let extraClassDeclaration = [{
-    /// QuantizationInterface method implementations
+    /// QuantStorageTypeInterface method implementations
     bool isStorageSigned() const { return true; }
     /// Get the bit width of this 8-bit floating point type.
     unsigned getStorageWidth() const { return 8; }
@@ -160,7 +160,7 @@ def Builtin_Float8E4M3 : Builtin_FloatType<"Float8E4M3", "f8E4M3"> {
 //===----------------------------------------------------------------------===//
 
 def Builtin_Float8E4M3FN : Builtin_FloatType<"Float8E4M3FN", "f8E4M3FN", 
-                                   ["QuantizationInterface"]> {
+                                   ["QuantStorageTypeInterface"]> {
   let summary = "8-bit floating point with 3 bit mantissa";
   let description = [{
     An 8-bit floating point type with 1 sign bit, 4 bits exponent and 3 bits
@@ -179,7 +179,7 @@ def Builtin_Float8E4M3FN : Builtin_FloatType<"Float8E4M3FN", "f8E4M3FN",
   }];
 
   let extraClassDeclaration = [{
-    /// QuantizationInterface method implementations
+    /// QuantStorageTypeInterface method implementations
     bool isStorageSigned() const { return true; }
     /// Get the bit width of this 8-bit floating point type.
     unsigned getStorageWidth() const { return 8; }
@@ -534,7 +534,7 @@ def Builtin_Index : Builtin_Type<"Index", "index",
 //===----------------------------------------------------------------------===//
 
 def Builtin_Integer : Builtin_Type<"Integer", "integer",
-    [VectorElementTypeInterface, QuantizationInterface]> {
+    [VectorElementTypeInterface, QuantStorageTypeInterface]> {
   let summary = "Integer type with arbitrary precision up to a fixed limit";
   let description = [{
     Syntax:
@@ -592,7 +592,7 @@ def Builtin_Integer : Builtin_Type<"Integer", "integer",
     /// Note: This is aligned with the maximum width of llvm::IntegerType.
     static constexpr unsigned kMaxWidth = (1 << 24) - 1;
 
-    /// QuantizationInterface method implementations
+    /// QuantStorageTypeInterface method implementations
     /// Return true if this is a signed or signless integer type.
     bool isStorageSigned() const { return !isUnsigned(); }
     /// Get the bit width of this integer type.

mlir/include/mlir/IR/CMakeLists.txt

@@ -1,7 +1,7 @@
 add_mlir_interface(SymbolInterfaces)
 add_mlir_interface(RegionKindInterface)
 
-add_mlir_type_interface(QuantizationInterface)
+add_mlir_type_interface(QuantStorageTypeInterface)
 
 set(LLVM_TARGET_DEFINITIONS OpAsmInterface.td)
 mlir_tablegen(OpAsmAttrInterface.h.inc -gen-attr-interface-decls)

mlir/include/mlir/IR/QuantizationInterface.h renamed to mlir/include/mlir/IR/QuantStorageTypeInterface.h

@@ -1,4 +1,4 @@
-//===- QuantizationInterface.h - Quantzation Interfaces --------*- C++
+//===- QuantStorageTypeInterface.h - Quantzation Interfaces --------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_IR_QuantizationInterface_H
-#define MLIR_IR_QuantizationInterface_H
+#ifndef MLIR_IR_QuantStorageTypeInterface_H
+#define MLIR_IR_QuantStorageTypeInterface_H
 
 #include "mlir/IR/Types.h"
 
@@ -17,6 +17,6 @@ namespace mlir {
 class IntegerType;
 } // namespace mlir
 
-#include "mlir/IR/QuantizationInterface.h.inc"
+#include "mlir/IR/QuantStorageTypeInterface.h.inc"
 
-#endif // MLIR_IR_QuantizationInterface_H
+#endif // MLIR_IR_QuantStorageTypeInterface_H

mlir/include/mlir/IR/QuantizationInterface.td renamed to mlir/include/mlir/IR/QuantStorageTypeInterface.td

@@ -1,9 +1,9 @@
-#ifndef MLIR_IR_QUANTIZATIONINTERFACE
-#define MLIR_IR_QUANTIZATIONINTERFACE
+#ifndef MLIR_IR_QUANTSTORAGETYPEINTERFACE
+#define MLIR_IR_QUANTSTORAGETYPEINTERFACE
 
 include "mlir/IR/OpBase.td"
 
-def QuantizationInterface : TypeInterface<"QuantizationInterface"> {
+def QuantStorageTypeInterface : TypeInterface<"QuantStorageTypeInterface"> {
   let description = [{
     Interface for types that can be used as storage types in Quant dialect.
     This interface provides methods to determine storage characteristics for quantization purposes.
@@ -41,4 +41,4 @@ def QuantizationInterface : TypeInterface<"QuantizationInterface"> {
 
 }
 
-#endif // MLIR_IR_QUANTIZATIONINTERFACE
+#endif // MLIR_IR_QUANTSTORAGETYPEINTERFACE

mlir/lib/Dialect/Quant/IR/QuantTypes.cpp

@@ -9,7 +9,7 @@
 #include "mlir/Dialect/Quant/IR/QuantTypes.h"
 #include "TypeDetail.h"
 #include "mlir/Dialect/Quant/IR/Quant.h"
-#include "mlir/IR/QuantizationInterface.h"
+#include "mlir/IR/QuantStorageTypeInterface.h"
 
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/MLIRContext.h"
@@ -47,23 +47,16 @@ QuantizedType::verifyInvariants(function_ref<InFlightDiagnostic()> emitError,
                                 unsigned flags, Type storageType,
                                 Type expressedType, int64_t storageTypeMin,
                                 int64_t storageTypeMax) {
-  // Verify that the storage type is integral.
-  // This restriction may be lifted at some point in favor of using bf16
-  // or f16 as exact representations on hardware where that is advantageous.
-  auto intStorageType = llvm::dyn_cast<IntegerType>(storageType);
-  if (!intStorageType)
-    return emitError() << "storage type must be integral";
-
-  if (auto quantizationInterface =
-          llvm::dyn_cast<QuantizationInterface>(storageType)) {
-    unsigned integralWidth = quantizationInterface.getStorageWidth();
+  if (auto quantStorageTypeInterface =
+          llvm::dyn_cast<QuantStorageTypeInterface>(storageType)) {
+    unsigned integralWidth = quantStorageTypeInterface.getStorageWidth();
 
     // Verify storage width.
     if (integralWidth == 0 || integralWidth > MaxStorageBits)
       return emitError() << "illegal storage type size: " << integralWidth;
 
-    int64_t defaultMin = quantizationInterface.getDefaultMinimum();
-    int64_t defaultMax = quantizationInterface.getDefaultMaximum();
+    int64_t defaultMin = quantStorageTypeInterface.getDefaultMinimum();
+    int64_t defaultMax = quantStorageTypeInterface.getDefaultMaximum();
 
     if (storageTypeMax - storageTypeMin <= 0 || storageTypeMin < defaultMin ||
         storageTypeMax > defaultMax) {
@@ -74,7 +67,7 @@ QuantizedType::verifyInvariants(function_ref<InFlightDiagnostic()> emitError,
     return success();
   }
 
-  return emitError() << "storage type must implement QuantizationInterface";
+  return emitError() << "storage type must implement QuantStorageTypeInterface";
 }
 
 Type QuantizedType::getStorageType() const {
@@ -91,21 +84,21 @@ int64_t QuantizedType::getStorageTypeMax() const {
 
 bool QuantizedType::hasStorageTypeBounds() const {
   Type storageType = static_cast<ImplType *>(impl)->storageType;
-  auto quantizationInterface =
-      llvm::dyn_cast<QuantizationInterface>(storageType);
+  auto quantStorageTypeInterface =
+      llvm::dyn_cast<QuantStorageTypeInterface>(storageType);
 
-  int64_t defaultMin = quantizationInterface.getDefaultMinimum();
-  int64_t defaultMax = quantizationInterface.getDefaultMaximum();
+  int64_t defaultMin = quantStorageTypeInterface.getDefaultMinimum();
+  int64_t defaultMax = quantStorageTypeInterface.getDefaultMaximum();
 
   return defaultMin != getStorageTypeMin() || defaultMax != getStorageTypeMax();
 }
 
 unsigned QuantizedType::getStorageTypeIntegralWidth() const {
   Type storageType = static_cast<ImplType *>(impl)->storageType;
-  auto quantizationInterface =
-      llvm::dyn_cast<QuantizationInterface>(storageType);
+  auto quantStorageTypeInterface =
+      llvm::dyn_cast<QuantStorageTypeInterface>(storageType);
 
-  return quantizationInterface.getStorageWidth();
+  return quantStorageTypeInterface.getStorageWidth();
 }
 
 Type QuantizedType::getExpressedType() const {

mlir/lib/Dialect/Quant/IR/TypeParser.cpp

@@ -10,7 +10,7 @@
 #include "mlir/Dialect/Quant/IR/QuantTypes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/DialectImplementation.h"
-#include "mlir/IR/QuantizationInterface.h"
+#include "mlir/IR/QuantStorageTypeInterface.h"
 #include "mlir/IR/Types.h"
 #include "llvm/ADT/APFloat.h"
 
@@ -29,10 +29,10 @@ static Type parseStorageType(DialectAsmParser &parser, bool &isSigned) {
     if (!succeeded(*result))
       return nullptr;
 
-    if (auto quantizationInterface =
-            llvm::dyn_cast<QuantizationInterface>(type)) {
-      isSigned = quantizationInterface.isStorageSigned();
-      storageTypeWidth = quantizationInterface.getStorageWidth();
+    if (auto quantStorageTypeInterface =
+            llvm::dyn_cast<QuantStorageTypeInterface>(type)) {
+      isSigned = quantStorageTypeInterface.isStorageSigned();
+      storageTypeWidth = quantStorageTypeInterface.getStorageWidth();
     } else {
       parser.emitError(typeLoc, "illegal quantized storage type alias");
       return nullptr;
@@ -67,12 +67,11 @@ static Type parseStorageType(DialectAsmParser &parser, bool &isSigned) {
 static ParseResult parseStorageRange(DialectAsmParser &parser, Type storageType,
                                      int64_t &storageTypeMin,
                                      int64_t &storageTypeMax) {
-  int64_t defaultMin, defaultMax;
-  if (auto quantizationInterface =
-          llvm::dyn_cast<QuantizationInterface>(storageType)) {
-    defaultMin = quantizationInterface.getDefaultMinimum();
-    defaultMax = quantizationInterface.getDefaultMaximum();
-  }
+  auto quantStorageTypeInterface =
+      llvm::dyn_cast<QuantStorageTypeInterface>(storageType);
+
+  int64_t defaultMin = quantStorageTypeInterface.getDefaultMinimum();
+  int64_t defaultMax = quantStorageTypeInterface.getDefaultMaximum();
 
   if (failed(parser.parseOptionalLess())) {
     storageTypeMin = defaultMin;
@@ -496,10 +495,10 @@ Type QuantDialect::parseType(DialectAsmParser &parser) const {
 
 static void printStorageType(QuantizedType type, DialectAsmPrinter &out) {
   // storage type
-  if (auto quantizationInterface =
-          llvm::dyn_cast<QuantizationInterface>(type.getStorageType())) {
-    out << quantizationInterface.getStorageType();
-  }
+  auto quantStorageTypeInterface =
+      llvm::dyn_cast<QuantStorageTypeInterface>(type.getStorageType());
+
+  out << quantStorageTypeInterface.getStorageType();
 
   // storageTypeMin and storageTypeMax if not default.
   if (type.hasStorageTypeBounds()) {

mlir/lib/IR/CMakeLists.txt

@@ -31,7 +31,7 @@ add_mlir_library(MLIRIR
   OperationSupport.cpp
   PatternLoggingListener.cpp
   PatternMatch.cpp
-  QuantizationInterface.cpp  
+  QuantStorageTypeInterface.cpp  
   Region.cpp
   RegionKindInterface.cpp
   Remarks.cpp
@@ -64,7 +64,7 @@ add_mlir_library(MLIRIR
   MLIRCastInterfacesIncGen
   MLIRDataLayoutInterfacesIncGen
   MLIROpAsmInterfaceIncGen
-  MLIRQuantizationInterfaceIncGen
+  MLIRQuantStorageTypeInterfaceIncGen
   MLIRRegionKindInterfaceIncGen
   MLIRSideEffectInterfacesIncGen
   MLIRSymbolInterfacesIncGen
@@ -73,4 +73,3 @@ add_mlir_library(MLIRIR
   LINK_LIBS PUBLIC
   MLIRSupport
   )
-

mlir/lib/IR/QuantizationInterface.cpp renamed to mlir/lib/IR/QuantStorageTypeInterface.cpp

@@ -1,4 +1,4 @@
-//===- QuantizationInterface.cpp
+//===- QuantStorageTypeInterface.cpp
 //------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
@@ -20,4 +20,4 @@ using namespace mlir::detail;
 /// Tablegen Interface Definitions
 //===----------------------------------------------------------------------===//
 
-#include "mlir/IR/QuantizationInterface.cpp.inc"
+#include "mlir/IR/QuantStorageTypeInterface.cpp.inc"