[mlir][spirv] NFC: move conversion options out of the type converter

[antiagainst]

Summary

This is a step for adding more options not directly related to type
conversion. Also with this we can now avoid the explicit constructor.

[kuhar]

We cannot make these pass options in .td because they are shared by multiple passes, right?

[antiagainst]

In D133596#3780988, @kuhar wrote:

We cannot make these pass options in .td because they are shared by multiple passes, right?

These are fundamentally controls to the overall conversion. So they are now carried via the type converter, because every pattern have access to the type converter. So yes, in a sense we cannot put them in .td as pass options because all patterns would need them. What's really under the hood is that, passes in MLIR is more for testing purposes; so we expose pass options for testing mostly. Downstream users are expected to use the C++ API and thus the C++ option control, which is more clean and consistent. ;)

mlir/include/mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h

 #include "llvm/ADT/SmallSet.h"
 
 namespace mlir {
 
 //===----------------------------------------------------------------------===//
 // Type Converter
 //===----------------------------------------------------------------------===//
 
-/// Type conversion from builtin types to SPIR-V types for shader interface.
-///
-/// For memref types, this converter additionally performs type wrapping to
-/// satisfy shader interface requirements: shader interface types must be
-/// pointers to structs.
-class SPIRVTypeConverter : public TypeConverter {
-public:
-  struct Options {
-    /// Whether to emulate non-32-bit scalar types with 32-bit scalar types if
-    /// no native support.
-    ///
-    /// Non-32-bit scalar types require special hardware support that may not
-    /// exist on all GPUs. This is reflected in SPIR-V as that non-32-bit scalar
-    /// types require special capabilities or extensions. This option controls
-    /// whether to use 32-bit types to emulate, if a scalar type of a certain
-    /// bitwidth is not supported in the target environment. This requires the
-    /// runtime to also feed in data with a matched bitwidth and layout for
-    /// interface types. The runtime can do that by inspecting the SPIR-V
-    /// module.
-    ///
-    /// If the original scalar type has less than 32-bit, a multiple of its
-    /// values will be packed into one 32-bit value to be memory efficient.
-    bool emulateNon32BitScalarTypes{true};
+struct SPIRVConversionOptions {
 
-    /// Use 64-bit integers to convert index types.
-    bool use64bitIndex{false};
 
-    /// The number of bits to store a boolean value. It is eight bits by
-    /// default.
-    unsigned boolNumBits{8};
-
-    // Note: we need this instead of inline initializers because of
-    // https://bugs.llvm.org/show_bug.cgi?id=36684
-    Options()
-
-    {}
-  };
 
+/// Type conversion from builtin types to SPIR-V types for shader interface.
+///
+/// For memref types, this converter additionally performs type wrapping to
+/// satisfy shader interface requirements: shader interface types must be
+/// pointers to structs.
+class SPIRVTypeConverter : public TypeConverter {
+public:
   explicit SPIRVTypeConverter(spirv::TargetEnvAttr targetAttr,
-                              Options options = {});
+                              const SPIRVConversionOptions &options = {});
 
   /// Gets the SPIR-V correspondence for the standard index type.
   Type getIndexType() const;
 
   const spirv::TargetEnv &getTargetEnv() const { return targetEnv; }
 
   /// Returns the options controlling the SPIR-V type converter.
-  const Options &getOptions() const { return options; }
+  const SPIRVConversionOptions &getOptions() const { return options; }
 
 private:
   spirv::TargetEnv targetEnv;
-  Options options;
+  SPIRVConversionOptions options;
 
   MLIRContext *getContext() const;
 };
 
 //===----------------------------------------------------------------------===//
 // Conversion Target
 //===----------------------------------------------------------------------===//
 

mlir/lib/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.cpp

 namespace {
 struct ConvertArithmeticToSPIRVPass
     : public impl::ConvertArithmeticToSPIRVBase<ConvertArithmeticToSPIRVPass> {
   void runOnOperation() override {
     Operation *op = getOperation();
     auto targetAttr = spirv::lookupTargetEnvOrDefault(op);
     auto target = SPIRVConversionTarget::get(targetAttr);
 
-    SPIRVTypeConverter::Options options;
+    SPIRVConversionOptions options;
     options.emulateNon32BitScalarTypes = this->emulateNon32BitScalarTypes;
     SPIRVTypeConverter typeConverter(targetAttr, options);
 
     // Use UnrealizedConversionCast as the bridge so that we don't need to pull
     // in patterns for other dialects.
     auto addUnrealizedCast = [](OpBuilder &builder, Type type,
                                 ValueRange inputs, Location loc) {
       auto cast = builder.create<UnrealizedConversionCastOp>(loc, type, inputs);

mlir/lib/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRVPass.cpp

 void ConvertControlFlowToSPIRVPass::runOnOperation() {
   MLIRContext *context = &getContext();
   Operation *op = getOperation();
 
   auto targetAttr = spirv::lookupTargetEnvOrDefault(op);
   std::unique_ptr<ConversionTarget> target =
       SPIRVConversionTarget::get(targetAttr);
 
-  SPIRVTypeConverter::Options options;
+  SPIRVConversionOptions options;
   options.emulateNon32BitScalarTypes = this->emulateNon32BitScalarTypes;
   SPIRVTypeConverter typeConverter(targetAttr, options);
 
   RewritePatternSet patterns(context);
   cf::populateControlFlowToSPIRVPatterns(typeConverter, patterns);
 
   if (failed(applyPartialConversion(op, *target, std::move(patterns))))
     return signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<>> mlir::createConvertControlFlowToSPIRVPass() {
   return std::make_unique<ConvertControlFlowToSPIRVPass>();
 }

mlir/lib/Conversion/FuncToSPIRV/FuncToSPIRVPass.cpp

 void ConvertFuncToSPIRVPass::runOnOperation() {
   MLIRContext *context = &getContext();
   Operation *op = getOperation();
 
   auto targetAttr = spirv::lookupTargetEnvOrDefault(op);
   std::unique_ptr<ConversionTarget> target =
       SPIRVConversionTarget::get(targetAttr);
 
-  SPIRVTypeConverter::Options options;
+  SPIRVConversionOptions options;
   options.emulateNon32BitScalarTypes = this->emulateNon32BitScalarTypes;
   SPIRVTypeConverter typeConverter(targetAttr, options);
 
   RewritePatternSet patterns(context);
   populateFuncToSPIRVPatterns(typeConverter, patterns);
   populateBuiltinFuncToSPIRVPatterns(typeConverter, patterns);
 
   if (failed(applyPartialConversion(op, *target, std::move(patterns))))
     return signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<>> mlir::createConvertFuncToSPIRVPass() {
   return std::make_unique<ConvertFuncToSPIRVPass>();
 }

mlir/lib/Conversion/MemRefToSPIRV/MemRefToSPIRVPass.cpp

 void ConvertMemRefToSPIRVPass::runOnOperation() {
   MLIRContext *context = &getContext();
   Operation *op = getOperation();
 
   auto targetAttr = spirv::lookupTargetEnvOrDefault(op);
   std::unique_ptr<ConversionTarget> target =
       SPIRVConversionTarget::get(targetAttr);
 
-  SPIRVTypeConverter::Options options;
+  SPIRVConversionOptions options;
   options.boolNumBits = this->boolNumBits;
   SPIRVTypeConverter typeConverter(targetAttr, options);
 
   // Use UnrealizedConversionCast as the bridge so that we don't need to pull in
   // patterns for other dialects.
   auto addUnrealizedCast = [](OpBuilder &builder, Type type, ValueRange inputs,
                               Location loc) {
     auto cast = builder.create<UnrealizedConversionCastOp>(loc, type, inputs);

mlir/lib/Conversion/TensorToSPIRV/TensorToSPIRVPass.cpp

class ConvertTensorToSPIRVPass
   void runOnOperation() override {
     MLIRContext *context = &getContext();
     Operation *op = getOperation();
 
     auto targetAttr = spirv::lookupTargetEnvOrDefault(op);
     std::unique_ptr<ConversionTarget> target =
         SPIRVConversionTarget::get(targetAttr);
 
-    SPIRVTypeConverter::Options options;
+    SPIRVConversionOptions options;
     options.emulateNon32BitScalarTypes = this->emulateNon32BitScalarTypes;
     SPIRVTypeConverter typeConverter(targetAttr, options);
 
     RewritePatternSet patterns(context);
     arith::populateArithmeticToSPIRVPatterns(typeConverter, patterns);
     populateFuncToSPIRVPatterns(typeConverter, patterns);
     populateTensorToSPIRVPatterns(typeConverter, /*byteCountThreshold=*/64,
                                   patterns);

mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp

 }
 
 MLIRContext *SPIRVTypeConverter::getContext() const {
   return targetEnv.getAttr().getContext();
 }
 
 // TODO: This is a utility function that should probably be exposed by the
 // SPIR-V dialect. Keeping it local till the use case arises.
-static Optional<int64_t>
-getTypeNumBytes(const SPIRVTypeConverter::Options &options, Type type) {
+static Optional<int64_t> getTypeNumBytes(const SPIRVConversionOptions &options,
+                                         Type type) {
   if (type.isa<spirv::ScalarType>()) {
     auto bitWidth = type.getIntOrFloatBitWidth();
     // According to the SPIR-V spec:
     // "There is no physical size or bit pattern defined for values with boolean
     // type. If they are stored (in conjunction with OpVariable), they can only
     // be used with logical addressing operations, not physical, and only with
     // non-externally visible shader Storage Classes: Workgroup, CrossWorkgroup,
     // Private, Function, Input, and Output."
static Optional<int64_t> getTypeNumBytes(const SPIRVConversionOptions &options,
   }
 
   // TODO: Add size computation for other types.
   return llvm::None;
 }
 
 /// Converts a scalar `type` to a suitable type under the given `targetEnv`.
 static Type convertScalarType(const spirv::TargetEnv &targetEnv,
-                              const SPIRVTypeConverter::Options &options,
+                              const SPIRVConversionOptions &options,
                               spirv::ScalarType type,
                               Optional<spirv::StorageClass> storageClass = {}) {
   // Get extension and capability requirements for the given type.
   SmallVector<ArrayRef<spirv::Extension>, 1> extensions;
   SmallVector<ArrayRef<spirv::Capability>, 2> capabilities;
   type.getExtensions(extensions, storageClass);
   type.getCapabilities(capabilities, storageClass);
 
static Type convertScalarType(const spirv::TargetEnv &targetEnv,
   auto intType = type.cast<IntegerType>();
   LLVM_DEBUG(llvm::dbgs() << type << " converted to 32-bit for SPIR-V\n");
   return IntegerType::get(targetEnv.getContext(), /*width=*/32,
                           intType.getSignedness());
 }
 
 /// Converts a vector `type` to a suitable type under the given `targetEnv`.
 static Type convertVectorType(const spirv::TargetEnv &targetEnv,
-                              const SPIRVTypeConverter::Options &options,
+                              const SPIRVConversionOptions &options,
                               VectorType type,
                               Optional<spirv::StorageClass> storageClass = {}) {
   if (type.getRank() <= 1 && type.getNumElements() == 1)
     return type.getElementType();
 
   if (!spirv::CompositeType::isValid(type)) {
     // TODO: Vector types with more than four elements can be translated into
     // array types.

 
 /// Converts a tensor `type` to a suitable type under the given `targetEnv`.
 ///
 /// Note that this is mainly for lowering constant tensors. In SPIR-V one can
 /// create composite constants with OpConstantComposite to embed relative large
 /// constant values and use OpCompositeExtract and OpCompositeInsert to
 /// manipulate, like what we do for vectors.
 static Type convertTensorType(const spirv::TargetEnv &targetEnv,
-                              const SPIRVTypeConverter::Options &options,
+                              const SPIRVConversionOptions &options,
                               TensorType type) {
   // TODO: Handle dynamic shapes.
   if (!type.hasStaticShape()) {
     LLVM_DEBUG(llvm::dbgs()
                << type << " illegal: dynamic shape unimplemented\n");
     return nullptr;
   }
 
LLVM_DEBUG(llvm::dbgs()
                << type << " illegal: cannot deduce converted element size\n");
     return nullptr;
   }
 
   return spirv::ArrayType::get(arrayElemType, arrayElemCount);
 }
 
 static Type convertBoolMemrefType(const spirv::TargetEnv &targetEnv,
-                                  const SPIRVTypeConverter::Options &options,
+                                  const SPIRVConversionOptions &options,
                                   MemRefType type,
                                   spirv::StorageClass storageClass) {
   unsigned numBoolBits = options.boolNumBits;
   if (numBoolBits != 8) {
     LLVM_DEBUG(llvm::dbgs()
                << "using non-8-bit storage for bool types unimplemented");
     return nullptr;
   }
static Type convertBoolMemrefType(const spirv::TargetEnv &targetEnv,
   auto arrayElemCount = llvm::divideCeil(memrefSize, *arrayElemSize);
   int64_t stride = needsExplicitLayout(storageClass) ? *arrayElemSize : 0;
   auto arrayType = spirv::ArrayType::get(arrayElemType, arrayElemCount, stride);
 
   return wrapInStructAndGetPointer(arrayType, storageClass);
 }
 
 static Type convertMemrefType(const spirv::TargetEnv &targetEnv,
-                              const SPIRVTypeConverter::Options &options,
+                              const SPIRVConversionOptions &options,
                               MemRefType type) {
   auto attr = type.getMemorySpace().dyn_cast_or_null<spirv::StorageClassAttr>();
   if (!attr) {
     LLVM_DEBUG(
         llvm::dbgs()
         << type
         << " illegal: expected memory space to be a SPIR-V storage class "
            "attribute; please use MemorySpaceToStorageClassConverter to map "
static Type convertMemrefType(const spirv::TargetEnv &targetEnv,
   auto arrayElemCount = llvm::divideCeil(*memrefSize, *arrayElemSize);
   int64_t stride = needsExplicitLayout(storageClass) ? *arrayElemSize : 0;
   auto arrayType = spirv::ArrayType::get(arrayElemType, arrayElemCount, stride);
 
   return wrapInStructAndGetPointer(arrayType, storageClass);
 }
 
 SPIRVTypeConverter::SPIRVTypeConverter(spirv::TargetEnvAttr targetAttr,
-                                       Options options)
+                                       const SPIRVConversionOptions &options)
     : targetEnv(targetAttr), options(options) {
   // Add conversions. The order matters here: later ones will be tried earlier.
 
   // Allow all SPIR-V dialect specific types. This assumes all builtin types
   // adopted in the SPIR-V dialect (i.e., IntegerType, FloatType, VectorType)
   // were tried before.
   //
   // TODO: this assumes that the SPIR-V types are valid to use in