Added interface methods which expose a few basic packing and alignment facts

Author: Roman-Pevnyi

mlir/include/mlir/IR/BuiltinTypes.td

@@ -132,6 +132,18 @@ def Builtin_Float8E5M2 : Builtin_FloatType<"Float8E5M2", "f8E5M2",
 
     /// Get the storage type as a string.
     std::string getStorageType() const { return "f8E5M2"; }
+
+    /// Check if this 8-bit floating point type uses packed representation.
+    bool isPacked() const { return false; }
+
+    /// Get the logical bit width per value for this 8-bit floating point type.
+    unsigned getLogicalBitWidth() const { return 8; }
+
+    /// Get the number of logical elements that fit in one byte for this 8-bit floating point type.
+    unsigned getElementsPerByte() const { return 1; }
+
+    /// Get the preferred alignment in bytes for this 8-bit floating point type.
+    std::optional<unsigned> getPreferredAlignmentBytes() const { return std::nullopt; }
   }];
 }
 
@@ -191,6 +203,18 @@ def Builtin_Float8E4M3FN : Builtin_FloatType<"Float8E4M3FN", "f8E4M3FN",
 
     /// Get the storage type as a string.
     std::string getStorageType() const { return "f8E4M3FN"; }
+
+    /// Check if this 8-bit floating point type uses packed representation.
+    bool isPacked() const { return false; }
+
+    /// Get the logical bit width per value for this 8-bit floating point type.
+    unsigned getLogicalBitWidth() const { return 8; }
+
+    /// Get the number of logical elements that fit in one byte for this 8-bit floating point type.
+    unsigned getElementsPerByte() const { return 1; }
+
+    /// Get the preferred alignment in bytes for this 8-bit floating point type.
+    std::optional<unsigned> getPreferredAlignmentBytes() const { return std::nullopt; }
   }];
 }
 
@@ -617,6 +641,18 @@ def Builtin_Integer : Builtin_Type<"Integer", "integer",
     std::string getStorageType() const {
       return (isStorageSigned() ? "i" : "u") + std::to_string(getWidth());
     }
+
+    /// Check if this integer type uses packed representation.
+    bool isPacked() const { return false; }
+
+    /// Get the logical bit width per value for this integer type.
+    unsigned getLogicalBitWidth() const { return getWidth(); }
+
+    /// Get the number of logical elements that fit in one byte for this integer type.
+    unsigned getElementsPerByte() const { return 1; }
+
+    /// Get the preferred alignment in bytes for this integer type.
+    std::optional<unsigned> getPreferredAlignmentBytes() const { return std::nullopt; }
   }];
 }
 

mlir/include/mlir/IR/QuantStorageTypeInterface.td

@@ -6,7 +6,8 @@ include "mlir/IR/OpBase.td"
 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.
+    This interface provides methods to determine storage characteristics for quantization purposes,
+    including packing behavior, and alignment requirements.
   }];
   let cppNamespace = "::mlir";
 
@@ -18,25 +19,49 @@ def QuantStorageTypeInterface : TypeInterface<"QuantStorageTypeInterface"> {
     "bool", "isStorageSigned", (ins)>,
 
     InterfaceMethod<[{
-      Get the bit width of this integer type.
+      Get the bit width of this type.
       Returns the number of bits used to store values of this type.
     }],
     "unsigned", "getStorageWidth", (ins)>,
 
     InterfaceMethod<[{
-      Get default minimum value for this integer type.
+      Get default minimum value for this type.
     }],
     "int64_t", "getDefaultMinimum", (ins)>,
 
     InterfaceMethod<[{
-      Get default maximum value for this integer type.
+      Get default maximum value for this type.
     }],
     "int64_t", "getDefaultMaximum", (ins)>,
 
     InterfaceMethod<[{
       Get the storage type as a string.
     }],
-    "std::string", "getStorageType", (ins)>
+    "std::string", "getStorageType", (ins)>,
+
+    InterfaceMethod<[{
+      Check if the storage type uses packed representation.
+      Returns true if multiple values are packed into one byte (e.g., sub-byte types),
+      false if value uses full byte.
+    }],
+    "bool", "isPacked", (ins)>,
+
+    InterfaceMethod<[{
+      Get the logical bit width per value.
+      For packed sub-byte types, this may differ from getStorageWidth().
+    }],
+    "unsigned", "getLogicalBitWidth", (ins)>,
+
+    InterfaceMethod<[{
+      Get the number of logical elements that fit in one byte.
+      For packed sub-byte types, this returns how many values can be stored per byte.
+    }],
+    "unsigned", "getElementsPerByte", (ins)>,
+
+    InterfaceMethod<[{
+      Returns the preferred alignment for this type, in bytes.
+    }],
+    "std::optional<unsigned>", "getPreferredAlignmentBytes", (ins)>
   ];
 
 }