Add a create function for mlir::SerializeToCubinPass

[bondhugula]

mlir/include/mlir/Dialect/GPU/Transforms/Passes.h

129–131

Any reason to default this to old hardware - how about sm_80 instead?

mlir/lib/Dialect/GPU/Transforms/SerializeToCubin.cpp

148–149

No need to duplicate the doc comment here.

[herhut]

Not sure about the defaults but looks good otherwise. Also +1 to @bondhugula comments. Please address those first.

mlir/include/mlir/Dialect/GPU/Transforms/Passes.h

129–131

Why do we need to give these defaults, at all?

[ivanradanov]

• Default arg and comment fix

[ivanradanov]

mlir/include/mlir/Dialect/GPU/Transforms/Passes.h

129–131

@bondhugula @herhut I have removed the default arguments here, and left newer defaults ones in the class constructor - should help someone immediately know what should go in there at a glance.

mlir/lib/Dialect/GPU/Transforms/SerializeToCubin.cpp

148–149

Removed.

[akuegel]

Changing the defaults makes some integration tests fail if a toolchain doesn't support sm_80, e.g. mlir/test/Integration/GPU/CUDA:all-reduce-max.mlir.test

Error: failed with error code the provided PTX was compiled with an unsupported toolchain.[ptxas application ptx input, line 5; fatal : Unsupported .version 7.5; current version is '7.4']

Was it really necessary to also change the defaults?

mlir/include/mlir/Dialect/GPU/Transforms/Passes.h

 /// Register pass to serialize GPU kernel functions to a CUBIN binary
 /// annotation.
 void registerGpuSerializeToCubinPass();
 
 /// Register pass to serialize GPU kernel functions to a HSAco binary
 /// annotation.
 void registerGpuSerializeToHsacoPass();
 
+/// Create an instance of the GPU kernel function to CUBIN binary serialization
+/// pass.
+std::unique_ptr<Pass>
+createGpuSerializeToCubinPass(StringRef triple = "nvptx64-nvidia-cuda",
+                              StringRef chip = "sm_35",
+                              StringRef features = "+ptx60");
 /// Create an instance of the GPU kernel function to HSAco binary serialization
 /// pass.
 std::unique_ptr<Pass> createGpuSerializeToHsacoPass(StringRef triple,
                                                     StringRef arch,
                                                     StringRef features,
                                                     int optLevel);
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/GPU/Transforms/Passes.h.inc"
 
 } // namespace mlir
 
 #endif // MLIR_DIALECT_GPU_TRANSFORMS_PASSES_H_

mlir/lib/Dialect/GPU/Transforms/SerializeToCubin.cpp

#define RETURN_ON_CUDA_ERROR(expr)                                             \
   } while (false)
 
 namespace {
 class SerializeToCubinPass
     : public PassWrapper<SerializeToCubinPass, gpu::SerializeToBlobPass> {
 public:
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SerializeToCubinPass)
 
-  SerializeToCubinPass();
+  SerializeToCubinPass(StringRef triple = "nvptx64-nvidia-cuda",
+                       StringRef chip = "sm_35", StringRef features = "+ptx60");
 
   StringRef getArgument() const override { return "gpu-to-cubin"; }
   StringRef getDescription() const override {
     return "Lower GPU kernel function to CUBIN binary annotations";
   }
 
 private:
   void getDependentDialects(DialectRegistry &registry) const override;
 
   // Serializes PTX to CUBIN.
   std::unique_ptr<std::vector<char>>
   serializeISA(const std::string &isa) override;
 };
 } // namespace
 
 // Sets the 'option' to 'value' unless it already has a value.
-static void maybeSetOption(Pass::Option<std::string> &option,
-                           const char *value) {
+static void maybeSetOption(Pass::Option<std::string> &option, StringRef value) {
   if (!option.hasValue())
-    option = value;
+    option = value.str();
 }
 
-SerializeToCubinPass::SerializeToCubinPass() {
-  maybeSetOption(this->triple, "nvptx64-nvidia-cuda");
-  maybeSetOption(this->chip, "sm_35");
-  maybeSetOption(this->features, "+ptx60");
+SerializeToCubinPass::SerializeToCubinPass(StringRef triple, StringRef chip,
+                                           StringRef features) {
+  maybeSetOption(this->triple, triple);
+  maybeSetOption(this->chip, chip);
+  maybeSetOption(this->features, features);
 }
 
 void SerializeToCubinPass::getDependentDialects(
     DialectRegistry &registry) const {
   registerNVVMDialectTranslation(registry);
   gpu::SerializeToBlobPass::getDependentDialects(registry);
 }
 
PassRegistration<SerializeToCubinPass> registerSerializeToCubin([] {
     LLVMInitializeNVPTXTarget();
     LLVMInitializeNVPTXTargetInfo();
     LLVMInitializeNVPTXTargetMC();
     LLVMInitializeNVPTXAsmPrinter();
 
     return std::make_unique<SerializeToCubinPass>();
   });
 }
+
+/// Create an instance of the GPU kernel function to CUBIN binary serialization
+/// pass.
+std::unique_ptr<Pass> mlir::createGpuSerializeToCubinPass(StringRef triple,
+                                                          StringRef arch,
+                                                          StringRef features) {
+  return std::make_unique<SerializeToCubinPass>(triple, arch, features);
+}
+
 #else  // MLIR_GPU_TO_CUBIN_PASS_ENABLE
 void mlir::registerGpuSerializeToCubinPass() {}
 #endif // MLIR_GPU_TO_CUBIN_PASS_ENABLE