Enable quantization for FP4 type

Author: Jacenty-And-Intel

mlir/include/mlir/Dialect/Quant/IR/QuantTypes.h

@@ -97,6 +97,12 @@ class QuantizedType : public Type {
     return -getDefaultMaximumForF8E5M2();
   }
 
+  static constexpr int64_t getDefaultMaximumForF4E2M1FN() { return 6; }
+
+  static constexpr int64_t getDefaultMinimumForF4E2M1FN() {
+    return -getDefaultMaximumForF4E2M1FN();
+  }
+
   /// Gets the original expressed type that this quantized type approximates.
   /// Note that this presumes that the quantized type was always derived from
   /// a floating point type, which in the broadest definition, is not true (i.e.
@@ -267,7 +273,7 @@ class AnyQuantizedType
 ///   Per-layer, optional parameters omitted:
 ///     !quant<uniform[StorageType]{Scale}>
 ///
-///   StorageType: 'i'|'u' NumBits
+///   StorageType: 'i'|'u' NumBits, 'f4', 'hf8', 'bf8'
 ///   ExpressedType: 'f16', 'f32', 'bf16', 'f64'
 ///   Scale: A legal double value
 ///   ZeroPoint: An integer value
@@ -327,7 +333,7 @@ class UniformQuantizedType
 ///   Per-axis, optional parameters omitted:
 ///     !quant<uniform[StorageType]{Scale}>
 ///
-///   StorageType: 'i'|'u' NumBits
+///   StorageType: 'i'|'u' NumBits, 'f4', 'hf8', 'bf8'
 ///   ExpressedType: 'f16', 'f32', 'bf16', 'f64'
 ///   QuantizedDim: An integer value
 ///   QuantParams: (Scale ':' ZeroPoint)+
@@ -401,149 +407,6 @@ class UniformQuantizedPerAxisType
   }
 };
 
-/// QuantileQuantizedType derives from UniformQuantizedType and adds to it a
-/// look up table array of quantile values. The type of the data in the look up
-/// table is determined by the quantileType member: supported quantileType types
-/// are integer/unsigned/hf8/bf8/f16/bf16/f32/f64.
-///
-/// Syntax synopsis:
-///   Per-layer, all parameters expressed:
-///     !quant<quantile[StorageType:QuantileType:ExpressedType]{Quantiles}:{Scale:ZeroPoint}>
-///   Per-layer, optional parameters omitted:
-///     !quant<quantile[StorageType:QuantileType]{Quantiles}:{Scale}>
-///
-///   StorageType: 'i'|'u' NumBits
-///   QuantileType: 'i'|'u' NumBits, 'hf8', 'bf8', 'f16', 'bf16', 'f32', 'f64'
-///   ExpressedType: 'f16', 'f32', 'bf16', 'f64'
-///   Quantiles: Quantile+
-///   Quantile: A legal double value
-///   Scale: A legal double value
-///   ZeroPoint: An integer value
-class QuantileQuantizedType
-    : public Type::TypeBase<QuantileQuantizedType, UniformQuantizedType,
-                            detail::QuantileQuantizedTypeStorage> {
-public:
-  using Base::Base;
-  using Base::getChecked;
-
-  static constexpr StringLiteral name = "quant.quantile";
-
-  /// Gets an instance of the type with all parameters specified but not
-  /// checked.
-  static QuantileQuantizedType get(unsigned flags, Type storageType,
-                                   Type quantileType, Type expressedType,
-                                   ArrayRef<double> quantiles, double scale,
-                                   int64_t zeroPoint, int64_t storageTypeMin,
-                                   int64_t storageTypeMax);
-
-  static QuantileQuantizedType
-  getChecked(function_ref<InFlightDiagnostic()> emitError, unsigned flags,
-             Type storageType, Type quantileType, Type expressedType,
-             ArrayRef<double> quantiles, double scale, int64_t zeroPoint,
-             int64_t storageTypeMin, int64_t storageTypeMax);
-
-  /// Verifies construction invariants and issues errors/warnings.
-  static LogicalResult
-  verifyInvariants(function_ref<InFlightDiagnostic()> emitError, unsigned flags,
-                   Type storageType, Type quantileType, Type expressedType,
-                   ArrayRef<double> quantiles, double scale, int64_t zeroPoint,
-                   int64_t storageTypeMin, int64_t storageTypeMax);
-
-  static bool classof(mlir::Type type);
-
-  /// Gets the quantileType
-  Type getQuantileType() const;
-
-  /// Gets the quantileType bit width
-  unsigned getQuantileTypeIntegralWidth() const;
-
-  /// Gets the quantile values
-  ArrayRef<double> getQuantiles() const;
-
-  // Fixed point values are real numbers divided by a scale.
-  // Currently, only signed storage types are treated as fixed point.
-  // A fixed point value can be obtained from an affine value by subtracting
-  // the zeroPoint.
-  // In the future, this may be explicit versus implied by type and zeroPoint.
-  bool isFixedPoint() const { return isSigned() && getZeroPoint() == 0; }
-};
-
-/// Represents per-axis QuantileQuantizedType (also known as per-channel
-/// quantization). The type of the data in the look up table is determined by
-/// the quantileType member: supported quantileType types are
-/// integer/unsigned/hf8/bf8/f16/bf16/f32/f64.
-///
-/// Syntax synopsis:
-///   Per-axis, all parameters expressed:
-///     !quant<quantile[StorageType:QuantileType:ExpressedType:QuantizedDim]{Quantiles}:{QuantParams}>
-///   Per-axis, optional parameters omitted:
-///     !quant<quantile[StorageType:QuantileType]{Quantiles}:{Scale}>
-///
-///   StorageType: 'i'|'u' NumBits
-///   QuantileType: 'i'|'u' NumBits, 'hf8', 'bf8', 'f16', 'bf16', 'f32', 'f64'
-///   ExpressedType: 'f16', 'f32', 'bf16', 'f64'
-///   QuantizedDim: An integer value
-///   Quantiles: Quantile+
-///   Quantile: A legal double value
-///   QuantParams: (Scale ':' ZeroPoint)+
-///   Scale: A legal double value
-///   ZeroPoint: An integer value
-class QuantileQuantizedPerAxisType
-    : public Type::TypeBase<QuantileQuantizedPerAxisType,
-                            UniformQuantizedPerAxisType,
-                            detail::QuantileQuantizedPerAxisTypeStorage> {
-public:
-  using Base::Base;
-  using Base::getChecked;
-
-  static constexpr StringLiteral name = "quant.quantile_per_axis";
-
-  /// Gets an instance of the type with all parameters specified but not
-  /// checked.
-  static QuantileQuantizedPerAxisType
-  get(unsigned flags, Type storageType, Type quantileType, Type expressedType,
-      ArrayRef<double> quantiles, ArrayRef<double> scales,
-      ArrayRef<int64_t> zeroPoints, int32_t quantizedDimension,
-      int64_t storageTypeMin, int64_t storageTypeMax);
-
-  /// Gets an instance of the type with all specified parameters checked.
-  /// Returns a nullptr convertible type on failure.
-  static QuantileQuantizedPerAxisType
-  getChecked(function_ref<InFlightDiagnostic()> emitError, unsigned flags,
-             Type storageType, Type quantileType, Type expressedType,
-             ArrayRef<double> quantiles, ArrayRef<double> scales,
-             ArrayRef<int64_t> zeroPoints, int32_t quantizedDimension,
-             int64_t storageTypeMin, int64_t storageTypeMax);
-
-  /// Verifies construction invariants and issues errors/warnings.
-  static LogicalResult
-  verifyInvariants(function_ref<InFlightDiagnostic()> emitError, unsigned flags,
-                   Type storageType, Type quantileType, Type expressedType,
-                   ArrayRef<double> quantiles, ArrayRef<double> scales,
-                   ArrayRef<int64_t> zeroPoints, int32_t quantizedDimension,
-                   int64_t storageTypeMin, int64_t storageTypeMax);
-
-  static bool classof(mlir::Type type);
-
-  /// Gets the quantileType
-  Type getQuantileType() const;
-
-  /// Gets the quantileType bit width
-  unsigned getQuantileTypeIntegralWidth() const;
-
-  /// Gets the quantile values
-  ArrayRef<double> getQuantiles() const;
-
-  /// Fixed point values are real numbers divided by a scale.
-  /// Currently, only signed storage types are treated as fixed point.
-  /// A fixed point value can be obtained from an affine value by subtracting
-  /// the zeroPoint.
-  /// In the future, this may be explicit versus implied by type and zeroPoint.
-  bool isFixedPoint() const {
-    return isSigned() && !llvm::is_contained(getZeroPoints(), 0);
-  }
-};
-
 /// Represents sub-channel (also known as blockwise quantization).
 ///
 /// Syntax synopsis:
@@ -557,7 +420,7 @@ class QuantileQuantizedPerAxisType
 ///   ScaleZeroList  ::= ScaleZero (',' ScaleZero)*
 ///   ScaleZero ::= Scale (':' ZeroPoint)?
 ///
-///   StorageType: 'i'|'u' NumBits
+///   StorageType: 'i'|'u' NumBits, 'f4', 'hf8', 'bf8'
 ///   ExpressedType: 'f16', 'f32', 'bf16', 'f64'
 ///   AxisSpec: An integer value
 ///   BlockSizeSpec: An integer value
@@ -674,6 +537,145 @@ class UniformQuantizedSubChannelType
   const SmallVector<std::pair<int32_t, int64_t>> getBlockSizeInfo() const;
 };
 
+/// QuantileQuantizedType derives from UniformQuantizedType and adds to it a
+/// look up table array of quantile values. The type of the data in the look up
+/// table is determined by the quantileType member: supported quantileType types
+/// are integer/unsigned/f4/hf8/bf8/f16/bf16/f32/f64.
+///
+/// Syntax synopsis:
+///   Per-layer, all parameters expressed:
+///     !quant<quantile[StorageType:QuantileType:ExpressedType]{Quantiles}:{Scale:ZeroPoint}>
+///   Per-layer, optional parameters omitted:
+///     !quant<quantile[StorageType:QuantileType]{Quantiles}:{Scale}>
+///
+///   StorageType: 'i'|'u' NumBits, 'f4', 'hf8', 'bf8'
+///   QuantileType: 'i'|'u' NumBits, 'f4', 'hf8', 'bf8', 'f16', 'bf16', 'f32',
+///   'f64' ExpressedType: 'f16', 'f32', 'bf16', 'f64' Quantiles: Quantile+
+///   Quantile: A legal double value
+///   Scale: A legal double value
+///   ZeroPoint: An integer value
+class QuantileQuantizedType
+    : public Type::TypeBase<QuantileQuantizedType, UniformQuantizedType,
+                            detail::QuantileQuantizedTypeStorage> {
+public:
+  using Base::Base;
+  using Base::getChecked;
+
+  static constexpr StringLiteral name = "quant.quantile";
+
+  /// Gets an instance of the type with all parameters specified but not
+  /// checked.
+  static QuantileQuantizedType get(unsigned flags, Type storageType,
+                                   Type quantileType, Type expressedType,
+                                   ArrayRef<double> quantiles, double scale,
+                                   int64_t zeroPoint, int64_t storageTypeMin,
+                                   int64_t storageTypeMax);
+
+  static QuantileQuantizedType
+  getChecked(function_ref<InFlightDiagnostic()> emitError, unsigned flags,
+             Type storageType, Type quantileType, Type expressedType,
+             ArrayRef<double> quantiles, double scale, int64_t zeroPoint,
+             int64_t storageTypeMin, int64_t storageTypeMax);
+
+  /// Verifies construction invariants and issues errors/warnings.
+  static LogicalResult
+  verifyInvariants(function_ref<InFlightDiagnostic()> emitError, unsigned flags,
+                   Type storageType, Type quantileType, Type expressedType,
+                   ArrayRef<double> quantiles, double scale, int64_t zeroPoint,
+                   int64_t storageTypeMin, int64_t storageTypeMax);
+
+  static bool classof(mlir::Type type);
+
+  /// Gets the quantileType
+  Type getQuantileType() const;
+
+  /// Gets the quantileType bit width
+  unsigned getQuantileTypeIntegralWidth() const;
+
+  /// Gets the quantile values
+  ArrayRef<double> getQuantiles() const;
+
+  // Fixed point values are real numbers divided by a scale.
+  // Currently, only signed storage types are treated as fixed point.
+  // A fixed point value can be obtained from an affine value by subtracting
+  // the zeroPoint.
+  // In the future, this may be explicit versus implied by type and zeroPoint.
+  bool isFixedPoint() const { return isSigned() && getZeroPoint() == 0; }
+};
+
+/// Represents per-axis QuantileQuantizedType (also known as per-channel
+/// quantization). The type of the data in the look up table is determined by
+/// the quantileType member: supported quantileType types are
+/// integer/unsigned/f4/hf8/bf8/f16/bf16/f32/f64.
+///
+/// Syntax synopsis:
+///   Per-axis, all parameters expressed:
+///     !quant<quantile[StorageType:QuantileType:ExpressedType:QuantizedDim]{Quantiles}:{QuantParams}>
+///   Per-axis, optional parameters omitted:
+///     !quant<quantile[StorageType:QuantileType]{Quantiles}:{Scale}>
+///
+///   StorageType: 'i'|'u' NumBits, 'f4', 'hf8', 'bf8'
+///   QuantileType: 'i'|'u' NumBits, 'f4', 'hf8', 'bf8', 'f16', 'bf16', 'f32',
+///   'f64' ExpressedType: 'f16', 'f32', 'bf16', 'f64' QuantizedDim: An integer
+///   value Quantiles: Quantile+ Quantile: A legal double value QuantParams:
+///   (Scale ':' ZeroPoint)+ Scale: A legal double value ZeroPoint: An integer
+///   value
+class QuantileQuantizedPerAxisType
+    : public Type::TypeBase<QuantileQuantizedPerAxisType,
+                            UniformQuantizedPerAxisType,
+                            detail::QuantileQuantizedPerAxisTypeStorage> {
+public:
+  using Base::Base;
+  using Base::getChecked;
+
+  static constexpr StringLiteral name = "quant.quantile_per_axis";
+
+  /// Gets an instance of the type with all parameters specified but not
+  /// checked.
+  static QuantileQuantizedPerAxisType
+  get(unsigned flags, Type storageType, Type quantileType, Type expressedType,
+      ArrayRef<double> quantiles, ArrayRef<double> scales,
+      ArrayRef<int64_t> zeroPoints, int32_t quantizedDimension,
+      int64_t storageTypeMin, int64_t storageTypeMax);
+
+  /// Gets an instance of the type with all specified parameters checked.
+  /// Returns a nullptr convertible type on failure.
+  static QuantileQuantizedPerAxisType
+  getChecked(function_ref<InFlightDiagnostic()> emitError, unsigned flags,
+             Type storageType, Type quantileType, Type expressedType,
+             ArrayRef<double> quantiles, ArrayRef<double> scales,
+             ArrayRef<int64_t> zeroPoints, int32_t quantizedDimension,
+             int64_t storageTypeMin, int64_t storageTypeMax);
+
+  /// Verifies construction invariants and issues errors/warnings.
+  static LogicalResult
+  verifyInvariants(function_ref<InFlightDiagnostic()> emitError, unsigned flags,
+                   Type storageType, Type quantileType, Type expressedType,
+                   ArrayRef<double> quantiles, ArrayRef<double> scales,
+                   ArrayRef<int64_t> zeroPoints, int32_t quantizedDimension,
+                   int64_t storageTypeMin, int64_t storageTypeMax);
+
+  static bool classof(mlir::Type type);
+
+  /// Gets the quantileType
+  Type getQuantileType() const;
+
+  /// Gets the quantileType bit width
+  unsigned getQuantileTypeIntegralWidth() const;
+
+  /// Gets the quantile values
+  ArrayRef<double> getQuantiles() const;
+
+  /// Fixed point values are real numbers divided by a scale.
+  /// Currently, only signed storage types are treated as fixed point.
+  /// A fixed point value can be obtained from an affine value by subtracting
+  /// the zeroPoint.
+  /// In the future, this may be explicit versus implied by type and zeroPoint.
+  bool isFixedPoint() const {
+    return isSigned() && !llvm::is_contained(getZeroPoints(), 0);
+  }
+};
+
 /// A quantized type that infers its range from given min/max values.
 ///
 /// Typical syntax: